git:20260425.a734716 to git:20260428.99f2785

156 added, 70 removed. Audit A to A.

What this update changes in the checks

No check changed: every fixed check gives the same answer before and after this update.

A tripped check is a label, not a verdict: read the matched text and the lines below. This week's updates that newly trip a check.

---
name: adding-a-command
- description: Create a new CLI command following Commander.js pattern. Handles command file in src/commands/, registration in src/cli.ts, telemetry tracking via tracked() wrapper, and option parsing. Use when user says 'add command', 'new CLI command', 'create subcommand', or adds files to src/commands/. Do NOT use for modifying existing commands or refactoring command structure.
+ description: Creates a new CLI command following the Commander.js pattern in src/commands/. Handles command registration in src/cli.ts, telemetry tracking via tracked() wrapper, and option parsing. Use when user says add command, new CLI command, create subcommand, or adds files to src/commands/. Do NOT use for modifying existing commands or fixing bugs in existing commands.
---
# Adding a Command
## Critical
- - Commands MUST be registered in `src/cli.ts` using `.command()` and `.action()` with the `tracked()` wrapper for telemetry.
- - Command file MUST be in `src/commands/{commandName}.ts` and export a **named** async function: `export async function {commandName}Command(options?: OptionType)`. Never use default exports — `src/cli.ts` imports commands by name.
- - Always use `tracked('{kebab-name}', {commandName}Command)` wrapper in `src/cli.ts` to enable telemetry tracking.
- - Test file MUST be in `src/commands/__tests__/{commandName}.test.ts` with at least one happy-path test.
+ - **Export pattern**: Command must export a named async function: `export async function myCommand(options?: OptionType)`. Never use default exports.
+ - **Registration in cli.ts**: Every command must be imported and registered with `.command()` chain in `src/cli.ts`, wrapped with `tracked()` for telemetry.
+ - **Error signaling**: Use `throw new Error('__exit__')` to exit gracefully without printing the error message. Use chalk for user-facing messages.
+ - **Options typing**: Commands receiving options must define a TypeScript interface for those options. Pass options as a destructured object parameter.
## Instructions
- 1. **Create command file** in `src/commands/{commandName}.ts`
- - Export named async function: `export async function {commandName}Command(options?: { optionName?: type }) { ... }`
- - Return `void`; handle all output via `console.log` or chalk
- - Define a TypeScript interface for options if the command takes any
- - Verify function signature matches existing commands like `src/commands/score.ts`
-
- 2. **Register in src/cli.ts**
- - Import the command by name: `import { {commandName}Command } from './commands/{commandName}.js'`
- - Add command definition:
- ```ts
- program
- .command('{kebab-name}')
- .description('One-line description')
- .option('--option', 'Option description')
- .action(tracked('{kebab-name}', {commandName}Command))
- ```
- - Verify imports are `.js` (ESM)
- - Verify `tracked()` wrapper is applied to `.action()`
+ 1. **Create the command file** at `src/commands/{commandName}.ts` with named async export.
+ - Signature: `export async function {commandName}Command(options?: { optionName?: optionType }) { ... }`
+ - Import only what you need (avoid kitchen-sink imports).
+ - Return void (handle all output via console.log or chalk).
+ - Verify the file follows the naming convention: camelCase function + "Command" suffix.
- 3. **Handle errors consistently**: Wrap error-prone operations in try/catch:
+ 2. **Handle errors consistently**: Wrap error-prone operations in try/catch. Distinguish between user errors and system errors:
- User error (bad input): `console.error(chalk.red('message')); throw new Error('__exit__');`
- - System error: `throw new Error('Detailed error message');`
+ - System error (missing dependency): `throw new Error('Detailed error message');` — this will print and exit with code 1.
+ - Parse-like errors: Use ora spinner with `.fail()` before throwing.
+ - This step prevents double error printing in bin.ts.
- 4. **Create test file** in `src/commands/__tests__/{commandName}.test.ts`
- - Import `describe`, `it`, `expect`, `vi` from `vitest`
- - Import command by name: `import { {commandName}Command } from '../{commandName}.js'`
- - Test happy path and error paths
- - Verify test runs: `npx vitest run src/commands/__tests__/{commandName}.test.ts`
+ 3. **Import and register in src/cli.ts** in the correct location:
+ - Add import at the top: `import { {commandName}Command } from './commands/{commandName}.js';`
+ - Register the command in the appropriate section (main commands, or nested under a group like `sources`).
+ - For main commands: `.command('{kebab-name}').description('...').option(...).action(tracked('{kebab-name}', {commandName}Command))`
+ - For subcommands (like `sources add`): `sources.command('add').description(...).action(tracked('sources:add', sourcesAddCommand))`
+ - Key: Wrap handler with `tracked('{command-name}', handler)` for automatic telemetry.
+ - Verify the command name in tracked() uses kebab-case for main commands and colon-separated for subcommands.
- 5. **Build and validate**
- - Run `npm run build` → verify no TypeScript errors
- - Run `npm run lint` → verify ESLint passes
- - Test command: `node dist/bin.js mycommand --help` → verify options listed
- - Run `npm run test` → verify new test passes
+ 4. **Define options (if needed)**:
+ - Add `.option()` chains before `.action()`: `.option('--flag', 'Description')` or `.option('--opt <value>', 'Description')`
+ - For parsed options (like comma-separated agents), add a parse function: `.option('--opt <value>', 'Description', parseFunction)`
+ - Pass options to handler: `.action(tracked('name', (opts) => command(opts)))`
+ - Define TypeScript interface for the options object.
+ - Verify option names use camelCase (Commander converts kebab-case flags to camelCase).
+ 5. **Verify before proceeding**:
+ - Function exports correctly and is imported in cli.ts.
+ - Command is registered with tracked() wrapper.
+ - Output uses chalk for colors, not plain console.log.
+ - Error paths throw `new Error('__exit__')` for user errors.
+
## Examples
- User says: "Add a new `verify` command that checks if config files exist"
+ ### Example 1: Simple command (status)
- **Actions:**
- 1. Create `src/commands/verify.ts`:
- ```ts
- import chalk from 'chalk';
- import { checkFilesExist } from '../lib/config.js';
+ User says: "Add a command to show config status"
- export async function verifyCommand(options?: { json?: boolean }) {
- const exists = await checkFilesExist();
- console.log(chalk.bold('Verify'));
- console.log(` Config files: ${exists ? chalk.green('found') : chalk.red('missing')}`);
- }
- ```
- 2. Register in `src/cli.ts`:
- ```ts
- import { verifyCommand } from './commands/verify.js';
- program
- .command('verify')
- .description('Verify configuration files exist')
- .action(tracked('verify', verifyCommand))
- ```
- 3. Create `src/commands/__tests__/verify.test.ts` with happy-path test
- 4. Run `npm run build && npm run test`
+ **Actions taken**:
+ 1. Create src/commands/status.ts with statusCommand() export
+ 2. Import and register in src/cli.ts with tracked() wrapper
+ **Result**: `caliber status` displays config status; `caliber status --json` outputs JSON.
+
+ Code example:
+ ```typescript
+ import chalk from 'chalk';
+ import { loadConfig } from '../llm/config.js';
+
+ export async function statusCommand(options?: { json?: boolean }) {
+ const config = loadConfig();
+
+ if (options?.json) {
+ console.log(JSON.stringify({ configured: !!config }, null, 2));
+ return;
+ }
+
+ console.log(chalk.bold('Status'));
+ console.log(` LLM: ${chalk.green(config?.provider || 'Not configured')}`);
+ }
+ ```
+
+ Registration in src/cli.ts:
+ ```typescript
+ import { statusCommand } from './commands/status.js';
+ program
+ .command('status')
+ .description('Show config status')
+ .option('--json', 'Output as JSON')
+ .action(tracked('status', statusCommand));
+ ```
+
+ ---
+
+ ### Example 2: Subcommand with arguments
+
+ User says: "Add a sources add subcommand"
+
+ **Actions taken**:
+ 1. Create src/commands/sources.ts with sourcesAddCommand() export
+ 2. Register under sources group with tracked('sources:add', ...)
+
+ **Result**: `caliber sources add ../lib` adds a source.
+
+ Code example:
+ ```typescript
+ export async function sourcesAddCommand(sourcePath: string) {
+ if (!fs.existsSync(sourcePath)) {
+ console.log(chalk.red(`Path not found: ${sourcePath}`));
+ throw new Error('__exit__');
+ }
+ const existing = loadSourcesConfig(process.cwd());
+ existing.push({ type: 'repo', path: sourcePath });
+ writeSourcesConfig(process.cwd(), existing);
+ console.log(chalk.green(`Added ${sourcePath}`));
+ }
+ ```
+
+ Registration:
+ ```typescript
+ const sources = program.command('sources');
+ sources
+ .command('add')
+ .argument('<path>', 'Path to add')
+ .action(tracked('sources:add', sourcesAddCommand));
+ ```
+
+ ---
+
+ ### Example 3: Command with option parsing
+
+ User says: "Add init with --agent flag supporting comma-separated values"
+
+ **Actions taken**:
+ 1. Create parseAgentOption() parser in src/cli.ts
+ 2. Create src/commands/init.ts with initCommand(options)
+ 3. Register with custom parser
+
+ **Result**: `caliber init --agent claude,cursor` passes parsed array to handler.
+
+ Parser code:
+ ```typescript
+ function parseAgentOption(value: string) {
+ const agents = value.split(',').map(s => s.trim().toLowerCase());
+ if (agents.length === 0) {
+ console.error('Invalid agent');
+ process.exit(1);
+ }
+ return agents;
+ }
+
+ program.command('init')
+ .option('--agent <type>', 'Agents (comma-separated)', parseAgentOption)
+ .action(tracked('init', initCommand));
+ ```
+
## Common Issues
- **"SyntaxError: The requested module does not provide an export named '{commandName}Command'"**
- - Use `export async function {commandName}Command(...)` — named export, not `export default`
- - Import in `src/cli.ts` using named import: `import { {commandName}Command } from './commands/{commandName}.js'`
- - Rebuild: `npm run build`
+ **Issue**: "SyntaxError: The requested module does not provide an export named 'myCommand'"
+ - **Cause**: Function not exported or exported as default instead of named.
+ - **Fix**: Use `export async function myCommand(...)` (not `export default`).
- **"tracked is not exported from src/cli.ts"**
- - `tracked()` is defined in `src/cli.ts` itself; it takes two args: `tracked('kebab-name', handlerFn)`
- - Verify you're using it as `.action(tracked('{kebab-name}', {commandName}Command))`
+ **Issue**: Command appears in help but crashes when run
+ - **Cause**: Handler not wrapped with `tracked()` or function import mismatch.
+ - **Fix**: Verify import name matches function export. Wrap with `tracked('command-name', handler)`.
- **Command crashes when run but appears in --help**
- - Verify import name matches function export in the command file
- - Wrap handler with `tracked('command-name', handler)` and ensure the import is correct
+ **Issue**: "Error: __exit__" appears in output for user errors
+ - **Cause**: Throwing generic error instead of using error exit pattern.
+ - **Fix**: Use `console.error(chalk.red('message')); throw new Error('__exit__');` for user-facing errors.
- **"--option not recognized" when testing**
- - Verify `.option()` is chained in `src/cli.ts` BEFORE `.action()`
- - Rebuild and test with `npm run build && node dist/bin.js mycommand --help`
+ **Issue**: --dry-run flag not recognized
+ - **Cause**: Option not declared with `.option()` or wrong camelCase in interface.
+ - **Fix**: Add `.option('--dry-run', 'Description')` and ensure options interface has `dryRun?: boolean`.
+
+ **Issue**: Subcommand crashes but parent command works
+ - **Cause**: Using `program.command()` instead of `groupVar.command()` for subcommands.
+ - **Fix**: Register on group: `const sources = program.command('sources'); sources.command('add')...`
+
+ **Issue**: Telemetry not appearing
+ - **Cause**: Handler not wrapped with `tracked()` or wrong command name.
+ - **Fix**: Ensure `.action(tracked('{kebab-case}', handler))` wraps handler. Use colon for subcommands like 'sources:add'.
+
+ **Issue**: "Cannot find module" with relative imports
+ - **Cause**: Using `.ts` extension in imports.
+ - **Fix**: Always use `.js` extension: `import { x } from '../lib/file.js'` (required for ESM).