Where to Find Documentation for the no-mistakes Core Modules

Documentation for the no-mistakes core modules is maintained in two locations: the docs/src/content/docs/ directory for user-facing guides and reference material, and inline Go source comments within the internal/ packages that provide the authoritative API documentation for each subsystem.

The kunchenguid/no-mistakes repository is a Go CLI application that automates code workflows through a daemon-managed pipeline. If you are looking for documentation for the no-mistakes core modules, you will find both high-level conceptual guides and granular implementation details distributed across the repository. This article maps every core module to its corresponding documentation sources, whether you need to understand the IPC protocol or configure the global YAML settings.

Core Module Documentation Map

CLI Module (internal/cli)

The CLI module parses user commands, drives the AXI UI, and communicates with the daemon. According to the source code, the entry point resides in internal/cli/root.go, with AXI-specific logic in internal/cli/axi.go and daemon command handling in internal/cli/daemon_cmd.go. The user-facing documentation lives at docs/src/content/docs/reference/cli.md.

Daemon Module (internal/daemon)

This long-running background process owns the singleton lock and manages pipeline execution. Key files include internal/daemon/lock.go (singleton lock implementation) and internal/daemon/manager.go (pipeline orchestration). Refer to docs/src/content/docs/concepts/daemon.md for conceptual documentation.

Agent Module (internal/agent)

Wraps native LLM agents (Claude, Codex, Opencode) with session reuse and fallback logic. The core abstraction is in internal/agent/agent.go, with session management in internal/agent/session.go and retry logic in internal/agent/fallback.go. See docs/src/content/docs/guides/agents.md for usage instructions.

Pipeline Module (internal/pipeline)

Orchestrates the nine fixed steps (intent → rebase → review → test → document → lint → push → PR → CI). The executor logic is in internal/pipeline/executor.go, with individual step implementations under internal/pipeline/steps/*. Documentation is available at docs/src/content/docs/concepts/pipeline.md.

Git Helpers (internal/git)

Provides safe wrappers around Git commands respecting safe.bareRepository. Key files are internal/git/env.go (environment handling) and internal/git/hook.go (hook management). While there is no dedicated documentation page, implementation details are covered in the pipeline documentation and source comments.

IPC Module (internal/ipc)

Defines the local RPC channel between CLI and daemon. The protocol specification is in internal/ipc/protocol.go, with client and server implementations in internal/ipc/client.go and internal/ipc/server.go respectively. The handshake protocol is documented in daemon source comments.

ShellEnv Module (internal/shellenv)

Centralizes process-tree handling to ensure child processes are killed when parents cancel. Core utilities are in internal/shellenv/shellenv.go and internal/shellenv/shell_command.go. The ConfigureShellCommand contract is described in source comments.

Configuration (internal/config)

Loads global settings from ~/.no-mistakes/config.yaml and per-repo overrides. The implementation is in internal/config/config.go. Complete field descriptions are at docs/src/content/docs/reference/global-config.md.

Intent Module (internal/intent)

Extracts user intent from LLM transcripts for downstream steps. Core logic is in internal/intent/intent.go with reader implementations in internal/intent/reader_* files. Matching and disambiguation logic is documented in source comments within the pipeline documentation context.

Practical Command Examples

Here are runnable examples that demonstrate how to interact with the documented modules:

Initialize a repository (creates ~/.no-mistakes if needed):

no-mistakes init

Run the full pipeline on the current branch:

no-mistakes axi run

Check daemon status, showing active runs and health:

no-mistakes axi status

Override the auto-detected agent for a specific run:

no-mistakes --agent codex axi run

Skip a specific step (e.g., lint) for one execution:

no-mistakes axi run --skip lint

Summary

• User-facing documentation for the no-mistakes core modules resides in docs/src/content/docs/ under reference, concepts, and guides sections.
• API documentation is embedded in Go source comments within the internal/ directory, with each package (cli, daemon, agent, pipeline, git, ipc, shellenv, config, intent) containing authoritative implementation details.
• Key entry points include internal/cli/root.go for command handling, internal/daemon/lock.go for singleton management, and internal/pipeline/executor.go for workflow orchestration.
• Configuration options are fully documented at docs/src/content/docs/reference/global-config.md, while pipeline semantics are explained in docs/src/content/docs/concepts/pipeline.md.

Frequently Asked Questions

Where is the CLI command reference documented?

The CLI command reference is documented at docs/src/content/docs/reference/cli.md in the repository. The source implementation, including command parsing and AXI UI logic, is located in internal/cli/root.go and internal/cli/axi.go according to the kunchenguid/no-mistakes source code.

How do I configure global settings for no-mistakes?

Global settings are configured via the ~/.no-mistakes/config.yaml file. The complete schema and field descriptions are available in docs/src/content/docs/reference/global-config.md, while the loading logic is implemented in internal/config/config.go.

Which file controls the pipeline execution order?

The pipeline execution is controlled by internal/pipeline/executor.go, which orchestrates the nine fixed steps (intent, rebase, review, test, document, lint, push, PR, CI). Individual step implementations reside in internal/pipeline/steps/*, and high-level semantics are documented at docs/src/content/docs/concepts/pipeline.md.

How does the CLI communicate with the daemon?

The CLI communicates with the daemon through a local RPC channel defined in internal/ipc/protocol.go. The client and server implementations are found in internal/ipc/client.go and internal/ipc/server.go respectively, with the handshake protocol documented in the daemon source comments as implemented in kunchenguid/no-mistakes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}