@soleri/cli 9.11.0 → 9.13.0

package/src/__tests__/uninstall-full.test.ts

@@ -0,0 +1,566 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Mock @clack/prompts to suppress console output during tests
+vi.mock('@clack/prompts', () => ({
+  log: {
+    success: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+  },
+  confirm: vi.fn(),
+  isCancel: vi.fn(),
+}));
+
+import {
+  detectArtifacts,
+  removeDirectory,
+  removeClaudeMdBlock,
+  removePermissionEntries,
+  removeLauncherScript,
+} from '../utils/agent-artifacts.js';
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makeTempDir(suffix: string): string {
+  const dir = join(
+    tmpdir(),
+    `uninstall-full-test-${suffix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ---------------------------------------------------------------------------
+// detectArtifacts
+// ---------------------------------------------------------------------------
+
+describe('detectArtifacts', () => {
+  let tempDir: string;
+  let originalHome: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('detect');
+    originalHome = process.env.HOME ?? '';
+    process.env.HOME = tempDir;
+    process.env.USERPROFILE = tempDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalHome) process.env.USERPROFILE = originalHome;
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('detects an existing agent project directory', () => {
+    const agentDir = join(tempDir, 'my-agent');
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(join(agentDir, 'agent.yaml'), 'name: test\n');
+
+    const manifest = detectArtifacts('my-agent', agentDir);
+    expect(manifest.projectDir).not.toBeNull();
+    expect(manifest.projectDir!.exists).toBe(true);
+    expect(manifest.projectDir!.path).toBe(agentDir);
+  });
+
+  it('returns exists: false for a non-existent agent directory', () => {
+    const nonExistent = join(tempDir, 'does-not-exist');
+    const manifest = detectArtifacts('ghost-agent', nonExistent);
+
+    expect(manifest.projectDir).not.toBeNull();
+    expect(manifest.projectDir!.exists).toBe(false);
+    expect(manifest.claudeMdBlocks).toEqual([]);
+    expect(manifest.mcpServerEntries).toEqual([]);
+    expect(manifest.permissionEntries).toEqual([]);
+  });
+
+  it('detects CLAUDE.md block with matching markers', () => {
+    const claudeMdPath = join(tempDir, 'CLAUDE.md');
+    const content = [
+      '# My Config',
+      '',
+      '<!-- agent:test-agent:mode -->',
+      '## Test Agent Mode',
+      'Some content here.',
+      '<!-- /agent:test-agent:mode -->',
+      '',
+      '# Other stuff',
+    ].join('\n');
+    writeFileSync(claudeMdPath, content);
+
+    const manifest = detectArtifacts('test-agent', join(tempDir, 'nope'));
+    expect(manifest.claudeMdBlocks.length).toBe(1);
+    expect(manifest.claudeMdBlocks[0].startLine).toBe(3);
+    expect(manifest.claudeMdBlocks[0].endLine).toBe(6);
+    expect(manifest.claudeMdBlocks[0].path).toBe(claudeMdPath);
+  });
+
+  it('returns empty blocks when end marker is missing', () => {
+    const claudeMdPath = join(tempDir, 'CLAUDE.md');
+    const content = [
+      '# My Config',
+      '<!-- agent:test-agent:mode -->',
+      '## Test Agent Mode',
+      'Some content here.',
+      // Missing end marker
+    ].join('\n');
+    writeFileSync(claudeMdPath, content);
+
+    const manifest = detectArtifacts('test-agent', join(tempDir, 'nope'));
+    expect(manifest.claudeMdBlocks).toEqual([]);
+  });
+
+  it('detects permission entries with matching prefix', () => {
+    const claudeDir = join(tempDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = join(claudeDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: [
+          'mcp__maria__design_check',
+          'mcp__maria__color_pairs',
+          'mcp__ernesto__vault_search',
+          'mcp__ernesto__memory_capture',
+          'Bash(*)',
+        ],
+      },
+    };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+    const manifest = detectArtifacts('maria', join(tempDir, 'nope'));
+    expect(manifest.permissionEntries.length).toBe(1);
+    expect(manifest.permissionEntries[0].matches).toEqual([
+      'mcp__maria__design_check',
+      'mcp__maria__color_pairs',
+    ]);
+    // Ernesto entries should NOT be included
+    expect(manifest.permissionEntries[0].matches).not.toContain('mcp__ernesto__vault_search');
+  });
+
+  it('does not match permission prefix that is a substring of another agent', () => {
+    const claudeDir = join(tempDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = join(claudeDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: ['mcp__marianne__some_op', 'mcp__maria__design_check'],
+      },
+    };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+    const manifest = detectArtifacts('maria', join(tempDir, 'nope'));
+    expect(manifest.permissionEntries.length).toBe(1);
+    // Only the exact prefix match — mcp__maria__ does NOT match mcp__marianne__
+    expect(manifest.permissionEntries[0].matches).toEqual(['mcp__maria__design_check']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// removeDirectory
+// ---------------------------------------------------------------------------
+
+describe('removeDirectory', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('rmdir');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes a directory with files', async () => {
+    const target = join(tempDir, 'to-remove');
+    mkdirSync(join(target, 'sub'), { recursive: true });
+    writeFileSync(join(target, 'file.txt'), 'data');
+    writeFileSync(join(target, 'sub', 'nested.txt'), 'nested');
+
+    const result = await removeDirectory(target);
+    expect(result.removed).toBe(true);
+    expect(result.path).toBe(target);
+    expect(existsSync(target)).toBe(false);
+  });
+
+  it('returns removed: false when called on a non-existent path (idempotent)', async () => {
+    const gone = join(tempDir, 'already-gone');
+    const result = await removeDirectory(gone);
+    expect(result.removed).toBe(false);
+    expect(result.path).toBe(gone);
+    expect(result.error).toBeUndefined();
+  });
+
+  it('is idempotent — second call after removal returns removed: false', async () => {
+    const target = join(tempDir, 'once');
+    mkdirSync(target);
+    writeFileSync(join(target, 'f.txt'), 'x');
+
+    const first = await removeDirectory(target);
+    expect(first.removed).toBe(true);
+
+    const second = await removeDirectory(target);
+    expect(second.removed).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// removeClaudeMdBlock
+// ---------------------------------------------------------------------------
+
+describe('removeClaudeMdBlock', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('claudemd');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes the block including markers', async () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    const content = [
+      '# Config',
+      '',
+      '<!-- agent:foo:mode -->',
+      '## Foo Mode',
+      'content',
+      '<!-- /agent:foo:mode -->',
+      '',
+      '# Other',
+    ].join('\n');
+    writeFileSync(filePath, content);
+
+    const result = await removeClaudeMdBlock(filePath, 3, 6);
+    expect(result.removed).toBe(true);
+
+    const after = readFileSync(filePath, 'utf-8');
+    expect(after).not.toContain('<!-- agent:foo:mode -->');
+    expect(after).not.toContain('## Foo Mode');
+    expect(after).not.toContain('<!-- /agent:foo:mode -->');
+    expect(after).toContain('# Config');
+    expect(after).toContain('# Other');
+  });
+
+  it('collapses triple blank lines after removal', async () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    const content = [
+      '# Config',
+      '',
+      '',
+      '<!-- agent:foo:mode -->',
+      'stuff',
+      '<!-- /agent:foo:mode -->',
+      '',
+      '',
+      '# Other',
+    ].join('\n');
+    writeFileSync(filePath, content);
+
+    const result = await removeClaudeMdBlock(filePath, 4, 6);
+    expect(result.removed).toBe(true);
+
+    const after = readFileSync(filePath, 'utf-8');
+    // Should not have 3+ consecutive newlines
+    expect(after).not.toMatch(/\n{3,}/);
+  });
+
+  it('returns removed: false for a non-existent file', async () => {
+    const result = await removeClaudeMdBlock(join(tempDir, 'nope.md'), 1, 3);
+    expect(result.removed).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// removePermissionEntries
+// ---------------------------------------------------------------------------
+
+describe('removePermissionEntries', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('perms');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes only the matching agent entries, keeps others', async () => {
+    const filePath = join(tempDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: [
+          'mcp__maria__design_check',
+          'mcp__maria__color_pairs',
+          'mcp__ernesto__vault_search',
+          'Bash(*)',
+        ],
+      },
+    };
+    writeFileSync(filePath, JSON.stringify(settings, null, 2));
+
+    const result = await removePermissionEntries(filePath, 'maria');
+    expect(result.removed).toBe(true);
+
+    const after = JSON.parse(readFileSync(filePath, 'utf-8'));
+    expect(after.permissions.allow).toEqual(['mcp__ernesto__vault_search', 'Bash(*)']);
+  });
+
+  it('preserves 2-space JSON indentation', async () => {
+    const filePath = join(tempDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: ['mcp__agent__op', 'other'],
+      },
+    };
+    writeFileSync(filePath, JSON.stringify(settings, null, 2));
+
+    await removePermissionEntries(filePath, 'agent');
+
+    const raw = readFileSync(filePath, 'utf-8');
+    // Verify 2-space indent is present
+    expect(raw).toContain('  "permissions"');
+    // Should end with trailing newline
+    expect(raw.endsWith('\n')).toBe(true);
+  });
+
+  it('returns removed: false when no entries match', async () => {
+    const filePath = join(tempDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: ['mcp__other__op', 'Bash(*)'],
+      },
+    };
+    writeFileSync(filePath, JSON.stringify(settings, null, 2));
+
+    const result = await removePermissionEntries(filePath, 'maria');
+    expect(result.removed).toBe(false);
+  });
+
+  it('returns removed: false for a non-existent file', async () => {
+    const result = await removePermissionEntries(join(tempDir, 'nope.json'), 'agent');
+    expect(result.removed).toBe(false);
+    expect(result.error).toBeUndefined();
+  });
+
+  it('handles empty settings file with no permissions key', async () => {
+    const filePath = join(tempDir, 'settings.local.json');
+    writeFileSync(filePath, JSON.stringify({}, null, 2));
+
+    const result = await removePermissionEntries(filePath, 'agent');
+    expect(result.removed).toBe(false);
+  });
+
+  it('handles malformed JSON without throwing', async () => {
+    const filePath = join(tempDir, 'settings.local.json');
+    writeFileSync(filePath, '{ not valid json');
+
+    const result = await removePermissionEntries(filePath, 'agent');
+    expect(result.removed).toBe(false);
+    expect(result.error).toBe('Failed to parse JSON');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// removeLauncherScript
+// ---------------------------------------------------------------------------
+
+describe('removeLauncherScript', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('launcher');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes an existing file', async () => {
+    const scriptPath = join(tempDir, 'my-agent');
+    writeFileSync(scriptPath, '#!/bin/bash\necho hello\n');
+
+    const result = await removeLauncherScript(scriptPath);
+    expect(result.removed).toBe(true);
+    expect(result.path).toBe(scriptPath);
+    expect(existsSync(scriptPath)).toBe(false);
+  });
+
+  it('returns removed: false for a non-existent path', async () => {
+    const result = await removeLauncherScript(join(tempDir, 'nope'));
+    expect(result.removed).toBe(false);
+    expect(result.error).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration test: full detect → remove → verify cycle
+// ---------------------------------------------------------------------------
+
+describe('integration: detect → remove → verify', () => {
+  let tempDir: string;
+  let originalHome: string;
+  const AGENT_ID = 'test-agent';
+
+  beforeEach(() => {
+    tempDir = makeTempDir('integration');
+    originalHome = process.env.HOME ?? '';
+    process.env.HOME = tempDir;
+    process.env.USERPROFILE = tempDir;
+
+    // 1. Project directory
+    const projectDir = join(tempDir, 'projects', AGENT_ID);
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(join(projectDir, 'agent.yaml'), 'name: test-agent\n');
+
+    // 2. Legacy data directory
+    const legacyDir = join(tempDir, `.${AGENT_ID}`);
+    mkdirSync(legacyDir, { recursive: true });
+    writeFileSync(join(legacyDir, 'vault.db'), 'fake-db');
+
+    // 3. CLAUDE.md with agent block
+    const claudeMdPath = join(tempDir, 'CLAUDE.md');
+    const claudeMdContent = [
+      '# Home Config',
+      '',
+      `<!-- agent:${AGENT_ID}:mode -->`,
+      `## ${AGENT_ID} Mode`,
+      'Agent instructions here.',
+      `<!-- /agent:${AGENT_ID}:mode -->`,
+      '',
+      '# Other Stuff',
+    ].join('\n');
+    writeFileSync(claudeMdPath, claudeMdContent);
+
+    // 4. Permissions in settings.local.json
+    const claudeDir = join(tempDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = join(claudeDir, 'settings.local.json');
+    const settings = {
+      permissions: {
+        allow: [
+          `mcp__${AGENT_ID}__vault_search`,
+          `mcp__${AGENT_ID}__memory_capture`,
+          'mcp__other__something',
+          'Bash(*)',
+        ],
+      },
+    };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalHome) process.env.USERPROFILE = originalHome;
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('detects all artifacts, removes them, and verifies clean state', async () => {
+    const projectDir = join(tempDir, 'projects', AGENT_ID);
+    const legacyDir = join(tempDir, `.${AGENT_ID}`);
+    const claudeMdPath = join(tempDir, 'CLAUDE.md');
+    const settingsPath = join(tempDir, '.claude', 'settings.local.json');
+
+    // --- Phase 1: Detect ---
+    const manifest = detectArtifacts(AGENT_ID, projectDir);
+
+    expect(manifest.agentId).toBe(AGENT_ID);
+    expect(manifest.projectDir!.exists).toBe(true);
+    expect(manifest.dataDirLegacy!.exists).toBe(true);
+    expect(manifest.claudeMdBlocks.length).toBe(1);
+    expect(manifest.permissionEntries.length).toBe(1);
+    expect(manifest.permissionEntries[0].matches.length).toBe(2);
+
+    // --- Phase 2: Remove ---
+    // Permission entries
+    const permResult = await removePermissionEntries(settingsPath, AGENT_ID);
+    expect(permResult.removed).toBe(true);
+
+    // CLAUDE.md block
+    const block = manifest.claudeMdBlocks[0];
+    const blockResult = await removeClaudeMdBlock(block.path, block.startLine, block.endLine);
+    expect(blockResult.removed).toBe(true);
+
+    // Directories
+    const projResult = await removeDirectory(projectDir);
+    expect(projResult.removed).toBe(true);
+
+    const legacyResult = await removeDirectory(legacyDir);
+    expect(legacyResult.removed).toBe(true);
+
+    // --- Phase 3: Verify clean state ---
+    expect(existsSync(projectDir)).toBe(false);
+    expect(existsSync(legacyDir)).toBe(false);
+
+    // CLAUDE.md should not contain agent markers
+    const claudeAfter = readFileSync(claudeMdPath, 'utf-8');
+    expect(claudeAfter).not.toContain(`<!-- agent:${AGENT_ID}:mode -->`);
+    expect(claudeAfter).toContain('# Home Config');
+    expect(claudeAfter).toContain('# Other Stuff');
+
+    // Settings should not contain agent permissions but keep other entries
+    const settingsAfter = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    expect(settingsAfter.permissions.allow).toEqual(['mcp__other__something', 'Bash(*)']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+
+describe('edge cases', () => {
+  let tempDir: string;
+  let originalHome: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir('edge');
+    originalHome = process.env.HOME ?? '';
+    process.env.HOME = tempDir;
+    process.env.USERPROFILE = tempDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalHome) process.env.USERPROFILE = originalHome;
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('partial install: only project dir exists, no configs', () => {
+    const projectDir = join(tempDir, 'projects', 'partial-agent');
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(join(projectDir, 'agent.yaml'), 'name: partial\n');
+
+    const manifest = detectArtifacts('partial-agent', projectDir);
+    expect(manifest.projectDir!.exists).toBe(true);
+    expect(manifest.claudeMdBlocks).toEqual([]);
+    expect(manifest.mcpServerEntries).toEqual([]);
+    expect(manifest.permissionEntries).toEqual([]);
+  });
+
+  it('empty settings.local.json (valid JSON, no permissions key)', () => {
+    const claudeDir = join(tempDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(join(claudeDir, 'settings.local.json'), '{}');
+
+    const manifest = detectArtifacts('some-agent', join(tempDir, 'nope'));
+    expect(manifest.permissionEntries).toEqual([]);
+  });
+
+  it('malformed JSON in settings file does not throw', () => {
+    const claudeDir = join(tempDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(join(claudeDir, 'settings.local.json'), '{ broken json !!!');
+
+    expect(() => {
+      const manifest = detectArtifacts('some-agent', join(tempDir, 'nope'));
+      expect(manifest.permissionEntries).toEqual([]);
+    }).not.toThrow();
+  });
+});

package/src/commands/create.ts

@@ -1,4 +1,4 @@
-import { accessSync, constants as fsConstants, readFileSync, existsSync } from 'node:fs';
+import { accessSync, constants as fsConstants, mkdirSync, readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -185,7 +185,15 @@ export function registerCreate(program: Command): void {
 
             const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? process.cwd());
 
-            // Preflight: check output directory is writable
+            // Preflight: ensure output directory exists and is writable
+            if (!existsSync(outputDir)) {
+              try {
+                mkdirSync(outputDir, { recursive: true });
+              } catch {
+                p.log.error(`Cannot create ${outputDir} — check permissions`);
+                process.exit(1);
+              }
+            }
             try {
               accessSync(outputDir, fsConstants.W_OK);
             } catch {

package/src/commands/dev.ts

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { watch, writeFileSync } from 'node:fs';
+import { existsSync, watch, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -26,18 +26,29 @@ export function registerDev(program: Command): void {
     });
 }
 
-function runFileTreeDev(agentPath: string, agentId: string): void {
+async function runFileTreeDev(agentPath: string, agentId: string): Promise<void> {
   p.log.info(`Starting ${agentId} in file-tree dev mode...`);
   p.log.info('Starting Knowledge Engine + watching for file changes.');
   p.log.info('CLAUDE.md will be regenerated automatically on changes.');
   p.log.info('Press Ctrl+C to stop.\n');
 
-  regenerateClaudeMd(agentPath);
+  await regenerateClaudeMd(agentPath);
 
   // Start the engine server
   let engineBin: string;
   try {
-    engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+    const candidate = join(
+      agentPath,
+      'node_modules',
+      '@soleri',
+      'core',
+      'dist',
+      'engine',
+      'bin',
+      'soleri-engine.js',
+    );
+    if (!existsSync(candidate)) throw new Error('Engine not found at ' + candidate);
+    engineBin = candidate;
   } catch {
     p.log.error('Engine not found. Run: npm install @soleri/core');
     process.exit(1);
@@ -73,10 +84,10 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
 
         // Debounce — regenerate at most once per 200ms
         if (debounceTimer) clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
+        debounceTimer = setTimeout(async () => {
           const changedFile = filename ? ` (${filename})` : '';
           p.log.info(`Change detected${changedFile} — regenerating CLAUDE.md`);
-          regenerateClaudeMd(agentPath);
+          await regenerateClaudeMd(agentPath);
         }, 200);
       });
     } catch (err: unknown) {
@@ -105,11 +116,10 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
   });
 }
 
-function regenerateClaudeMd(agentPath: string): void {
+async function regenerateClaudeMd(agentPath: string): Promise<void> {
   try {
     // Dynamic import to avoid loading forge at CLI startup
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { composeClaudeMd } = require('@soleri/forge/lib');
+    const { composeClaudeMd } = await import('@soleri/forge/lib');
     const { content } = composeClaudeMd(agentPath);
     writeFileSync(join(agentPath, 'CLAUDE.md'), content, 'utf-8');
     p.log.success('CLAUDE.md regenerated');