@soleri/cli 9.14.3 → 9.16.7

package/src/__tests__/doctor.test.ts

@@ -104,7 +104,7 @@ describe('doctor command', () => {
   describe('runAllChecks', () => {
     it('should return array of check results', { timeout: 20_000 }, () => {
       const results = runAllChecks(tempDir);
-      expect(results.length).toBeGreaterThan(0);
+      expect(results.length).toBe(9); // 4 common + 2 non-filetree (nodeModules + agentBuild) + 3 shared (mcpReg + hookPacks + cognee)
       for (const r of results) {
         expect(['pass', 'fail', 'warn']).toContain(r.status);
         expect(r.label).toBeTruthy();
@@ -117,5 +117,50 @@ describe('doctor command', () => {
       expect(labels).toContain('Node.js');
       expect(labels).toContain('npm');
     });
+
+    it('should detect Codex MCP registration for file-tree agents', { timeout: 20_000 }, () => {
+      const originalHome = process.env.HOME ?? '';
+      const originalUserProfile = process.env.USERPROFILE ?? '';
+      process.env.HOME = tempDir;
+      process.env.USERPROFILE = tempDir;
+
+      try {
+        const agentDir = join(tempDir, 'agent');
+        mkdirSync(join(agentDir, 'instructions'), { recursive: true });
+        mkdirSync(join(tempDir, '.codex'), { recursive: true });
+
+        writeFileSync(
+          join(agentDir, 'agent.yaml'),
+          [
+            'id: test-agent',
+            'name: Test Agent',
+            'role: A test agent',
+            'description: A minimal file-tree agent for doctor testing',
+            'domains: []',
+            'principles: []',
+            '',
+          ].join('\n'),
+        );
+        writeFileSync(join(agentDir, 'instructions', 'usage.md'), '# Usage');
+        writeFileSync(
+          join(tempDir, '.codex', 'config.toml'),
+          [
+            '[mcp_servers.test-agent]',
+            'command = "node"',
+            'args = ["engine.js", "--agent", "agent.yaml"]',
+            '',
+          ].join('\n'),
+        );
+
+        const results = runAllChecks(agentDir);
+        const registration = results.find((r) => r.label === 'MCP registration');
+        expect(registration).toBeDefined();
+        expect(registration!.status).toBe('pass');
+        expect(registration!.detail).toContain('codex');
+      } finally {
+        process.env.HOME = originalHome;
+        process.env.USERPROFILE = originalUserProfile;
+      }
+    });
   });
 });

package/src/__tests__/hook-packs.test.ts

@@ -23,24 +23,6 @@ describe('hook-packs', () => {
   });
 
   describe('registry', () => {
-    it('should list all 10 built-in packs', () => {
-      const packs = listPacks();
-      expect(packs.length).toBe(10);
-      const names = packs.map((p) => p.name).sort();
-      expect(names).toEqual([
-        'a11y',
-        'clean-commits',
-        'css-discipline',
-        'flock-guard',
-        'full',
-        'marketing-research',
-        'rtk',
-        'safety',
-        'typescript-safety',
-        'yolo-safety',
-      ]);
-    });
-
     it('should get a specific pack by name', () => {
       const pack = getPack('typescript-safety');
       expect(pack).not.toBeNull();

package/src/__tests__/hooks-convert.test.ts

@@ -222,22 +222,6 @@ describe('hooks convert', () => {
     });
   });
 
-  describe('constants', () => {
-    it('HOOK_EVENTS should contain all 5 events', () => {
-      expect(HOOK_EVENTS).toEqual([
-        'PreToolUse',
-        'PostToolUse',
-        'PreCompact',
-        'Notification',
-        'Stop',
-      ]);
-    });
-
-    it('ACTION_LEVELS should contain all 3 levels', () => {
-      expect(ACTION_LEVELS).toEqual(['remind', 'warn', 'block']);
-    });
-  });
-
   describe('validation', () => {
     it('should reject invalid event', () => {
       const invalidEvent = 'InvalidEvent';
@@ -248,18 +232,6 @@ describe('hooks convert', () => {
       const invalidAction = 'destroy';
       expect(ACTION_LEVELS.includes(invalidAction as any)).toBe(false);
     });
-
-    it('should accept all valid events', () => {
-      for (const event of HOOK_EVENTS) {
-        expect(HOOK_EVENTS.includes(event)).toBe(true);
-      }
-    });
-
-    it('should accept all valid action levels', () => {
-      for (const action of ACTION_LEVELS) {
-        expect(ACTION_LEVELS.includes(action)).toBe(true);
-      }
-    });
   });
 
   describe('directory structure', () => {

package/src/__tests__/hooks-sync.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+// ─── Mocks ─────────────────────────────────────────────────────────────────
+
+const mockSyncHooksToClaudeSettings = vi.fn();
+
+vi.mock('@soleri/core', () => ({
+  syncHooksToClaudeSettings: mockSyncHooksToClaudeSettings,
+}));
+
+const mockDetectAgent = vi.fn();
+
+vi.mock('../utils/agent-context.js', () => ({
+  detectAgent: mockDetectAgent,
+}));
+
+// Silence logger output during tests
+vi.mock('../utils/logger.js', () => ({
+  pass: vi.fn(),
+  fail: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  dim: vi.fn(),
+  heading: vi.fn(),
+}));
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+async function runSyncCommand(): Promise<void> {
+  // Import after mocks are established
+  const { registerHooks } = await import('../commands/hooks.js');
+  const program = new Command();
+  program.exitOverride(); // prevent process.exit from killing the test runner
+  registerHooks(program);
+  await program.parseAsync(['node', 'cli', 'hooks', 'sync']);
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('hooks sync command', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  it('calls syncHooksToClaudeSettings with the agentId when detectAgent returns a valid context', async () => {
+    mockDetectAgent.mockReturnValue({
+      agentId: 'myagent',
+      agentPath: '/some/path',
+      format: 'typescript',
+      packageName: 'myagent-mcp',
+      hasBrain: false,
+    });
+    mockSyncHooksToClaudeSettings.mockReturnValue({
+      installed: ['SessionStart', 'PreCompact', 'Stop'],
+      updated: [],
+      skipped: [],
+    });
+
+    await runSyncCommand();
+
+    expect(mockSyncHooksToClaudeSettings).toHaveBeenCalledTimes(1);
+    expect(mockSyncHooksToClaudeSettings).toHaveBeenCalledWith('myagent');
+  });
+
+  it('does NOT call syncHooksToClaudeSettings and exits non-zero when detectAgent returns null', async () => {
+    mockDetectAgent.mockReturnValue(null);
+
+    let exitCode: number | undefined;
+    const exitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation((code?: number | string | null) => {
+        exitCode = typeof code === 'number' ? code : 1;
+        throw new Error(`process.exit(${exitCode})`);
+      });
+
+    try {
+      await runSyncCommand();
+    } catch {
+      // Expected — process.exit throws via our mock
+    }
+
+    expect(mockSyncHooksToClaudeSettings).not.toHaveBeenCalled();
+    expect(exitCode).toBeGreaterThan(0);
+
+    exitSpy.mockRestore();
+  });
+
+  it('calls syncHooksToClaudeSettings with correct agentId for a file-tree agent context', async () => {
+    mockDetectAgent.mockReturnValue({
+      agentId: 'my-filetree-agent',
+      agentPath: '/path/to/agent',
+      format: 'filetree',
+      packageName: 'my-filetree-agent',
+      hasBrain: true,
+    });
+    mockSyncHooksToClaudeSettings.mockReturnValue({
+      installed: ['SessionStart'],
+      updated: ['Stop'],
+      skipped: ['PreCompact'],
+    });
+
+    await runSyncCommand();
+
+    expect(mockSyncHooksToClaudeSettings).toHaveBeenCalledTimes(1);
+    expect(mockSyncHooksToClaudeSettings).toHaveBeenCalledWith('my-filetree-agent');
+  });
+});

package/src/__tests__/hooks.test.ts

@@ -3,7 +3,6 @@ import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { installHooks, removeHooks, detectInstalledHooks } from '../hooks/generator.js';
-import { SUPPORTED_EDITORS } from '../hooks/templates.js';
 
 describe('hooks commands', () => {
   let tempDir: string;
@@ -110,24 +109,5 @@ describe('hooks commands', () => {
       expect(installed).toContain('claude-code');
       expect(installed).not.toContain('windsurf');
     });
-
-    it('should detect all 4 editors when all installed', () => {
-      for (const editor of SUPPORTED_EDITORS) {
-        installHooks(editor, agentDir);
-      }
-
-      const installed = detectInstalledHooks(agentDir);
-      expect(installed).toHaveLength(4);
-    });
-  });
-
-  describe('SUPPORTED_EDITORS', () => {
-    it('should have 4 editors', () => {
-      expect(SUPPORTED_EDITORS).toHaveLength(4);
-      expect(SUPPORTED_EDITORS).toContain('claude-code');
-      expect(SUPPORTED_EDITORS).toContain('cursor');
-      expect(SUPPORTED_EDITORS).toContain('windsurf');
-      expect(SUPPORTED_EDITORS).toContain('copilot');
-    });
   });
 });

package/src/__tests__/install-verify.test.ts

@@ -98,7 +98,7 @@ describe('verifyInstall', () => {
     const checks = verifyInstall('test-agent', agentDir, 'claude');
 
     expect(Array.isArray(checks)).toBe(true);
-    expect(checks.length).toBeGreaterThan(0);
+    expect(checks.length).toBe(3); // claude config entry + engine binary + agent.yaml
     for (const check of checks) {
       expect(check).toHaveProperty('label');
       expect(check).toHaveProperty('passed');

package/src/__tests__/install.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { mkdirSync, rmSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { toPosix, getNextStepMessage, resolveEngineBin } from '../commands/install.js';
@@ -82,20 +82,17 @@ describe('resolveEngineBin', () => {
 describe('npx fallback warning', () => {
   afterEach(() => {
     vi.resetModules();
-    vi.doUnmock('node:module');
+    vi.doUnmock('../utils/core-resolver.js');
   });
 
   it('returns npx fallback when core resolution fails', async () => {
-    vi.doMock('node:module', async () => {
-      const actual = await vi.importActual<typeof import('node:module')>('node:module');
+    vi.doMock('../utils/core-resolver.js', async () => {
+      const actual = await vi.importActual<typeof import('../utils/core-resolver.js')>(
+        '../utils/core-resolver.js',
+      );
       return {
         ...actual,
-        createRequire: () =>
-          ({
-            resolve: () => {
-              throw new Error('MODULE_NOT_FOUND');
-            },
-          }) as ReturnType<typeof import('node:module').createRequire>,
+        resolveInstalledEngineBin: () => null,
       };
     });
 

package/src/__tests__/update.test.ts

@@ -45,25 +45,6 @@ describe('update command', () => {
     vi.clearAllMocks();
   });
 
-  it('exports registerUpdate function', () => {
-    expect(typeof registerUpdate).toBe('function');
-  });
-
-  it('registers a command named "update" on the program', () => {
-    const mockCommand = {
-      command: vi.fn().mockReturnThis(),
-      description: vi.fn().mockReturnThis(),
-      action: vi.fn().mockReturnThis(),
-    };
-    const mockProgram = { command: vi.fn(() => mockCommand) };
-
-    registerUpdate(mockProgram as never);
-
-    expect(mockProgram.command).toHaveBeenCalledWith('update');
-    expect(mockCommand.description).toHaveBeenCalledWith(expect.stringContaining('Update'));
-    expect(mockCommand.action).toHaveBeenCalledWith(expect.any(Function));
-  });
-
   it('prints already-on-latest when current version matches latest', async () => {
     // getCurrentVersion() reads ../../package.json → packages/cli/package.json.
     // Return the same version from npm view to trigger the "already on latest" branch.

package/src/__tests__/validator.test.ts

@@ -52,22 +52,6 @@ describe('validator', () => {
       expect(fixtures).toHaveLength(15);
     });
 
-    it('matching PreToolUse fixtures should have shouldMatch: true', () => {
-      const fixtures = generateFixtures('PreToolUse', 'Bash');
-      const matching = fixtures.filter((f) => f.shouldMatch);
-      for (const f of matching) {
-        expect(f.shouldMatch).toBe(true);
-      }
-    });
-
-    it('non-matching PreToolUse fixtures should have shouldMatch: false', () => {
-      const fixtures = generateFixtures('PreToolUse', 'Write');
-      const nonMatching = fixtures.filter((f) => !f.shouldMatch);
-      for (const f of nonMatching) {
-        expect(f.shouldMatch).toBe(false);
-      }
-    });
-
     it('PreToolUse matching fixtures should contain tool_name and tool_input', () => {
       const fixtures = generateFixtures('PreToolUse', 'Write|Edit');
       const matching = fixtures.filter((f) => f.shouldMatch);

package/src/commands/add-domain.ts

@@ -1,15 +1,19 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
 import { addDomain } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
+import { resolveVaultDbPath } from '../utils/vault-db.js';
 
 export function registerAddDomain(program: Command): void {
   program
     .command('add-domain')
     .argument('<domain>', 'Domain name in kebab-case (e.g., "security")')
     .option('--no-build', 'Skip the build step after adding the domain')
+    .option('--yes', 'Auto-seed vault entries into the knowledge bundle without prompting')
     .description('Add a new knowledge domain to the agent in the current directory')
-    .action(async (domain: string, opts: { build: boolean }) => {
+    .action(async (domain: string, opts: { build: boolean; yes?: boolean }) => {
       const ctx = detectAgent();
       if (!ctx) {
         p.log.error('No agent project detected in current directory. Run this from an agent root.');
@@ -38,6 +42,9 @@ export function registerAddDomain(program: Command): void {
         if (!result.success) {
           process.exit(1);
         }
+
+        // ── Vault auto-seed ────────────────────────────────────────────────
+        await trySeedFromVault(ctx.agentId, ctx.agentPath, domain, opts.yes ?? false);
       } catch (err) {
         s.stop('Failed');
         p.log.error(err instanceof Error ? err.message : String(err));
@@ -45,3 +52,84 @@ export function registerAddDomain(program: Command): void {
       }
     });
 }
+
+/**
+ * Query the agent's vault for entries matching the domain.
+ * If found, prompt the user (or auto-seed with --yes) to populate the bundle.
+ */
+async function trySeedFromVault(
+  agentId: string,
+  agentPath: string,
+  domain: string,
+  autoYes: boolean,
+): Promise<void> {
+  const vaultDbPath = resolveVaultDbPath(agentId);
+  if (!vaultDbPath) return; // Vault not initialized yet — skip silently
+
+  try {
+    const { Vault } = await import('@soleri/core');
+    const vault = new Vault(vaultDbPath);
+
+    let entries: Array<{
+      id: string;
+      type: string;
+      domain?: string;
+      title: string;
+      description: string;
+      tags?: string[];
+      severity?: string;
+    }>;
+    try {
+      entries = vault.list({ domain, limit: 200 });
+    } finally {
+      vault.close();
+    }
+
+    if (entries.length === 0) return; // No matching entries
+
+    // Ask user (or auto-seed)
+    let shouldSeed = autoYes;
+    if (!autoYes) {
+      const answer = await p.confirm({
+        message: `Found ${entries.length} vault entries for domain "${domain}". Seed into knowledge bundle?`,
+        initialValue: true,
+      });
+      if (p.isCancel(answer)) return;
+      shouldSeed = answer;
+    }
+
+    if (!shouldSeed) return;
+
+    // Populate knowledge/{domain}.json
+    const bundlePath = join(agentPath, 'knowledge', `${domain}.json`);
+    const bundleEntries = entries.map((e) => ({
+      id: e.id,
+      type: e.type,
+      domain: e.domain,
+      title: e.title,
+      description: e.description,
+      ...(e.severity ? { severity: e.severity } : {}),
+      ...(e.tags?.length ? { tags: e.tags } : {}),
+    }));
+
+    try {
+      const existing = JSON.parse(readFileSync(bundlePath, 'utf-8')) as {
+        domain: string;
+        entries: unknown[];
+      };
+      existing.entries = bundleEntries;
+      writeFileSync(bundlePath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+    } catch {
+      // File not readable — write fresh
+      writeFileSync(
+        bundlePath,
+        JSON.stringify({ domain, entries: bundleEntries }, null, 2) + '\n',
+        'utf-8',
+      );
+    }
+
+    p.log.success(`Seeded ${entries.length} entries into knowledge/${domain}.json`);
+  } catch {
+    // Vault query failed — don't block the domain addition
+  }
+}

package/src/commands/agent.ts

@@ -6,7 +6,6 @@
  */
 
 import { join, dirname } from 'node:path';
-import { createRequire } from 'node:module';
 import {
   existsSync,
   readFileSync,
@@ -26,6 +25,7 @@ import { PackLockfile, checkNpmVersion, checkVersionCompat, SOLERI_HOME } from '
 import {
   generateClaudeMdTemplate,
   generateInjectClaudeMd,
+  generateAgentsMd,
   generateSkills,
 } from '@soleri/forge/lib';
 import { composeClaudeMd, getModularEngineRules, AgentYamlSchema } from '@soleri/forge/lib';
@@ -48,6 +48,42 @@ function readEngineFeatures(agentPath: string): EngineFeature[] | undefined {
   }
 }
 
+function readFileTreeAgentConfig(agentPath: string): AgentConfig | null {
+  try {
+    const yamlPath = join(agentPath, 'agent.yaml');
+    if (!existsSync(yamlPath)) return null;
+
+    const parsed = AgentYamlSchema.parse(parseYaml(readFileSync(yamlPath, 'utf-8')));
+    return {
+      id: parsed.id,
+      name: parsed.name,
+      role: parsed.role,
+      description: parsed.description,
+      domains: parsed.domains,
+      principles: parsed.principles,
+      tone: parsed.tone,
+      greeting: parsed.greeting,
+      persona: parsed.persona,
+      vaults: parsed.vaults,
+      setupTarget: parsed.setup?.target ?? 'claude',
+    } as AgentConfig;
+  } catch {
+    return null;
+  }
+}
+
+function readAgentCoreVersion(agentPath: string): string | null {
+  const corePkgPath = join(agentPath, 'node_modules', '@soleri', 'core', 'package.json');
+  if (!existsSync(corePkgPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(corePkgPath, 'utf-8')) as { version?: unknown };
+    return typeof pkg.version === 'string' ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
 export function registerAgent(program: Command): void {
   const agent = program.command('agent').description('Agent lifecycle management');
 
@@ -83,14 +119,7 @@ export function registerAgent(program: Command): void {
         }
 
         // Resolve engine version via require.resolve
-        let engineVersion = 'not installed';
-        try {
-          const req = createRequire(join(ctx.agentPath, 'package.json'));
-          const corePkgPath = req.resolve('@soleri/core/package.json');
-          engineVersion = JSON.parse(readFileSync(corePkgPath, 'utf-8')).version || 'unknown';
-        } catch {
-          engineVersion = 'not installed';
-        }
+        const engineVersion = readAgentCoreVersion(ctx.agentPath) ?? 'not installed';
 
         // Check for core update
         const latestCore = checkNpmVersion('@soleri/core');
@@ -219,14 +248,7 @@ export function registerAgent(program: Command): void {
       // ─── File-tree agent (v7+) ────────────────────────────────
       if (ctx.format === 'filetree') {
         // Resolve installed @soleri/core version
-        let installedVersion: string | null = null;
-        try {
-          const req = createRequire(import.meta.url);
-          const corePkgPath = req.resolve('@soleri/core/package.json');
-          installedVersion = JSON.parse(readFileSync(corePkgPath, 'utf-8')).version ?? null;
-        } catch {
-          // @soleri/core not resolvable — will show as unknown
-        }
+        const installedVersion = readAgentCoreVersion(ctx.agentPath);
 
         // Check latest version on npm
         const latestCore = checkNpmVersion('@soleri/core');
@@ -382,6 +404,14 @@ export function registerAgent(program: Command): void {
       if (ctx.format === 'filetree') {
         const enginePath = join(ctx.agentPath, 'instructions', '_engine.md');
         const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
+        const agentsMdPath = join(ctx.agentPath, 'AGENTS.md');
+        const config = readFileTreeAgentConfig(ctx.agentPath);
+
+        if (!config) {
+          p.log.error('Could not parse agent.yaml for AGENTS.md regeneration.');
+          process.exit(1);
+          return;
+        }
 
         // Generate skills from latest forge templates
         const skillFiles = opts.skipSkills
@@ -391,6 +421,7 @@ export function registerAgent(program: Command): void {
         if (opts.dryRun) {
           p.log.info(`Would regenerate: ${enginePath}`);
           p.log.info(`Would regenerate: ${claudeMdPath}`);
+          p.log.info(`Would regenerate: ${agentsMdPath}`);
           if (skillFiles.length > 0) {
             const newSkills = skillFiles.filter(
               ([relPath]) => !existsSync(join(ctx.agentPath, relPath)),
@@ -442,6 +473,11 @@ export function registerAgent(program: Command): void {
         p.log.success(
           `Regenerated ${claudeMdPath} (${result.sources.length} sources, ${result.content.length} bytes)`,
         );
+
+        // 4. Regenerate AGENTS.md for Codex/OpenCode
+        const agentsMd = generateAgentsMd(config);
+        writeFileSync(agentsMdPath, agentsMd, 'utf-8');
+        p.log.success(`Regenerated ${agentsMdPath} (${agentsMd.length} bytes)`);
         return;
       }