DivitMittal/ai-nixCfg：面向 AI 编程助手的 Nix home-manager 配置

Nix home-manager modules and personal configurations for AI coding assistants, LLM tools, MCP integrations, voice input, and agent orchestration.

Table of Contents

• Overview
• Architecture
• Quick Start
• As a Flake Input
• Using Reusable Modules
• Using Personal Configurations (Cfg)
• Tool Configurations
• Shared Content Library (_common)
  • Commands
  • Skills
  • Agents
  • Rules
• MCP Servers
• Voice & Browser
• Optimization & Orchestration
• Custom Packages
• CI & Pre-commit
• Project Structure
• Conventions
• Commands
• Related Repositories
• For AI Agents

Overview

This repository provides reusable Nix home-manager modules and personal configurations for a complete AI development toolkit — declarative, reproducible, and platform-aware (Linux + macOS). It includes agentic coding assistants, LLM CLIs, MCP integrations, voice input via Talon, terminal multiplexers for agents, token-compression proxies, and a curated set of custom packages.

Tool Catalog

Architecture

graph TD
    subgraph "flake.nix"
        F[Flake Entry]
    end

    F --> FP[flake/<br/>flake-parts modules]
    F --> MOD[modules/<br/>home-manager modules]
    F --> CFG[config/<br/>personal configurations]
    F --> PKG[pkgs/<br/>custom packages]

    FP --> FApps[apps.nix<br/>#ai shell]
    FP --> FChecks[checks.nix<br/>prek hooks]
    FP --> FDev[devshells.nix<br/>nixd, alejandra, nvfetcher]
    FP --> FFmt[formatters.nix<br/>treefmt-nix]
    FP --> FSand[sandnix.nix<br/>sandboxed claude]
    FP --> FAct[actions/<br/>CI workflows]

    MOD --> Mccs[ccs.nix]
    MOD --> Mcodex[codex.nix]
    MOD --> Mcrush[crush.nix]
    MOD --> Mherdr[herdr.nix]
    MOD --> Mn8n[n8n.nix]
    MOD --> Mralph[ralph-tui.nix]
    MOD --> Mtalon[talon.nix]
    MOD --> Mghnf[ghnf.nix]

    CFG --> CHome[home/]
    CHome --> CSet[setup.nix]
    CHome --> CCoding[coding/]
    CHome --> CCli[cli/]
    CHome --> CCld[cloud.nix]
    CHome --> CMcp[mcp.nix]
    CHome --> CAsst[assistants/]
    CHome --> CVoic[voice.nix]
    CHome --> CBrws[browser.nix]
    CHome --> CGui[gui.nix]
    CHome --> CMult[multiplexers.nix]
    CHome --> COpt[optimization/]
    CHome --> COrc[orchestration.nix]
    CHome --> CRvw[review.nix]
    CHome --> CTsk[tasks.nix]
    CHome --> CUsg[usage.nix]
    CHome --> CWfl[workflows.nix]

    CCoding --> CCom[_common/<br/>commands, skills,<br/>agents, rules]
    CCoding --> CClaud[claude/]
    CCoding --> CCodx[codex/]
    CCoding --> CCopi[copilot-cli/]
    CCoding --> COpen[opencode/]
    CCoding --> CCrush[crush/]
    CCoding --> CAnti[antigravity-cli/]
    CCoding --> CPi[pi/]

    PKG --> PCust[custom/<br/>gowa, lightpanda, zai]
    PKG --> PDarw[darwin/<br/>Perplexity-bin]
    PKG --> PSrc[_sources/<br/>nvfetcher]

    style F fill:#1f6feb,stroke:#fff,color:#fff
    style CCoding fill:#2ea043,stroke:#fff,color:#fff
    style CCom fill:#bf8700,stroke:#fff,color:#fff
    style CHome fill:#6e40c9,stroke:#fff,color:#fff
    style PKG fill:#cf222e,stroke:#fff,color:#fff

Loading

The flake has four top-level trees, each auto-imported via import-tree:

config/home/coding/_common/ is a pure-data library — it holds shared commands/skills/agents/rules that each tool's common.nix generator renders into the tool's native format. Content edits happen once; metadata ripples to every tool.

Quick Start

Drop into a pre-built AI shell

nix run github:DivitMittal/ai-nixCfg#ai --impure

Spawns $SHELL with the full AI toolchain prepended to PATH — all agentic assistants, LLM CLIs, workflow tools, MCP binaries, and the headroom/rtk wrappers. Ephemeral: nothing is activated or written to your home directory.

--impure lets the app read $USER/$HOME from your environment so the configuration adapts to whoever runs it.

Augment your current shell's PATH

nix shell github:DivitMittal/ai-nixCfg --impure

Same binaries, but you stay in your existing shell.

Enter the dev shell

nix develop

Provides nixd (LSP), alejandra (formatter), nvfetcher (package source updater), and apm-cli. Includes a pkgs-update command that regenerates pkgs/_sources/.

As a Flake Input

{
  inputs = {
    ai-nixCfg = {
      url = "github:DivitMittal/ai-nixCfg";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
}

Available Substituters

Pre-configured in flake.nix (nixConfig.extra-substituters):

Supported Systems

Pulled from nix-systems/default — Linux (x86_64, aarch64) + macOS (x86_64, aarch64). Note: OpenClaw and Hermes Agent bundles are aarch64-darwin only; other tools work cross-platform.

Using Reusable Modules

Import individual home-manager modules into your configuration:

{ inputs, ... }: {
  imports = [
    inputs.ai-nixCfg.homeManagerModules.ccs
    inputs.ai-nixCfg.homeManagerModules.codex
    inputs.ai-nixCfg.homeManagerModules.crush
    inputs.ai-nixCfg.homeManagerModules.herdr
    inputs.ai-nixCfg.homeManagerModules.n8n
    inputs.ai-nixCfg.homeManagerModules.ralph-tui
    inputs.ai-nixCfg.homeManagerModules.talon
    inputs.ai-nixCfg.homeManagerModules.ghnf
  ];
}

Module Reference

Example: ccs Module

{
  programs.ccs = {
    enable = true;
    package = pkgs.writeShellScriptBin "ccs" ''
      exec ${pkgs.pnpm}/bin/pnpm dlx @kaitranntt/ccs "$@"
    '';
    mutableUserSettings = true;       # Deep-merge; preserves OAuth tokens
    useXdgConfigHome = true;          # CCS_DIR = $XDG_CONFIG_HOME/ccs
    settings.preferences.theme = "dark";
  };
}

Using Personal Configurations (Cfg)

To import the full personal setup, use the Cfg module:

{ inputs, ... }: {
  imports = [inputs.ai-nixCfg.homeManagerModules.Cfg];
}

This composes config/setup.nix, which pulls in import-tree ./home, homeManagerModules.default, plus upstream modules:

graph LR
    Cfg[Cfg module] --> Setup[config/setup.nix]
    Setup --> IT[import-tree ./home]
    Setup --> UON[nix-openclaw<br/>homeManagerModules.openclaw]
    Setup --> UHA[hermes-agent-hm<br/>homeManagerModules.default]
    Setup --> UK[kolu<br/>homeManagerModules.default]
    Setup --> UP[pi-nix<br/>homeManagerModules.default]
    Setup --> MH[homeManagerModules.default<br/>all of modules/home]

    IT --> A[assistants/]
    IT --> B[browser.nix]
    IT --> C[cloud.nix]
    IT --> Cd[coding/]
    IT --> Cl[cli/]
    IT --> G[gui.nix]
    IT --> M[mcp.nix]
    IT --> Mu[multiplexers.nix]
    IT --> O[orchestration.nix]
    IT --> Op[optimization/]
    IT --> Cpx[cliproxyapi/]
    IT --> R[review.nix]
    IT --> T[tasks.nix]
    IT --> U[usage.nix]
    IT --> V[voice.nix]
    IT --> W[workflows.nix]

    style Cfg fill:#1f6feb,stroke:#fff,color:#fff
    style Setup fill:#2ea043,stroke:#fff,color:#fff

Loading

Or import specific subsets by path:

{ inputs, ... }: {
  imports = [
    (inputs.ai-nixCfg + "/config/home/coding")        # Agentic assistants only
    (inputs.ai-nixCfg + "/config/home/cli")           # LLM CLI tools only
    (inputs.ai-nixCfg + "/config/home/cloud.nix")      # Cloud platform CLIs only
    (inputs.ai-nixCfg + "/config/home/mcp.nix")        # Shared MCP servers only
    (inputs.ai-nixCfg + "/config/home/optimization")   # headroom + rtk + ponytail
  ];
}

What Cfg Includes

Top-level Options

{
  aiNixCfg = {
    guiApps.enable = false;   # Disable GUI app casks (Antigravity, Perplexity, …)
    voice.enable = false;     # Skip Talon + Wispr Flow installation
  };
}

The standalone nix run ...#ai app sets both to false so it stays lean and needs no brew-nix overlay.

Tool Configurations

Each tool under config/home/coding/<tool>/ follows the same shape:

Tool Configuration Matrix

Claude Code Hooks

Codex Profiles

Pi Coding-Agent Extensions

Pinned to upstream kissgyorgy/coding-agents rev 4d8c448033ca332b55e79de4cbd0737da5c5cfda. Update by bumping rev + re-running nix build to refresh hashes.

OpenCode Providers

The Antigravity provider exposes Claude and Gemini models via the Antigravity backend (no separate Google Cloud project required).

Shared Content Library (_common)

config/home/coding/_common/ holds shared commands, skills, agents, and rules as pure data. Each tool's common.nix consumes this library and renders content into the tool's native format (YAML frontmatter for Claude/Crush/Copilot, prompts for Codex, skill files for Pi, etc.).

graph LR
    subgraph _common["_common/ (pure data)"]
        CMD[commands/*.md]
        SKL[skills/*.md]
        AGT[agents/*.md]
        RUL[rules/*.md]
        META[metadata defaults<br/>commandMeta, skillMeta,<br/>agentMeta, ruleNames]
    end

    subgraph "tool generators (common.nix)"
        TC[claude/common.nix<br/>YAML frontmatter + context]
        TX[codex/common.nix<br/>prompts + skills]
        TP[copilot-cli/common.nix<br/>skills + agents]
        TO[opencode/common.nix<br/>context only]
        TA[antigravity-cli/common.nix<br/>commands → global skills]
        TI[pi/common.nix<br/>rules + skills + prompts]
        TR[crush/common.nix<br/>commands + instructions]
    end

    CMD --> META
    SKL --> META
    AGT --> META
    RUL --> META

    META --> TC
    META --> TX
    META --> TP
    META --> TO
    META --> TA
    META --> TI
    META --> TR

    style _common fill:#bf8700,stroke:#fff,color:#fff
    style META fill:#6e40c9,stroke:#fff,color:#fff

Loading

Edits to a common markdown file propagate to every tool automatically on the next home-manager switch.

Commands

Reusable slash commands. Body is tool-agnostic; metadata in _common/commands/default.nix adds per-tool fields (allowed-tools for Claude/Crush, tools for Copilot, argument-hint for Codex).

Skills

Tool-agnostic deep-knowledge documents. Loaded on-demand by the agent.

Agents

Predefined subagent personas, rendered with tool-appropriate metadata.

Rules

Always-on instructions loaded into every agent's system prompt via context = memoryInstruction + "\n\n" + combinedRules.

MCP Servers

Defined in config/home/mcp.nix and applied via programs.mcp.servers. Toggleable per-tool via each coding/<tool>/mcp.nix.

Optional servers (commented in mcp.nix): headroom, cognee (knowledge graph memory), sequential-thinking, filesystem, memory, markitdown. Uncomment to enable.

Per-Tool MCP Configuration

Voice & Browser

Voice (config/home/voice.nix)

Voice input via Talon — declarative, cross-platform (Linux + Darwin), with optional macOS app installation.

graph LR
    V[aiNixCfg.voice] --> E{enable?}
    E -->|true| Talon[programs.talon]
    E -->|true| Darwin{Darwin?}
    Darwin -->|yes + installDarwinApps| WF[brewCasks.wispr-flow]
    Darwin -->|yes + installTalonDarwinApp| TA[talonPackage cask]
    Talon --> TC{enableTalonCommunity?}
    TC -->|true| TL[talon-community clone]

    style V fill:#1f6feb,stroke:#fff,color:#fff

Loading

programs.talon.files."custom/ai-nixCfg.talon" carries a personal .talon script in voice/talon/.

Browser (config/home/browser.nix)

LIGHTPANDA_DISABLE_TELEMETRY=false is set as a session variable.

Optimization & Orchestration

Token Optimization (config/home/optimization/)

graph LR
    subgraph "Optimization Stack"
        User[User] -->|hr-claude, hr-codex, …| Wrap[headroom wrap]
        Wrap --> Proxy[headroom proxy<br/>:8787]
        Proxy --> Compress[Compress tool output<br/>HEADROOM_MODE=token]
        Proxy --> Context[Inject context<br/>HEADROOM_CONTEXT_TOOL=rtk]
        Context --> Rtk[rtk — Rust Token Killer]
        Proxy --> Agent[Claude / Codex /<br/>OpenCode / Copilot / OpenClaw]
    end

    style Proxy fill:#bf8700,stroke:#fff,color:#fff
    style Rtk fill:#cf222e,stroke:#fff,color:#fff

Loading

Headroom Shell Aliases

hr-claude    # headroom wrap claude
hr-codex     # headroom wrap codex
hr-opencode  # headroom wrap opencode
hr-copilot   # headroom wrap copilot
hr-openclaw  # headroom wrap openclaw
hr-proxy     # run proxy standalone on :8787
hr-learn     # headroom learn --apply
hr-stats     # headroom perf
hr-check     # headroom doctor

Headroom Environment Defaults

Multiplexers (config/home/multiplexers.nix)

Herdr keybindings:

Orchestration (config/home/orchestration.nix)

Tasks (config/home/tasks.nix)

Review (config/home/review.nix)

CLIProxyAPI(Plus) (config/home/cliproxyapi/, modules/home/cliproxyapi.nix)

Replaces the previous ccs (Claude Code Switcher)-managed proxy. Runs cli-proxy-api-plus locally on port 8317, fronting both OAuth-backed providers (gemini, codex, agy, qwen, kiro, ghcp, kimi, cursor, etc.) and custom OpenAI-compatible providers (z-ai, minimax, openrouter) behind one Anthropic- and OpenAI-compatible endpoint. claude-code gets ANTHROPIC_BASE_URL/ANTHROPIC_AUTH_TOKEN pointed at it (config/home/coding/claude/proxy.nix); every other harness that honors OPENAI_BASE_URL/OPENAI_API_KEY (codex, opencode, jcode, forgecode, …) routes through it too.

On first activation, an existing ~/.ccs/cliproxy/auth directory (if present) is symlinked into the new config location so already-logged-in OAuth accounts carry over without re-authentication (programs.cliproxyapi.inheritLegacyAuth). Provider API keys are left empty in the repo by design — populate them via the dashboard at http://localhost:8317 or inject them from a secret manager by overriding programs.cliproxyapi.settings.openai-compatibility downstream.

Usage (config/home/usage.nix)

Currently exposes ccusage for Claude Code usage tracking via ai-nixCfg.inputs.ccusage.

Custom Packages

Defined under pkgs/ and re-exported via packages.<system>:

graph TD
    P["packages per system"] --> Cust["customPkgs<br/>(cross-platform)"]
    P --> Darw["darwinPkgs<br/>aarch64-darwin only"]
    P --> Llm["llm-agents.nix<br/>apm, beads, beads-viewer,<br/>beads-cli, ck, codegraph,<br/>crush, dolt, gastown,<br/>happy-coder, mardi-gras,<br/>openspecui, rtk, …"]
    P --> Stp["nix-steipete-tools<br/>aarch64-darwin:<br/>summarize, gogcli, openclaw"]

    Cust --> Gowa["gowa<br/>(WhatsApp MCP, Go)"]
    Cust --> Panda["lightpanda<br/>(headless browser, Rust)"]
    Cust --> Zai["zai<br/>(Z.AI CLI)"]

    Darw --> Perp["Perplexity-bin"]

    style P fill:#1f6feb,stroke:#fff,color:#fff
    style Cust fill:#2ea043,stroke:#fff,color:#fff
    style Darw fill:#bf8700,stroke:#fff,color:#fff

Loading

pkgs/custom/

pkgs/darwin/

Re-exported from llm-agents.nix

Updating Sources

nix develop
pkgs-update   # regenerates pkgs/_sources/

Never edit pkgs/_sources/ by hand — it's regenerated by nvfetcher.

Using Custom Packages

{ inputs, pkgs, ... }: {
  home.packages = [
    inputs.ai-nixCfg.packages.${pkgs.system}.gowa
    inputs.ai-nixCfg.packages.${pkgs.system}.lightpanda
    inputs.ai-nixCfg.packages.${pkgs.system}.zai
  ];
}

CI & Pre-commit

CI Workflows

Generated via nix run .#render-workflows — do not hand-edit .github/workflows/*.yml.

graph TD
    subgraph "Triggers"
        Push[push to main<br/>flake.nix/lock/flake/**]
        PR[Pull request]
        Schedule[Schedule<br/>weekly Sunday 00:00]
        Manual[workflow_dispatch]
    end

    subgraph "Jobs"
        FC[flake-check<br/>nix -vL flake check<br/>--impure --all-systems --no-build]
        FLU[flake-lock-update<br/>DeterminateSystems/update-flake-lock<br/>+ auto PR]
    end

    Push --> FC
    PR --> FC
    Manual --> FC

    Schedule --> FLU
    Manual --> FLU

    FC --> Cache1[Magic Nix Cache]
    FLU --> Cache1

    style FC fill:#2ea043,stroke:#fff,color:#fff
    style FLU fill:#1f6feb,stroke:#fff,color:#fff

Loading

Pre-commit hooks (.pre-commit-config.yaml) also run in CI via actions-nix.

Pre-commit Hooks

Configured via git-hooks flake module in flake/checks.nix:

Formatters (flake/formatters.nix)

Run nix fmt to format all Nix files. .github/* is excluded (generated).

Project Structure

.
├── flake.nix                   # Main flake entry point
├── flake/                      # flake-parts module definitions
│   ├── apps.nix                # #ai shell app (PATH-augmented interactive shell)
│   ├── checks.nix              # Prek/pre-commit hooks
│   ├── devshells.nix           # Dev shell (nixd, alejandra, nvfetcher, apm-cli)
│   ├── formatters.nix          # Code formatters (treefmt-nix)
│   ├── sandnix.nix             # Sandboxed claude-code wrapper
│   ├── AGENTS.md               # Flake-level agent context
│   └── actions/                # GitHub Actions workflow definitions
│       ├── common.nix          # Shared workflow fragments
│       ├── flake-check.nix     # flake-check.yml
│       └── flake-lock-update.nix # flake-lock-update.yml
│
├── modules/                    # Home-manager modules (reusable)
│   ├── default.nix             # Exports: ccs, codex, crush, herdr, n8n, ralph-tui, talon, ghnf
│   └── home/
│       ├── ccs.nix             # Claude Code Switcher
│       ├── codex.nix           # Skills + prompts
│       ├── crush.nix           # MCP/LSP/permissions/commands
│       ├── ghnf.nix            # gnhf auto-committer
│       ├── herdr.nix           # Terminal multiplexer for agents
│       ├── n8n.nix             # n8n workflow automation
│       ├── ralph-tui.nix       # Agent loop orchestrator TUI
│       └── talon.nix           # Talon voice programming
│
├── config/                     # Personal home-manager configuration
│   ├── default.nix             # Exports: Cfg, default
│   ├── setup.nix               # Composes config/home/ + upstream modules
│   └── home/
│       ├── coding/             # Agentic coding assistants
│       │   ├── _common/        # Pure data library
│       │   │   ├── commands/   # 12 reusable commands
│       │   │   ├── skills/     # 3 skills
│       │   │   ├── agents/     # 4 agents
│       │   │   ├── rules/      # 4 rules
│       │   │   ├── lib.nix     # Shared helpers (mkYamlFrontmatter, memoryInstruction)
│       │   │   └── default.nix # Library entry point
│       │   ├── claude/         # Claude Code setup, hooks, TUI, permissions, plugins
│       │   ├── codex/          # Codex profiles, settings, prompts, skills
│       │   ├── copilot-cli/    # Copilot CLI settings, permissions, skills, agents
│       │   ├── opencode/       # Providers, themes, formatters, LSP, plugins
│       │   ├── crush/          # Crush settings, MCP, LSP, permissions
│       │   ├── antigravity-cli/# Antigravity CLI settings + global skills
│       │   ├── pi/             # Pi coding agent + 14 extensions
│       │   └── misc.nix        # Misc CLI tools (happy-coder, zai, mmx-cli)
│       ├── assistants/         # Standalone assistants
│       │   ├── hermes-agent/   # Hermes Agent setup
│       │   └── openclaw/       # OpenClaw setup (aarch64-darwin)
│       ├── cli/                # LLM CLI tools
│       │   ├── aichat.nix      # Multi-provider LLM client (OpenRouter zoo)
│       │   ├── fabric.nix      # Pattern-based AI workflows
│       │   ├── vcs.nix         # geminicommit, aicommit2
│       │   └── retrival.nix    # ck, codegraph, dolt
│       ├── optimization/       # Token optimization stack
│       │   ├── headroom.nix    # headroom proxy + shell aliases
│       │   ├── rtk.nix         # rtk CLI wrapper
│       │   └── ponytail.nix    # Ponytail plugin config
│       ├── multiplexers.nix    # herdr + kolu
│       ├── orchestration.nix   # ruflo, caveman, gastown, zeroshot, mardi-gras
│       ├── tasks.nix           # bead (bd), Beads-Viewer (bv)
│       ├── review.nix          # lumen
│       ├── cliproxyapi/        # CLIProxyAPI(Plus) settings (replaces ccs)
│       ├── usage.nix           # ccusage
│       ├── workflows.nix       # ralph-tui, gnhf, openspec, openspecui, …
│       ├── cloud.nix           # kaggle, hf
│       ├── mcp.nix             # Shared MCP servers (deepwiki, octocode, exa, gowa)
│       ├── browser.nix         # lightpanda, agent-browser, playwright-mcp
│       ├── gui.nix             # GUI casks (Antigravity, Perplexity, t3-code, handy)
│       └── voice.nix           # Talon + Wispr Flow (Darwin)
│
├── pkgs/                       # Custom package definitions
│   ├── default.nix             # Re-exports all packages per system
│   ├── custom/
│   │   ├── default.nix
│   │   ├── gowa/               # WhatsApp REST API + MCP (Go)
│   │   ├── lightpanda/         # Headless browser (Rust)
│   │   └── zai/                # Z.AI CLI
│   ├── darwin/
│   │   ├── default.nix
│   │   └── Perplexity-bin/     # Perplexity desktop app
│   ├── _sources/               # Generated by nvfetcher — never edit manually
│   └── nvfetcher.toml          # nvfetcher source definitions
│
├── .github/workflows/          # Auto-generated — render via `nix run .#render-workflows`
├── .claude/                    # Claude Code project config (rules, agents, skills)
├── apm.yml                     # AI Package Manager config (serena, nixos MCP)
├── apm.lock.yaml
├── .envrc                      # nix-direnv auto-activation
├── .pre-commit-config.yaml     # Symlink to git-hooks-managed config
├── .editorconfig               # UTF-8, LF, 2-space indent
└── AGENTS.md                   # AI agent instructions (project context)

Conventions

Nix Style

Anti-Patterns

• Do not hand-edit .github/workflows/*.yml — regenerate via nix run .#render-workflows
• Do not commit secrets — use agenix/ragenix; .env must stay in .gitignore
• Do not force-push to main — Conventional Commits required
• Do not duplicate command text in tool-specific dirs — modify common markdown instead
• Do not bypass cfg.enable guards
• Avoid deep nesting — prefer early returns and explicit error handling
• No broad reads of reference files in tool generators — load only what's needed

Commits

Conventional Commits format: type(scope): description. Examples:

feat(pi): add fetch extension with npm deps
fix(voice): guard missing brewCasks.wispr-flow
chore(pkgs): bump lightpanda source via nvfetcher
docs(readme): convert to tables + mermaid
refactor(coding): move assistants out of coding/

Run nix fmt and nix flake check before committing.

Commands

Common

nix fmt                                        # Format all Nix files (alejandra + deadnix + statix)
nix -vL flake check --impure --all-systems --no-build  # Validate flake
nix build .#<attr>                             # Build a package (e.g. .#gowa, .#zai)
nix develop                                    # Enter dev shell

Project-specific

nix run .#render-workflows                     # Regenerate .github/workflows/*.yml
nix run .#pre-commit                           # Run pre-commit hooks
pkgs-update                                    # (in devshell) Refresh pkgs/_sources/
nix run github:DivitMittal/ai-nixCfg#ai --impure  # Drop into ephemeral AI shell
nix shell github:DivitMittal/ai-nixCfg --impure   # Augment current shell's PATH

Build outputs

nix build .#gowa                               # WhatsApp MCP server
nix build .#lightpanda                         # Headless browser
nix build .#zai                                # Z.AI CLI
nix build .#Perplexity-bin                     # Perplexity desktop (darwin only)

Related Repositories

• DivitMittal/OS-nixCfg — Main Nix configurations repository (provides customLib.scanPaths, customLib.mkPnpmDlxBin, customLib.mkUvxBin)

For AI Agents

Context files (AGENTS.md, .claude/rules/*.md) are checked in but .claude/agents/, .codex/, .opencode/ per-project state is generated — run apm compile before exploring the repo to get directory-level guidance.

The shared content library at config/home/coding/_common/ is the canonical source for commands/skills/agents/rules — do not duplicate content in tool-specific directories; modify the common markdown and let the tool generators re-render.