@soleri/cli 0.0.1 → 1.0.0

package/src/__tests__/add-domain.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { addDomain } from '@soleri/forge/lib';
+
+describe('add-domain command', () => {
+  let tempDir: string;
+  let agentDir: string;
+
+  function createMinimalAgent(): void {
+    mkdirSync(join(agentDir, 'src', 'intelligence', 'data'), { recursive: true });
+    mkdirSync(join(agentDir, 'src', 'facades'), { recursive: true });
+    mkdirSync(join(agentDir, 'src', 'activation'), { recursive: true });
+    writeFileSync(
+      join(agentDir, 'package.json'),
+      JSON.stringify({
+        name: 'test-agent-mcp',
+        scripts: { build: 'echo build' },
+      }),
+    );
+    // Minimal index.ts with anchors
+    writeFileSync(
+      join(agentDir, 'src', 'index.ts'),
+      [
+        "import { createCoreFacade } from './facades/core.facade.js';",
+        '',
+        'const facades = [',
+        '    createCoreFacade(vault, brain),',
+        '];',
+      ].join('\n'),
+    );
+  }
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-add-domain-test-${Date.now()}`);
+    agentDir = join(tempDir, 'test-agent');
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should fail if no package.json', async () => {
+    mkdirSync(agentDir, { recursive: true });
+    const result = await addDomain({ agentPath: agentDir, domain: 'security', noBuild: true });
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('package.json');
+  });
+
+  it('should fail if package name does not end with -mcp', async () => {
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'not-agent' }));
+    const result = await addDomain({ agentPath: agentDir, domain: 'security', noBuild: true });
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('-mcp');
+  });
+
+  it('should fail with invalid domain name', async () => {
+    createMinimalAgent();
+    const result = await addDomain({ agentPath: agentDir, domain: 'Invalid', noBuild: true });
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('kebab-case');
+  });
+
+  it('should fail if domain already exists', async () => {
+    createMinimalAgent();
+    writeFileSync(
+      join(agentDir, 'src', 'intelligence', 'data', 'security.json'),
+      JSON.stringify({ domain: 'security', version: '1.0.0', entries: [] }),
+    );
+
+    const result = await addDomain({ agentPath: agentDir, domain: 'security', noBuild: true });
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('already exists');
+  });
+
+  it('should create empty bundle and facade', async () => {
+    createMinimalAgent();
+
+    const result = await addDomain({ agentPath: agentDir, domain: 'security', noBuild: true });
+    expect(result.success).toBe(true);
+
+    // Bundle
+    const bundle = JSON.parse(
+      readFileSync(join(agentDir, 'src', 'intelligence', 'data', 'security.json'), 'utf-8'),
+    );
+    expect(bundle.domain).toBe('security');
+    expect(bundle.entries).toEqual([]);
+
+    // Facade
+    expect(existsSync(join(agentDir, 'src', 'facades', 'security.facade.ts'))).toBe(true);
+  });
+
+  it('should patch index.ts with new import and facade', async () => {
+    createMinimalAgent();
+
+    await addDomain({ agentPath: agentDir, domain: 'security', noBuild: true });
+
+    const indexContent = readFileSync(join(agentDir, 'src', 'index.ts'), 'utf-8');
+    expect(indexContent).toContain('createSecurityFacade');
+    expect(indexContent).toContain('import { createSecurityFacade }');
+  });
+
+  it('should handle agents without brain directory', async () => {
+    createMinimalAgent();
+    // No brain dir → vault-only facade
+
+    const result = await addDomain({ agentPath: agentDir, domain: 'api-design', noBuild: true });
+    expect(result.success).toBe(true);
+
+    const facade = readFileSync(join(agentDir, 'src', 'facades', 'api-design.facade.ts'), 'utf-8');
+    // Vault-only facades import from vault directly, not from @soleri/core
+    expect(facade).toContain('vault');
+  });
+});

package/src/__tests__/create.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { previewScaffold, scaffold } from '@soleri/forge/lib';
+import type { AgentConfig } from '@soleri/forge/lib';
+
+describe('create command', () => {
+  let tempDir: string;
+
+  const testConfig: AgentConfig = {
+    id: 'test-agent',
+    name: 'TestAgent',
+    role: 'A test agent',
+    description: 'This agent is used for testing the CLI create command.',
+    domains: ['testing', 'quality'],
+    principles: ['Test everything', 'Quality first'],
+    greeting: 'Hello! I am TestAgent, here to help with testing.',
+    outputDir: '',
+  };
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-create-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    testConfig.outputDir = tempDir;
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should preview scaffold without creating files', () => {
+    const preview = previewScaffold(testConfig);
+
+    expect(preview.agentDir).toBe(join(tempDir, 'test-agent'));
+    expect(preview.persona.name).toBe('TestAgent');
+    expect(preview.domains).toEqual(['testing', 'quality']);
+    expect(preview.files.length).toBeGreaterThan(10);
+    expect(existsSync(preview.agentDir)).toBe(false);
+  });
+
+  it('should scaffold agent successfully', () => {
+    const result = scaffold(testConfig);
+
+    expect(result.success).toBe(true);
+    expect(result.agentDir).toBe(join(tempDir, 'test-agent'));
+    expect(result.filesCreated.length).toBeGreaterThan(10);
+    expect(existsSync(join(tempDir, 'test-agent', 'package.json'))).toBe(true);
+    expect(existsSync(join(tempDir, 'test-agent', 'src', 'index.ts'))).toBe(true);
+  });
+
+  it('should fail if directory already exists', () => {
+    scaffold(testConfig);
+    const result = scaffold(testConfig);
+
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('already exists');
+  });
+
+  it('should create domain facades for each domain', () => {
+    scaffold(testConfig);
+
+    expect(existsSync(join(tempDir, 'test-agent', 'src', 'facades', 'testing.facade.ts'))).toBe(
+      true,
+    );
+    expect(existsSync(join(tempDir, 'test-agent', 'src', 'facades', 'quality.facade.ts'))).toBe(
+      true,
+    );
+  });
+
+  it('should create intelligence data files for each domain', () => {
+    scaffold(testConfig);
+
+    const testingBundle = JSON.parse(
+      readFileSync(
+        join(tempDir, 'test-agent', 'src', 'intelligence', 'data', 'testing.json'),
+        'utf-8',
+      ),
+    );
+    expect(testingBundle.domain).toBe('testing');
+    expect(testingBundle.entries).toEqual([]);
+  });
+
+  it('should read config from file for non-interactive mode', () => {
+    const configPath = join(tempDir, 'agent.json');
+    writeFileSync(configPath, JSON.stringify(testConfig), 'utf-8');
+
+    const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(raw.id).toBe('test-agent');
+    expect(raw.domains).toEqual(['testing', 'quality']);
+  });
+});

package/src/__tests__/dev.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { detectAgent } from '../utils/agent-context.js';
+
+describe('dev command', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-dev-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should detect agent in directory', () => {
+    const agentDir = join(tempDir, 'my-agent');
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'my-agent-mcp' }));
+
+    const ctx = detectAgent(agentDir);
+    expect(ctx).not.toBeNull();
+    expect(ctx!.agentId).toBe('my-agent');
+  });
+
+  it('should return null for non-agent directory', () => {
+    const dir = join(tempDir, 'not-agent');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'some-lib' }));
+
+    const ctx = detectAgent(dir);
+    expect(ctx).toBeNull();
+  });
+
+  it('should return null for directory without package.json', () => {
+    const ctx = detectAgent(tempDir);
+    expect(ctx).toBeNull();
+  });
+
+  it('should detect brain presence', () => {
+    const agentDir = join(tempDir, 'brain-agent');
+    mkdirSync(join(agentDir, 'src', 'brain'), { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'brain-agent-mcp' }));
+
+    const ctx = detectAgent(agentDir);
+    expect(ctx).not.toBeNull();
+    expect(ctx!.hasBrain).toBe(true);
+  });
+
+  it('should report no brain when absent', () => {
+    const agentDir = join(tempDir, 'no-brain');
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'no-brain-mcp' }));
+
+    const ctx = detectAgent(agentDir);
+    expect(ctx).not.toBeNull();
+    expect(ctx!.hasBrain).toBe(false);
+  });
+});

package/src/__tests__/doctor.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  checkNodeVersion,
+  checkNpm,
+  checkAgentProject,
+  checkAgentBuild,
+  checkNodeModules,
+  runAllChecks,
+} from '../utils/checks.js';
+
+describe('doctor command', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-doctor-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('checkNodeVersion', () => {
+    it('should pass for current Node version', () => {
+      const result = checkNodeVersion();
+      expect(result.status).toBe('pass');
+      expect(result.detail).toContain(process.versions.node);
+    });
+  });
+
+  describe('checkNpm', () => {
+    it('should pass when npm is available', () => {
+      const result = checkNpm();
+      expect(result.status).toBe('pass');
+    });
+  });
+
+  describe('checkAgentProject', () => {
+    it('should warn for non-agent directory', () => {
+      const result = checkAgentProject(tempDir);
+      expect(result.status).toBe('warn');
+    });
+
+    it('should pass for agent directory', () => {
+      const agentDir = join(tempDir, 'agent');
+      mkdirSync(agentDir, { recursive: true });
+      writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'agent-mcp' }));
+
+      const result = checkAgentProject(agentDir);
+      expect(result.status).toBe('pass');
+      expect(result.detail).toContain('agent-mcp');
+    });
+  });
+
+  describe('checkAgentBuild', () => {
+    it('should warn if no agent detected', () => {
+      const result = checkAgentBuild(tempDir);
+      expect(result.status).toBe('warn');
+    });
+
+    it('should fail if dist is missing', () => {
+      const agentDir = join(tempDir, 'agent');
+      mkdirSync(agentDir, { recursive: true });
+      writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'agent-mcp' }));
+
+      const result = checkAgentBuild(agentDir);
+      expect(result.status).toBe('fail');
+    });
+
+    it('should pass if dist/index.js exists', () => {
+      const agentDir = join(tempDir, 'agent');
+      mkdirSync(join(agentDir, 'dist'), { recursive: true });
+      writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'agent-mcp' }));
+      writeFileSync(join(agentDir, 'dist', 'index.js'), '');
+
+      const result = checkAgentBuild(agentDir);
+      expect(result.status).toBe('pass');
+    });
+  });
+
+  describe('checkNodeModules', () => {
+    it('should fail if node_modules is missing', () => {
+      const agentDir = join(tempDir, 'agent');
+      mkdirSync(agentDir, { recursive: true });
+      writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'agent-mcp' }));
+
+      const result = checkNodeModules(agentDir);
+      expect(result.status).toBe('fail');
+    });
+
+    it('should pass if node_modules exists', () => {
+      const agentDir = join(tempDir, 'agent');
+      mkdirSync(join(agentDir, 'node_modules'), { recursive: true });
+      writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'agent-mcp' }));
+
+      const result = checkNodeModules(agentDir);
+      expect(result.status).toBe('pass');
+    });
+  });
+
+  describe('runAllChecks', () => {
+    it('should return array of check results', () => {
+      const results = runAllChecks(tempDir);
+      expect(results.length).toBeGreaterThan(0);
+      for (const r of results) {
+        expect(['pass', 'fail', 'warn']).toContain(r.status);
+        expect(r.label).toBeTruthy();
+      }
+    });
+
+    it('should include Node and npm checks regardless of directory', () => {
+      const results = runAllChecks(tempDir);
+      const labels = results.map((r) => r.label);
+      expect(labels).toContain('Node.js');
+      expect(labels).toContain('npm');
+    });
+  });
+});

package/src/__tests__/hooks.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+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;
+  let agentDir: string;
+
+  function createMinimalAgent(): void {
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'hook-test-mcp' }));
+  }
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-hooks-test-${Date.now()}`);
+    agentDir = join(tempDir, 'hook-test');
+    mkdirSync(tempDir, { recursive: true });
+    createMinimalAgent();
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('installHooks', () => {
+    it('should create claude-code settings.json', () => {
+      const files = installHooks('claude-code', agentDir);
+
+      expect(files).toContain('.claude/settings.json');
+      expect(existsSync(join(agentDir, '.claude', 'settings.json'))).toBe(true);
+
+      const settings = JSON.parse(
+        readFileSync(join(agentDir, '.claude', 'settings.json'), 'utf-8'),
+      );
+      expect(settings.hooks).toBeDefined();
+      expect(settings.hooks.PreToolUse).toBeDefined();
+      expect(settings.hooks.SessionStart).toBeDefined();
+    });
+
+    it('should create cursor rules file', () => {
+      const files = installHooks('cursor', agentDir);
+
+      expect(files).toContain('.cursorrules');
+      const content = readFileSync(join(agentDir, '.cursorrules'), 'utf-8');
+      expect(content).toContain('hook-test');
+      expect(content).toContain('Cursor Rules');
+    });
+
+    it('should create windsurf rules file', () => {
+      const files = installHooks('windsurf', agentDir);
+
+      expect(files).toContain('.windsurfrules');
+      const content = readFileSync(join(agentDir, '.windsurfrules'), 'utf-8');
+      expect(content).toContain('Windsurf Rules');
+    });
+
+    it('should create copilot instructions', () => {
+      const files = installHooks('copilot', agentDir);
+
+      expect(files).toContain('.github/copilot-instructions.md');
+      expect(existsSync(join(agentDir, '.github', 'copilot-instructions.md'))).toBe(true);
+    });
+
+    it('should include agent ID in generated files', () => {
+      installHooks('cursor', agentDir);
+      const content = readFileSync(join(agentDir, '.cursorrules'), 'utf-8');
+      expect(content).toContain('hook-test');
+    });
+  });
+
+  describe('removeHooks', () => {
+    it('should remove installed hook files', () => {
+      installHooks('cursor', agentDir);
+      expect(existsSync(join(agentDir, '.cursorrules'))).toBe(true);
+
+      const removed = removeHooks('cursor', agentDir);
+      expect(removed).toContain('.cursorrules');
+      expect(existsSync(join(agentDir, '.cursorrules'))).toBe(false);
+    });
+
+    it('should return empty array if no hooks installed', () => {
+      const removed = removeHooks('cursor', agentDir);
+      expect(removed).toEqual([]);
+    });
+
+    it('should remove claude-code settings', () => {
+      installHooks('claude-code', agentDir);
+      expect(existsSync(join(agentDir, '.claude', 'settings.json'))).toBe(true);
+
+      const removed = removeHooks('claude-code', agentDir);
+      expect(removed).toContain('.claude/settings.json');
+    });
+  });
+
+  describe('detectInstalledHooks', () => {
+    it('should detect no hooks when none installed', () => {
+      const installed = detectInstalledHooks(agentDir);
+      expect(installed).toEqual([]);
+    });
+
+    it('should detect installed hooks', () => {
+      installHooks('cursor', agentDir);
+      installHooks('claude-code', agentDir);
+
+      const installed = detectInstalledHooks(agentDir);
+      expect(installed).toContain('cursor');
+      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-knowledge.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { installKnowledge } from '@soleri/forge/lib';
+
+describe('install-knowledge command', () => {
+  let tempDir: string;
+  let agentDir: string;
+  let bundleDir: string;
+
+  function createMinimalAgent(): void {
+    mkdirSync(join(agentDir, 'src', 'intelligence', 'data'), { recursive: true });
+    mkdirSync(join(agentDir, 'src', 'facades'), { recursive: true });
+    writeFileSync(
+      join(agentDir, 'package.json'),
+      JSON.stringify({
+        name: 'test-agent-mcp',
+        scripts: { build: 'echo build' },
+      }),
+    );
+  }
+
+  function createBundle(domain: string, entries: unknown[] = []): string {
+    const bundlePath = join(bundleDir, `${domain}.json`);
+    writeFileSync(
+      bundlePath,
+      JSON.stringify({
+        domain,
+        version: '1.0.0',
+        entries: entries.length
+          ? entries
+          : [
+              {
+                id: `${domain}-pattern-1`,
+                type: 'pattern',
+                domain,
+                title: `${domain} Pattern`,
+                severity: 'suggestion',
+                description: `A ${domain} pattern for testing.`,
+                tags: [domain],
+              },
+            ],
+      }),
+    );
+    return bundlePath;
+  }
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-knowledge-test-${Date.now()}`);
+    agentDir = join(tempDir, 'test-agent');
+    bundleDir = join(tempDir, 'bundles');
+    mkdirSync(bundleDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should fail if agent path is invalid', async () => {
+    const result = await installKnowledge({
+      agentPath: join(tempDir, 'nonexistent'),
+      bundlePath: bundleDir,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should fail if no bundles found', async () => {
+    createMinimalAgent();
+    const emptyDir = join(tempDir, 'empty-bundles');
+    mkdirSync(emptyDir);
+
+    const result = await installKnowledge({
+      agentPath: agentDir,
+      bundlePath: emptyDir,
+    });
+    expect(result.success).toBe(false);
+    expect(result.summary).toContain('No .json bundle files');
+  });
+
+  it('should install a single bundle', async () => {
+    createMinimalAgent();
+    createBundle('security');
+
+    const result = await installKnowledge({
+      agentPath: agentDir,
+      bundlePath: bundleDir,
+      generateFacades: false,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.bundlesInstalled).toBe(1);
+    expect(result.domainsAdded).toContain('security');
+    expect(existsSync(join(agentDir, 'src', 'intelligence', 'data', 'security.json'))).toBe(true);
+  });
+
+  it('should classify domains as added vs updated', async () => {
+    createMinimalAgent();
+    // Pre-existing domain
+    writeFileSync(
+      join(agentDir, 'src', 'intelligence', 'data', 'security.json'),
+      JSON.stringify({ domain: 'security', version: '0.5.0', entries: [] }),
+    );
+    // New + updated bundles
+    createBundle('security');
+    createBundle('api-design');
+
+    const result = await installKnowledge({
+      agentPath: agentDir,
+      bundlePath: bundleDir,
+      generateFacades: false,
+    });
+
+    expect(result.domainsUpdated).toContain('security');
+    expect(result.domainsAdded).toContain('api-design');
+  });
+});