@soleri/cli 0.0.1 → 1.0.1

package/src/__tests__/list.test.ts

@@ -0,0 +1,80 @@
+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 { listAgents } from '@soleri/forge/lib';
+
+describe('list command', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `cli-list-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should return empty array for directory with no agents', () => {
+    const agents = listAgents(tempDir);
+    expect(agents).toEqual([]);
+  });
+
+  it('should return empty array for non-existent directory', () => {
+    const agents = listAgents(join(tempDir, 'nonexistent'));
+    expect(agents).toEqual([]);
+  });
+
+  it('should detect agent directories', () => {
+    // Create a minimal agent directory
+    const agentDir = join(tempDir, 'test-agent');
+    mkdirSync(join(agentDir, 'src', 'intelligence', 'data'), { recursive: true });
+    writeFileSync(
+      join(agentDir, 'package.json'),
+      JSON.stringify({ name: 'test-agent-mcp', description: 'A test agent' }),
+    );
+    writeFileSync(
+      join(agentDir, 'src', 'intelligence', 'data', 'testing.json'),
+      JSON.stringify({ domain: 'testing', version: '1.0.0', entries: [] }),
+    );
+
+    const agents = listAgents(tempDir);
+    expect(agents).toHaveLength(1);
+    expect(agents[0].id).toBe('test-agent');
+    expect(agents[0].domains).toContain('testing');
+  });
+
+  it('should skip directories without -mcp package name', () => {
+    const dir = join(tempDir, 'not-agent');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'some-lib' }));
+
+    const agents = listAgents(tempDir);
+    expect(agents).toHaveLength(0);
+  });
+
+  it('should detect multiple agents', () => {
+    for (const id of ['alpha', 'beta']) {
+      const dir = join(tempDir, id);
+      mkdirSync(join(dir, 'src', 'intelligence', 'data'), { recursive: true });
+      writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: `${id}-mcp` }));
+    }
+
+    const agents = listAgents(tempDir);
+    expect(agents).toHaveLength(2);
+    expect(agents.map((a) => a.id).sort()).toEqual(['alpha', 'beta']);
+  });
+
+  it('should report build and deps status', () => {
+    const agentDir = join(tempDir, 'built-agent');
+    mkdirSync(join(agentDir, 'src', 'intelligence', 'data'), { recursive: true });
+    mkdirSync(join(agentDir, 'dist'), { recursive: true });
+    mkdirSync(join(agentDir, 'node_modules'), { recursive: true });
+    writeFileSync(join(agentDir, 'package.json'), JSON.stringify({ name: 'built-agent-mcp' }));
+
+    const agents = listAgents(tempDir);
+    expect(agents[0].hasDistDir).toBe(true);
+    expect(agents[0].hasNodeModules).toBe(true);
+  });
+});

package/src/commands/add-domain.ts

@@ -0,0 +1,46 @@
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { addDomain } from '@soleri/forge/lib';
+import { detectAgent } from '../utils/agent-context.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')
+    .description('Add a new knowledge domain to the agent in the current directory')
+    .action(async (domain: string, opts: { build: boolean }) => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        p.log.error('No agent project detected in current directory. Run this from an agent root.');
+        process.exit(1);
+      }
+
+      const s = p.spinner();
+      s.start(`Adding domain "${domain}" to ${ctx.agentId}...`);
+
+      try {
+        const result = await addDomain({
+          agentPath: ctx.agentPath,
+          domain,
+          noBuild: !opts.build,
+        });
+
+        s.stop(result.success ? result.summary : 'Failed');
+
+        if (result.warnings.length > 0) {
+          for (const w of result.warnings) {
+            p.log.warn(w);
+          }
+        }
+
+        if (!result.success) {
+          process.exit(1);
+        }
+      } catch (err) {
+        s.stop('Failed');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/create.ts

@@ -0,0 +1,73 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { previewScaffold, scaffold, AgentConfigSchema } from '@soleri/forge/lib';
+import { runCreateWizard } from '../prompts/create-wizard.js';
+
+export function registerCreate(program: Command): void {
+  program
+    .command('create')
+    .argument('[name]', 'Agent ID (kebab-case)')
+    .option('-c, --config <path>', 'Path to JSON config file (skip interactive prompts)')
+    .description('Create a new Soleri agent')
+    .action(async (name?: string, opts?: { config?: string }) => {
+      try {
+        let config;
+
+        if (opts?.config) {
+          // Non-interactive: read from config file
+          const configPath = resolve(opts.config);
+          if (!existsSync(configPath)) {
+            p.log.error(`Config file not found: ${configPath}`);
+            process.exit(1);
+          }
+          const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+          const parsed = AgentConfigSchema.safeParse(raw);
+          if (!parsed.success) {
+            p.log.error(`Invalid config: ${parsed.error.message}`);
+            process.exit(1);
+          }
+          config = parsed.data;
+        } else {
+          // Interactive wizard
+          config = await runCreateWizard(name);
+          if (!config) {
+            p.outro('Cancelled.');
+            return;
+          }
+        }
+
+        // Preview
+        const preview = previewScaffold(config);
+
+        p.log.info(`Will create ${preview.files.length} files in ${preview.agentDir}`);
+        p.log.info(`Facades: ${preview.facades.map((f) => f.name).join(', ')}`);
+        p.log.info(`Domains: ${preview.domains.join(', ')}`);
+
+        const confirmed = await p.confirm({ message: 'Create agent?' });
+        if (p.isCancel(confirmed) || !confirmed) {
+          p.outro('Cancelled.');
+          return;
+        }
+
+        // Scaffold
+        const s = p.spinner();
+        s.start('Scaffolding agent...');
+        const result = scaffold(config);
+        s.stop(result.success ? 'Agent created!' : 'Scaffolding failed');
+
+        if (result.success) {
+          p.note(result.summary, 'Next steps');
+        } else {
+          p.log.error(result.summary);
+          process.exit(1);
+        }
+
+        p.outro('Done!');
+      } catch (err) {
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/dev.ts

@@ -0,0 +1,39 @@
+import { spawn } from 'node:child_process';
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { detectAgent } from '../utils/agent-context.js';
+
+export function registerDev(program: Command): void {
+  program
+    .command('dev')
+    .description('Run the agent in development mode (stdio MCP server)')
+    .action(() => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        p.log.error('No agent project detected in current directory. Run this from an agent root.');
+        process.exit(1);
+      }
+
+      p.log.info(`Starting ${ctx.agentId} in dev mode...`);
+
+      const child = spawn('npx', ['tsx', 'src/index.ts'], {
+        cwd: ctx.agentPath,
+        stdio: 'inherit',
+        env: { ...process.env },
+      });
+
+      child.on('error', (err) => {
+        p.log.error(`Failed to start: ${err.message}`);
+        p.log.info('Make sure tsx is available: npm install -g tsx');
+        process.exit(1);
+      });
+
+      child.on('exit', (code, signal) => {
+        if (signal) {
+          p.log.warn(`Process terminated by signal ${signal}`);
+          process.exit(1);
+        }
+        process.exit(code ?? 0);
+      });
+    });
+}

package/src/commands/doctor.ts

@@ -0,0 +1,33 @@
+import type { Command } from 'commander';
+import { runAllChecks } from '../utils/checks.js';
+import * as log from '../utils/logger.js';
+
+export function registerDoctor(program: Command): void {
+  program
+    .command('doctor')
+    .description('Check system health and agent project status')
+    .action(() => {
+      log.heading('Soleri Doctor');
+
+      const results = runAllChecks();
+      let hasFailures = false;
+
+      for (const r of results) {
+        if (r.status === 'pass') log.pass(r.label, r.detail);
+        else if (r.status === 'warn') log.warn(r.label, r.detail);
+        else {
+          log.fail(r.label, r.detail);
+          hasFailures = true;
+        }
+      }
+
+      console.log();
+
+      if (hasFailures) {
+        log.info('Some checks failed. Fix the issues above and run soleri doctor again.');
+        process.exit(1);
+      } else {
+        log.info('All checks passed!');
+      }
+    });
+}

package/src/commands/hooks.ts

@@ -0,0 +1,86 @@
+import type { Command } from 'commander';
+import { SUPPORTED_EDITORS, type EditorId } from '../hooks/templates.js';
+import { installHooks, removeHooks, detectInstalledHooks } from '../hooks/generator.js';
+import { detectAgent } from '../utils/agent-context.js';
+import * as log from '../utils/logger.js';
+
+export function registerHooks(program: Command): void {
+  const hooks = program.command('hooks').description('Manage editor hooks for this agent');
+
+  hooks
+    .command('add')
+    .argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`)
+    .description('Generate editor hooks/config files')
+    .action((editor: string) => {
+      if (!isValidEditor(editor)) {
+        log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`);
+        process.exit(1);
+      }
+
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+
+      const files = installHooks(editor, ctx.agentPath);
+      for (const f of files) {
+        log.pass(`Created ${f}`);
+      }
+      log.info(`${editor} hooks installed for ${ctx.agentId}`);
+    });
+
+  hooks
+    .command('remove')
+    .argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`)
+    .description('Remove editor hooks/config files')
+    .action((editor: string) => {
+      if (!isValidEditor(editor)) {
+        log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`);
+        process.exit(1);
+      }
+
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+
+      const removed = removeHooks(editor, ctx.agentPath);
+      if (removed.length === 0) {
+        log.info(`No ${editor} hooks found to remove.`);
+      } else {
+        for (const f of removed) {
+          log.warn(`Removed ${f}`);
+        }
+        log.info(`${editor} hooks removed from ${ctx.agentId}`);
+      }
+    });
+
+  hooks
+    .command('list')
+    .description('Show which editor hooks are installed')
+    .action(() => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+
+      const installed = detectInstalledHooks(ctx.agentPath);
+
+      log.heading(`Editor hooks for ${ctx.agentId}`);
+
+      for (const editor of SUPPORTED_EDITORS) {
+        if (installed.includes(editor)) {
+          log.pass(editor, 'installed');
+        } else {
+          log.dim(`  ${editor} — not installed`);
+        }
+      }
+    });
+}
+
+function isValidEditor(editor: string): editor is EditorId {
+  return (SUPPORTED_EDITORS as readonly string[]).includes(editor);
+}

package/src/commands/install-knowledge.ts

@@ -0,0 +1,49 @@
+import { resolve } from 'node:path';
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+import { installKnowledge } from '@soleri/forge/lib';
+import { detectAgent } from '../utils/agent-context.js';
+
+export function registerInstallKnowledge(program: Command): void {
+  program
+    .command('install-knowledge')
+    .argument('<pack>', 'Path to knowledge bundle file or directory')
+    .option('--no-facades', 'Skip facade generation for new domains')
+    .description('Install knowledge packs into the agent in the current directory')
+    .action(async (pack: string, opts: { facades: boolean }) => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        p.log.error('No agent project detected in current directory. Run this from an agent root.');
+        process.exit(1);
+      }
+
+      const bundlePath = resolve(pack);
+
+      const s = p.spinner();
+      s.start(`Installing knowledge from ${bundlePath}...`);
+
+      try {
+        const result = await installKnowledge({
+          agentPath: ctx.agentPath,
+          bundlePath,
+          generateFacades: opts.facades,
+        });
+
+        s.stop(result.success ? result.summary : 'Installation failed');
+
+        if (result.warnings.length > 0) {
+          for (const w of result.warnings) {
+            p.log.warn(w);
+          }
+        }
+
+        if (!result.success) {
+          process.exit(1);
+        }
+      } catch (err) {
+        s.stop('Installation failed');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/list.ts

@@ -0,0 +1,42 @@
+import { resolve } from 'node:path';
+import type { Command } from 'commander';
+import { listAgents } from '@soleri/forge/lib';
+import * as log from '../utils/logger.js';
+
+function pad(s: string, len: number): string {
+  return s.length >= len ? s.slice(0, len) : s + ' '.repeat(len - s.length);
+}
+
+export function registerList(program: Command): void {
+  program
+    .command('list')
+    .argument('[dir]', 'Directory to scan for agents', process.cwd())
+    .description('List all Soleri agents in a directory')
+    .action((dir: string) => {
+      const targetDir = resolve(dir);
+      const agents = listAgents(targetDir);
+
+      if (agents.length === 0) {
+        log.info(`No agents found in ${targetDir}`);
+        return;
+      }
+
+      log.heading(`Agents in ${targetDir}`);
+
+      // Table header
+      console.log(`  ${pad('ID', 16)}${pad('Domains', 26)}${pad('Built', 8)}${pad('Deps', 8)}Path`);
+      console.log('  ' + '-'.repeat(80));
+
+      for (const agent of agents) {
+        const built = agent.hasDistDir ? '✓' : '✗';
+        const deps = agent.hasNodeModules ? '✓' : '✗';
+        const domains = agent.domains.join(', ') || '(none)';
+        const truncDomains = domains.length > 25 ? domains.slice(0, 22) + '...' : domains;
+        console.log(
+          `  ${pad(agent.id, 16)}${pad(truncDomains, 26)}${pad(built, 8)}${pad(deps, 8)}${agent.path}`,
+        );
+      }
+
+      console.log(`\n  ${agents.length} agent(s) found`);
+    });
+}

package/src/hooks/generator.ts

@@ -0,0 +1,65 @@
+/**
+ * Hook file generator — writes and removes editor hook files.
+ */
+import { existsSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { getEditorFiles, SUPPORTED_EDITORS, type EditorId } from './templates.js';
+
+/**
+ * Install editor hooks for the given editor.
+ * Returns list of files written.
+ */
+export function installHooks(editor: EditorId, agentPath: string): string[] {
+  const files = getEditorFiles(editor, agentPath);
+  const written: string[] = [];
+
+  const overwritten: string[] = [];
+  for (const [relPath, content] of Object.entries(files)) {
+    const absPath = join(agentPath, relPath);
+    if (existsSync(absPath)) overwritten.push(relPath);
+    mkdirSync(dirname(absPath), { recursive: true });
+    writeFileSync(absPath, content, 'utf-8');
+    written.push(relPath);
+  }
+  if (overwritten.length > 0) {
+    console.warn(`Warning: overwritten existing file(s): ${overwritten.join(', ')}`);
+  }
+
+  return written;
+}
+
+/**
+ * Remove editor hooks for the given editor.
+ * Returns list of files removed.
+ */
+export function removeHooks(editor: EditorId, agentPath: string): string[] {
+  const files = getEditorFiles(editor, agentPath);
+  const removed: string[] = [];
+
+  for (const relPath of Object.keys(files)) {
+    const absPath = join(agentPath, relPath);
+    if (existsSync(absPath)) {
+      unlinkSync(absPath);
+      removed.push(relPath);
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * Detect which editors have hooks installed.
+ */
+export function detectInstalledHooks(agentPath: string): EditorId[] {
+  const installed: EditorId[] = [];
+
+  for (const editor of SUPPORTED_EDITORS) {
+    const files = getEditorFiles(editor, agentPath);
+    const allExist = Object.keys(files).every((relPath) => existsSync(join(agentPath, relPath)));
+    if (allExist) {
+      installed.push(editor);
+    }
+  }
+
+  return installed;
+}