@dot-ai/cli 0.5.2 → 0.7.0

package/src/index.ts

@@ -1,17 +1,10 @@
 #!/usr/bin/env node
 import { argv, cwd, exit } from 'node:process';
-import { mkdir, writeFile, access } from 'node:fs/promises';
-import { join } from 'node:path';
+import { mkdir, writeFile, access, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 import {
-  loadConfig,
-  resolveConfig,
-  injectRoot,
-  registerDefaults,
-  clearProviders,
-  createProviders,
-  boot,
-  enrich,
-  formatContext,
+  DotAiRuntime,
+  clearBootCache,
 } from '@dot-ai/core';
 
 const args = argv.slice(2);
@@ -28,23 +21,282 @@ async function main(): Promise<void> {
     case 'trace':
       await cmdTrace(args.slice(1));
       break;
+    case 'cache':
+      await cmdCache(args.slice(1));
+      break;
+    case 'tools':
+      await cmdTools(args.slice(1));
+      break;
+    case 'commands':
+      await cmdCommands();
+      break;
+    case 'migrate':
+      await cmdMigrate();
+      break;
+    case '--version':
+    case '-v':
+      console.log('dot-ai v0.6.0');
+      break;
+    default:
+      // Try to execute as a tool: dot-ai <domain> <action> [args...]
+      if (command && !command.startsWith('-')) {
+        await cmdExecTool(args);
+      } else {
+        printHelp();
+        exit(command ? 1 : 0);
+      }
+  }
+}
+
+function printHelp(): void {
+  console.log('dot-ai v0.6.0\n');
+  console.log('Commands:');
+  console.log('  init                          Create .ai/ directory with defaults');
+  console.log('  boot                          Run boot and show workspace info');
+  console.log('  trace "<prompt>"              Dry-run enrich pipeline with token estimates');
+  console.log('  tools [--json]                List registered tools from extensions');
+  console.log('  commands                      List registered commands from extensions');
+  console.log('  cache clear                   Clear boot cache');
+  console.log('  cache status                  Show cache status');
+  console.log('  migrate                       Migrate dot-ai.yml to settings.json');
+  console.log('');
+  console.log('Tool execution:');
+  console.log('  dot-ai <domain> <action> [args...]');
+  console.log('  dot-ai memory recall "query"  Execute memory_recall tool');
+  console.log('  dot-ai tasks list             Execute task_list tool');
+  console.log('');
+  console.log('Flags:');
+  console.log('  --json                        Output as JSON');
+  console.log('  --workspace <path>            Override workspace root');
+}
+
+// ── Workspace Detection ──
+
+async function resolveWorkspace(): Promise<string> {
+  const wsIdx = args.indexOf('--workspace');
+  if (wsIdx !== -1 && args[wsIdx + 1]) {
+    return resolve(args[wsIdx + 1]);
+  }
+
+  let dir = cwd();
+  const root = resolve('/');
+
+  while (dir !== root) {
+    try {
+      await access(join(dir, '.ai'));
+      return dir;
+    } catch {
+      dir = resolve(dir, '..');
+    }
+  }
+
+  return cwd();
+}
+
+// ── Boot Runtime ──
+
+async function bootRuntime(workspaceRoot?: string): Promise<DotAiRuntime> {
+  const ws = workspaceRoot ?? await resolveWorkspace();
+  const runtime = new DotAiRuntime({ workspaceRoot: ws });
+  await runtime.boot();
+  return runtime;
+}
+
+// ── Tool Execution ──
+
+async function cmdExecTool(rawArgs: string[]): Promise<void> {
+  const jsonMode = rawArgs.includes('--json');
+  const cleanArgs = rawArgs.filter(a => a !== '--json' && a !== '--workspace').filter((_, i, arr) => {
+    if (i > 0 && arr[i - 1] === '--workspace') return false;
+    return true;
+  });
+
+  const domain = cleanArgs[0];
+  const action = cleanArgs[1];
+
+  if (!domain || !action) {
+    console.error(`Unknown command: ${domain ?? ''}`);
+    console.error('Run "dot-ai" for help.');
+    exit(1);
+  }
+
+  const toolName = `${domain}_${action}`;
+  const toolArgs = cleanArgs.slice(2);
+
+  const runtime = await bootRuntime();
+  const tools = runtime.capabilities;
+
+  const tool = tools.find(t => t.name === toolName);
+  if (!tool) {
+    console.error(`Unknown tool: ${toolName}`);
+    console.error('Available tools:');
+    for (const t of tools) {
+      console.error(`  ${t.name} — ${t.description}`);
+    }
+    exit(1);
+  }
+
+  const input = parseToolArgs(toolArgs, tool.parameters);
+
+  try {
+    const result = await tool.execute(input);
+    if (jsonMode) {
+      console.log(JSON.stringify({ content: result.text, details: result.details }, null, 2));
+    } else {
+      console.log(result.text);
+    }
+  } catch (err) {
+    console.error(`Tool execution error: ${err instanceof Error ? err.message : err}`);
+    exit(1);
+  } finally {
+    await runtime.flush();
+  }
+}
+
+function parseToolArgs(rawArgs: string[], schema: Record<string, unknown>): Record<string, unknown> {
+  const input: Record<string, unknown> = {};
+  const props = (schema as { properties?: Record<string, { type?: string }> }).properties ?? {};
+  const required = (schema as { required?: string[] }).required ?? [];
+  const propNames = Object.keys(props);
+
+  let positionalIdx = 0;
+  let i = 0;
+
+  while (i < rawArgs.length) {
+    const arg = rawArgs[i];
+
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        input[key] = coerceValue(value, props[key]?.type);
+      } else {
+        const key = arg.slice(2);
+        const nextArg = rawArgs[i + 1];
+        if (nextArg && !nextArg.startsWith('--')) {
+          input[key] = coerceValue(nextArg, props[key]?.type);
+          i++;
+        } else {
+          input[key] = true;
+        }
+      }
+    } else {
+      const targetKey = required[positionalIdx] ?? propNames.find(p => !(p in input));
+      if (targetKey) {
+        input[targetKey] = coerceValue(arg, props[targetKey]?.type);
+      }
+      positionalIdx++;
+    }
+    i++;
+  }
+
+  return input;
+}
+
+function coerceValue(value: string, type?: string): unknown {
+  if (type === 'number') return Number(value);
+  if (type === 'boolean') return value === 'true';
+  if (type === 'array') {
+    try { return JSON.parse(value); } catch { return value.split(','); }
+  }
+  return value;
+}
+
+// ── Tools List ──
+
+async function cmdTools(rawArgs: string[]): Promise<void> {
+  const jsonMode = rawArgs.includes('--json');
+  const runtime = await bootRuntime();
+  const tools = runtime.capabilities;
+
+  if (jsonMode) {
+    const output = tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      category: t.category,
+      readOnly: t.readOnly,
+    }));
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    if (tools.length === 0) {
+      console.log('No tools registered.');
+    } else {
+      console.log(`${tools.length} tool(s) registered:\n`);
+      for (const t of tools) {
+        const cat = t.category ? ` [${t.category}]` : '';
+        const ro = t.readOnly ? ' (read-only)' : '';
+        console.log(`  ${t.name}${cat}${ro}`);
+        console.log(`    ${t.description}`);
+      }
+    }
+  }
+
+  await runtime.flush();
+}
+
+// ── Commands List ──
+
+async function cmdCommands(): Promise<void> {
+  const runtime = await bootRuntime();
+  const runner = runtime.runner;
+  const commands = runner?.commands ?? [];
+
+  if (commands.length === 0) {
+    console.log('No commands registered.');
+  } else {
+    console.log(`${commands.length} command(s) registered:\n`);
+    for (const cmd of commands) {
+      const params = cmd.parameters?.map((p: { name: string; required?: boolean }) =>
+        p.required ? `<${p.name}>` : `[${p.name}]`
+      ).join(' ') ?? '';
+      console.log(`  /${cmd.name} ${params}`);
+      console.log(`    ${cmd.description}`);
+    }
+  }
+
+  await runtime.flush();
+}
+
+// ── Cache Management ──
+
+async function cmdCache(rawArgs: string[]): Promise<void> {
+  const subcommand = rawArgs[0];
+  const ws = await resolveWorkspace();
+  const cacheDir = join(ws, '.ai', '.cache');
+
+  switch (subcommand) {
+    case 'clear': {
+      await clearBootCache(ws);
+      console.log('Cache cleared.');
+      break;
+    }
+    case 'status': {
+      try {
+        const bootJson = join(cacheDir, 'boot.json');
+        const s = await stat(bootJson);
+        console.log(`Cache: ${cacheDir}`);
+        console.log(`  boot.json: ${s.size} bytes, modified ${s.mtime.toISOString()}`);
+      } catch {
+        console.log('No cache found.');
+      }
+      break;
+    }
     default:
-      console.log('dot-ai v0.4.0\n');
-      console.log('Commands:');
-      console.log('  init              Create .ai/ directory with defaults');
-      console.log('  boot              Run boot and show workspace info');
-      console.log('  trace "<prompt>"  Dry-run enrich pipeline with token estimates');
-      exit(command ? 1 : 0);
+      console.log('Usage: dot-ai cache <clear|status>');
+      exit(1);
   }
 }
 
+// ── Init ──
+
 async function cmdInit(): Promise<void> {
   const root = cwd();
   const aiDir = join(root, '.ai');
 
   try {
-    await access(join(aiDir, 'dot-ai.yml'));
-    console.log('.ai/dot-ai.yml already exists. Nothing to do.');
+    await access(join(aiDir, 'settings.json'));
+    console.log('.ai/settings.json already exists. Nothing to do.');
     return;
   } catch {
     // Doesn't exist, create it
@@ -52,21 +304,10 @@ async function cmdInit(): Promise<void> {
 
   await mkdir(aiDir, { recursive: true });
 
-  await writeFile(join(aiDir, 'dot-ai.yml'), [
-    '# dot-ai configuration',
-    '# Uncomment and customize providers as needed.',
-    '# Default: file-based providers reading from .ai/ directory.',
-    '#',
-    '# memory:',
-    '#   use: "@dot-ai/provider-file-memory"',
-    '#',
-    '# skills:',
-    '#   use: "@dot-ai/provider-file-skills"',
-    '#',
-    '# routing:',
-    '#   use: "@dot-ai/provider-rules-routing"',
-    '',
-  ].join('\n'));
+  await writeFile(join(aiDir, 'settings.json'), JSON.stringify({
+    extensions: [],
+    packages: [],
+  }, null, 2) + '\n');
 
   await writeFile(join(aiDir, 'AGENTS.md'), [
     '# AGENTS.md',
@@ -80,32 +321,34 @@ async function cmdInit(): Promise<void> {
   ].join('\n'));
 
   console.log('Created:');
-  console.log('  .ai/dot-ai.yml    (config)');
-  console.log('  .ai/AGENTS.md     (template)');
-  console.log('\nNext: add SOUL.md, USER.md, skills/, memory/ as needed.');
+  console.log('  .ai/settings.json  (config)');
+  console.log('  .ai/AGENTS.md      (template)');
+  console.log('\nNext: add SOUL.md, USER.md, skills/, extensions/ as needed.');
 }
 
+// ── Boot ──
+
 async function cmdBoot(): Promise<void> {
-  const root = cwd();
+  const root = await resolveWorkspace();
   const start = performance.now();
 
-  clearProviders();
-  registerDefaults();
-
-  const rawConfig = await loadConfig(root);
-  const config = injectRoot(rawConfig, root);
-  const providers = await createProviders(config);
-  const cache = await boot(providers);
-
+  const runtime = new DotAiRuntime({ workspaceRoot: root });
+  await runtime.boot();
   const duration = Math.round(performance.now() - start);
+  const diag = runtime.diagnostics;
 
   console.log(`dot-ai boot — ${root}\n`);
-  console.log(`Identities: ${cache.identities.length}${cache.identities.length > 0 ? ` (${cache.identities.map(i => i.type).join(', ')})` : ''}`);
-  console.log(`Skills: ${cache.skills.length}${cache.skills.length > 0 ? ` (${cache.skills.map(s => s.name).join(', ')})` : ''}`);
-  console.log(`Vocabulary: ${cache.vocabulary.length} labels`);
+  console.log(`Extensions: ${diag.extensions.length}`);
+  console.log(`Vocabulary: ${diag.vocabularySize} labels`);
+  console.log(`Tools: ${diag.capabilityCount}`);
+  console.log(`Tiers: ${diag.usedTiers.join(', ') || 'none'}`);
   console.log(`\nBoot complete in ${duration}ms`);
+
+  await runtime.flush();
 }
 
+// ── Trace ──
+
 async function cmdTrace(rawArgs: string[]): Promise<void> {
   const flags = new Set(rawArgs.filter(a => a.startsWith('--')));
   const prompt = rawArgs.filter(a => !a.startsWith('--')).join(' ');
@@ -117,109 +360,73 @@ async function cmdTrace(rawArgs: string[]): Promise<void> {
     exit(1);
   }
 
-  const root = cwd();
+  const root = await resolveWorkspace();
   const start = performance.now();
 
-  clearProviders();
-  registerDefaults();
-
-  const rawConfig = await loadConfig(root);
-  const config = injectRoot(rawConfig, root);
-  const resolved = resolveConfig(rawConfig);
-  const providers = await createProviders(config);
-  const cache = await boot(providers);
-  const ctx = await enrich(prompt, providers, cache);
-
-  // Load skill content for matched skills
-  for (const skill of ctx.skills) {
-    if (!skill.content && skill.name) {
-      skill.content = await providers.skills.load(skill.name) ?? undefined;
-    }
-  }
-
+  const runtime = new DotAiRuntime({ workspaceRoot: root });
+  await runtime.boot();
+  const result = await runtime.processPrompt(prompt);
   const duration = Math.round(performance.now() - start);
 
-  // Compute token estimates
-  const identityChars = cache.identities.reduce((sum, i) => sum + (i.content?.length ?? 0), 0);
-  const skillChars = ctx.skills.reduce((sum, s) => sum + (s.content?.length ?? 0), 0);
-  const memoryChars = ctx.memories.reduce((sum, m) => sum + m.content.length, 0);
-  const totalChars = skillChars + memoryChars;
-
-  // Check for disabled skills
-  const disabledList = typeof resolved.skills?.with?.disabled === 'string'
-    ? resolved.skills.with.disabled.split(',').map((s: string) => s.trim()).filter(Boolean)
-    : [];
-
   if (jsonMode) {
     const output = {
       prompt,
-      sessionStart: {
-        identityCount: cache.identities.length,
-        identityChars,
-        estimatedTokens: Math.round(identityChars / 4),
-      },
-      userPromptSubmit: {
-        labels: ctx.labels.map(l => l.name),
-        skills: ctx.skills.map(s => ({
-          name: s.name,
-          chars: s.content?.length ?? 0,
-        })),
-        memoryCount: ctx.memories.length,
-        memoryChars,
-        toolCount: ctx.tools.length,
-        routing: ctx.routing,
-        totalChars,
-        estimatedTokens: Math.round(totalChars / 4),
-      },
-      disabled: disabledList,
-      vocabularySize: cache.vocabulary.length,
+      labels: result.labels?.map(l => l.name),
+      routing: result.routing,
+      sections: result.sections?.map(s => ({
+        id: s.id,
+        title: s.title,
+        priority: s.priority,
+        source: s.source,
+        chars: s.content.length,
+      })),
+      totalChars: result.formatted.length,
+      estimatedTokens: Math.round(result.formatted.length / 4),
+      toolCount: result.capabilities.length,
       durationMs: duration,
     };
     console.log(JSON.stringify(output, null, 2));
-    return;
-  }
+  } else {
+    console.log(`dot-ai trace — "${prompt}"\n`);
 
-  // Human-readable output
-  console.log(`dot-ai trace — "${prompt}"\n`);
+    const labels = result.labels ?? result.enriched.labels;
+    console.log(`Labels: [${labels.map(l => l.name).join(', ')}]`);
 
-  // SessionStart section
-  console.log(`── SessionStart (one-time) ──`);
-  console.log(`  ${cache.identities.length} identities: ${identityChars.toLocaleString()} chars (~${Math.round(identityChars / 4).toLocaleString()} tokens)`);
+    if (result.sections && result.sections.length > 0) {
+      console.log(`\nSections (${result.sections.length}):`);
+      for (const s of result.sections) {
+        console.log(`  [${s.priority}] ${s.title} (${s.source}, ${s.content.length} chars)`);
+      }
+    }
 
-  // UserPromptSubmit section
-  console.log(`\n── UserPromptSubmit ──`);
-  console.log(`  Labels: [${ctx.labels.map(l => l.name).join(', ')}]`);
+    const routing = result.routing ?? result.enriched.routing;
+    console.log(`\nRouting: ${routing?.model ?? 'default'} (${routing?.reason ?? 'none'})`);
+    console.log(`Total: ${result.formatted.length.toLocaleString()} chars (~${Math.round(result.formatted.length / 4).toLocaleString()} tokens)`);
+    console.log(`Tools: ${result.capabilities.length}`);
 
-  if (ctx.skills.length > 0) {
-    const skillDetails = ctx.skills.map(s => `${s.name} (${(s.content?.length ?? 0).toLocaleString()} chars)`);
-    console.log(`  Skills: ${skillDetails.join(', ')}`);
-  } else {
-    console.log(`  Skills: none matched`);
+    if (verbose) {
+      console.log(`\n── Injected markdown (${result.formatted.length.toLocaleString()} chars) ──`);
+      console.log(result.formatted);
+    }
+
+    console.log(`\nTrace complete in ${duration}ms`);
   }
 
-  console.log(`  Memory: ${ctx.memories.length} entries (${memoryChars.toLocaleString()} chars)`);
-  console.log(`  Tools: ${ctx.tools.length} matched`);
-  console.log(`  Routing: ${ctx.routing.model} (${ctx.routing.reason})`);
-  console.log(`  Total: ${totalChars.toLocaleString()} chars (~${Math.round(totalChars / 4).toLocaleString()} tokens)`);
+  await runtime.flush();
+}
 
-  // Disabled skills
-  if (disabledList.length > 0) {
-    console.log(`\n── Disabled skills ──`);
-    console.log(`  ${disabledList.join(', ')} (via config)`);
-  }
+// ── Migrate ──
 
-  // Verbose: show the actual markdown that would be injected
-  if (verbose) {
-    const formatted = formatContext(ctx, {
-      skipIdentities: true,
-      maxSkillLength: 3000,
-      maxSkills: 5,
-    });
-    console.log(`\n── Injected markdown (${formatted.length.toLocaleString()} chars) ──`);
-    console.log(formatted);
+async function cmdMigrate(): Promise<void> {
+  const ws = await resolveWorkspace();
+  const { migrateConfig } = await import('@dot-ai/core');
+  const result = await migrateConfig(ws);
+  if (result) {
+    console.log(`Migrated config to ${result}`);
+    console.log('You can now delete .ai/dot-ai.yml');
+  } else {
+    console.log('No dot-ai.yml found to migrate.');
   }
-
-  console.log(`\nTrace complete in ${duration}ms`);
 }
 
 main().catch((err) => {