@dot-ai/cli 0.5.2

package/src/__tests__/cli.test.ts

@@ -0,0 +1,346 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mkdtemp, mkdir, writeFile, readFile, access } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  loadConfig,
+  registerDefaults,
+  clearProviders,
+  createProviders,
+  boot,
+  enrich,
+} from '@dot-ai/core';
+
+// ── init command logic ───────────────────────────────────────────────────────
+
+async function runInit(root: string): Promise<string> {
+  const aiDir = join(root, '.ai');
+  const lines: string[] = [];
+
+  try {
+    await access(join(aiDir, 'dot-ai.yml'));
+    lines.push('.ai/dot-ai.yml already exists. Nothing to do.');
+    return lines.join('\n');
+  } catch {
+    // Doesn't exist, create it
+  }
+
+  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, 'AGENTS.md'), [
+    '# AGENTS.md',
+    '',
+    '> Your workspace rules and conventions go here.',
+    '',
+    '## Rules',
+    '',
+    '- ...',
+    '',
+  ].join('\n'));
+
+  lines.push('Created:');
+  lines.push('  .ai/dot-ai.yml    (config)');
+  lines.push('  .ai/AGENTS.md     (template)');
+  lines.push('\nNext: add SOUL.md, USER.md, skills/, memory/ as needed.');
+  return lines.join('\n');
+}
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+async function setupAiDir(root: string): Promise<void> {
+  const ai = join(root, '.ai');
+  await mkdir(ai, { recursive: true });
+  await mkdir(join(ai, 'memory'), { recursive: true });
+  await mkdir(join(ai, 'skills', 'ts-standards'), { recursive: true });
+  await mkdir(join(ai, 'skills', 'code-review'), { recursive: true });
+  await mkdir(join(ai, 'tools'), { recursive: true });
+
+  await writeFile(join(ai, 'AGENTS.md'), '# AGENTS.md\n\nYou are Kiwi.');
+  await writeFile(join(ai, 'SOUL.md'), '# SOUL.md\n\nBe genuine.');
+  await writeFile(join(ai, 'USER.md'), '# USER.md\n\nJo, developer.');
+  await writeFile(join(ai, 'IDENTITY.md'), '# IDENTITY.md\n\nName: Kiwi');
+
+  await writeFile(join(ai, 'skills', 'ts-standards', 'SKILL.md'), [
+    '---',
+    'description: TypeScript coding standards',
+    'labels: [typescript, code, standards]',
+    'triggers: [auto]',
+    '---',
+    '',
+    '## TypeScript Standards',
+    '- Use strict mode',
+  ].join('\n'));
+
+  await writeFile(join(ai, 'skills', 'code-review', 'SKILL.md'), [
+    '---',
+    'description: Code review guidelines',
+    'labels: [review, code-fix, bug]',
+    'triggers: [auto]',
+    '---',
+    '',
+    '## Code Review',
+    '- Check for edge cases',
+  ].join('\n'));
+
+  await writeFile(join(ai, 'tools', 'eslint.yaml'), [
+    'name: eslint',
+    'description: TypeScript linter',
+    'labels: [typescript, lint, code]',
+  ].join('\n'));
+
+  await writeFile(join(ai, 'memory', '2026-03-01.md'), [
+    '- Fixed auth middleware N+1 query bug',
+    '- Decided to use JWT for auth tokens',
+  ].join('\n'));
+
+  await writeFile(join(ai, 'dot-ai.yml'), [
+    '# dot-ai config',
+    'memory:',
+    '  use: @dot-ai/provider-file-memory',
+    `    root: ${root}`,
+    'skills:',
+    '  use: @dot-ai/provider-file-skills',
+    `    root: ${root}`,
+    'identity:',
+    '  use: @dot-ai/provider-file-identity',
+    `    root: ${root}`,
+    'routing:',
+    '  use: @dot-ai/provider-rules-routing',
+    'tasks:',
+    '  use: @dot-ai/provider-file-tasks',
+    `    root: ${root}`,
+    'tools:',
+    '  use: @dot-ai/provider-file-tools',
+    `    root: ${root}`,
+  ].join('\n'));
+}
+
+// ── init tests ───────────────────────────────────────────────────────────────
+
+describe('init command', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'dot-ai-cli-init-'));
+  });
+
+  it('creates .ai/dot-ai.yml in empty directory', async () => {
+    await runInit(root);
+    const content = await readFile(join(root, '.ai', 'dot-ai.yml'), 'utf8');
+    expect(content).toContain('# dot-ai configuration');
+  });
+
+  it('creates .ai/AGENTS.md in empty directory', async () => {
+    await runInit(root);
+    const content = await readFile(join(root, '.ai', 'AGENTS.md'), 'utf8');
+    expect(content).toContain('# AGENTS.md');
+  });
+
+  it('dot-ai.yml contains commented provider examples', async () => {
+    await runInit(root);
+    const content = await readFile(join(root, '.ai', 'dot-ai.yml'), 'utf8');
+    expect(content).toContain('@dot-ai/provider-file-memory');
+    expect(content).toContain('@dot-ai/provider-file-skills');
+    expect(content).toContain('@dot-ai/provider-rules-routing');
+  });
+
+  it('AGENTS.md is a template with ## Rules section', async () => {
+    await runInit(root);
+    const content = await readFile(join(root, '.ai', 'AGENTS.md'), 'utf8');
+    expect(content).toContain('## Rules');
+  });
+
+  it('does nothing if dot-ai.yml already exists', async () => {
+    await mkdir(join(root, '.ai'), { recursive: true });
+    await writeFile(join(root, '.ai', 'dot-ai.yml'), '# existing config\n');
+
+    const output = await runInit(root);
+
+    expect(output).toContain('already exists');
+    // File should be unchanged
+    const content = await readFile(join(root, '.ai', 'dot-ai.yml'), 'utf8');
+    expect(content).toBe('# existing config\n');
+  });
+
+  it('works if .ai/ directory already exists without dot-ai.yml', async () => {
+    await mkdir(join(root, '.ai'), { recursive: true });
+    await writeFile(join(root, '.ai', 'AGENTS.md'), '# existing\n');
+
+    await runInit(root);
+
+    // dot-ai.yml should be created
+    const content = await readFile(join(root, '.ai', 'dot-ai.yml'), 'utf8');
+    expect(content).toContain('# dot-ai configuration');
+  });
+});
+
+// ── boot command logic ────────────────────────────────────────────────────────
+
+describe('boot command (core pipeline)', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    clearProviders();
+    registerDefaults();
+    root = await mkdtemp(join(tmpdir(), 'dot-ai-cli-boot-'));
+    await setupAiDir(root);
+  });
+
+  it('loads config and creates providers', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    expect(providers.memory).toBeDefined();
+    expect(providers.skills).toBeDefined();
+    expect(providers.identity).toBeDefined();
+    expect(providers.routing).toBeDefined();
+    expect(providers.tools).toBeDefined();
+  });
+
+  it('boot returns identities, skills, vocabulary', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    expect(cache.identities.length).toBe(4); // AGENTS, SOUL, USER, IDENTITY
+    expect(cache.skills.length).toBe(2);     // ts-standards, code-review
+    expect(cache.vocabulary.length).toBeGreaterThan(0);
+  });
+
+  it('vocabulary contains labels from skills and tools', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    expect(cache.vocabulary).toContain('typescript');
+    expect(cache.vocabulary).toContain('code');
+    expect(cache.vocabulary).toContain('bug');
+  });
+
+  it('identities have correct types', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const types = cache.identities.map(i => i.type);
+    expect(types).toContain('agents');
+    expect(types).toContain('soul');
+    expect(types).toContain('user');
+    expect(types).toContain('identity');
+  });
+});
+
+// ── trace command logic ───────────────────────────────────────────────────────
+
+describe('trace command (enrich pipeline)', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    clearProviders();
+    registerDefaults();
+    root = await mkdtemp(join(tmpdir(), 'dot-ai-cli-trace-'));
+    await setupAiDir(root);
+  });
+
+  it('enrich returns labels matching prompt vocabulary', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('Fix the TypeScript bug', providers, cache);
+
+    expect(ctx.labels.some(l => l.name === 'typescript')).toBe(true);
+    expect(ctx.labels.some(l => l.name === 'bug')).toBe(true);
+  });
+
+  it('enrich returns matched skills for typescript prompt', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('Fix the TypeScript code', providers, cache);
+
+    expect(ctx.skills.some(s => s.name === 'ts-standards')).toBe(true);
+  });
+
+  it('enrich returns matched tools for typescript prompt', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('Fix the TypeScript bug', providers, cache);
+
+    expect(ctx.tools.some(t => t.name === 'eslint')).toBe(true);
+  });
+
+  it('enrich returns memories related to prompt', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('Fix the auth bug', providers, cache);
+
+    expect(ctx.memories.some(m => m.content.includes('auth'))).toBe(true);
+  });
+
+  it('enrich returns routing result', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('Fix the bug', providers, cache);
+
+    expect(ctx.routing.model).toBeDefined();
+    expect(ctx.routing.reason).toBeDefined();
+  });
+
+  it('enrich returns identities from boot cache', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const ctx = await enrich('anything', providers, cache);
+
+    expect(ctx.identities.length).toBe(4);
+  });
+
+  it('enrich with unrelated prompt returns no matched skills', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    // "hello world" doesn't match any known label
+    const ctx = await enrich('hello world', providers, cache);
+
+    expect(ctx.labels.length).toBe(0);
+    expect(ctx.skills.length).toBe(0);
+    expect(ctx.tools.length).toBe(0);
+  });
+
+  it('different prompts match different skills', async () => {
+    const config = await loadConfig(root);
+    const providers = await createProviders(config);
+    const cache = await boot(providers);
+
+    const tsCtx = await enrich('Fix TypeScript code', providers, cache);
+    const reviewCtx = await enrich('Review this code for bugs', providers, cache);
+
+    expect(tsCtx.skills.some(s => s.name === 'ts-standards')).toBe(true);
+    expect(reviewCtx.skills.some(s => s.name === 'code-review')).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,228 @@
+#!/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 {
+  loadConfig,
+  resolveConfig,
+  injectRoot,
+  registerDefaults,
+  clearProviders,
+  createProviders,
+  boot,
+  enrich,
+  formatContext,
+} from '@dot-ai/core';
+
+const args = argv.slice(2);
+const command = args[0];
+
+async function main(): Promise<void> {
+  switch (command) {
+    case 'init':
+      await cmdInit();
+      break;
+    case 'boot':
+      await cmdBoot();
+      break;
+    case 'trace':
+      await cmdTrace(args.slice(1));
+      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);
+  }
+}
+
+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.');
+    return;
+  } catch {
+    // Doesn't exist, create it
+  }
+
+  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, 'AGENTS.md'), [
+    '# AGENTS.md',
+    '',
+    '> Your workspace rules and conventions go here.',
+    '',
+    '## Rules',
+    '',
+    '- ...',
+    '',
+  ].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.');
+}
+
+async function cmdBoot(): Promise<void> {
+  const root = cwd();
+  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 duration = Math.round(performance.now() - start);
+
+  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(`\nBoot complete in ${duration}ms`);
+}
+
+async function cmdTrace(rawArgs: string[]): Promise<void> {
+  const flags = new Set(rawArgs.filter(a => a.startsWith('--')));
+  const prompt = rawArgs.filter(a => !a.startsWith('--')).join(' ');
+  const jsonMode = flags.has('--json');
+  const verbose = flags.has('--verbose');
+
+  if (!prompt) {
+    console.error('Usage: dot-ai trace "<prompt>" [--json] [--verbose]');
+    exit(1);
+  }
+
+  const root = cwd();
+  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 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,
+      durationMs: duration,
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  console.log(`dot-ai trace — "${prompt}"\n`);
+
+  // SessionStart section
+  console.log(`── SessionStart (one-time) ──`);
+  console.log(`  ${cache.identities.length} identities: ${identityChars.toLocaleString()} chars (~${Math.round(identityChars / 4).toLocaleString()} tokens)`);
+
+  // UserPromptSubmit section
+  console.log(`\n── UserPromptSubmit ──`);
+  console.log(`  Labels: [${ctx.labels.map(l => l.name).join(', ')}]`);
+
+  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`);
+  }
+
+  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)`);
+
+  // Disabled skills
+  if (disabledList.length > 0) {
+    console.log(`\n── Disabled skills ──`);
+    console.log(`  ${disabledList.join(', ')} (via config)`);
+  }
+
+  // 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);
+  }
+
+  console.log(`\nTrace complete in ${duration}ms`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2023"],
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}