@soleri/cli 9.7.2 → 9.8.0

package/src/__tests__/git-utils.test.ts

@@ -0,0 +1,268 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock node:child_process before importing the module under test
+vi.mock('node:child_process', () => ({
+  execFile: vi.fn(),
+}));
+
+import { execFile } from 'node:child_process';
+import {
+  isGitInstalled,
+  isGhInstalled,
+  gitInit,
+  gitInitialCommit,
+  gitAddRemote,
+  gitPush,
+  ghCreateRepo,
+} from '../utils/git.js';
+
+const mockExecFile = vi.mocked(execFile);
+
+/** Helper: make execFile call its callback with success (stdout). */
+function mockSuccess(stdout = '') {
+  mockExecFile.mockImplementation((_cmd, _args, _opts, callback) => {
+    (callback as Function)(null, stdout, '');
+    return undefined as any;
+  });
+}
+
+/** Helper: make execFile call its callback with an error. */
+function mockFailure(message: string, stderr = '') {
+  mockExecFile.mockImplementation((_cmd, _args, _opts, callback) => {
+    const err = new Error(message);
+    (callback as Function)(err, '', stderr);
+    return undefined as any;
+  });
+}
+
+/**
+ * Helper: make execFile succeed N times then fail.
+ * Useful for testing gitInitialCommit where `git add` must succeed before `git commit` fails.
+ */
+function mockSequence(calls: Array<{ stdout?: string; error?: string; stderr?: string }>) {
+  let callIndex = 0;
+  mockExecFile.mockImplementation((_cmd, _args, _opts, callback) => {
+    const spec = calls[callIndex] ?? calls[calls.length - 1];
+    callIndex++;
+    if (spec.error) {
+      const err = new Error(spec.error);
+      (callback as Function)(err, '', spec.stderr ?? spec.error);
+    } else {
+      (callback as Function)(null, spec.stdout ?? '', '');
+    }
+    return undefined as any;
+  });
+}
+
+describe('git utilities', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  // ── isGitInstalled ──────────────────────────────────────────────
+  describe('isGitInstalled', () => {
+    it('returns true when git binary is found', async () => {
+      mockSuccess('/usr/bin/git');
+      const result = await isGitInstalled();
+      expect(result).toBe(true);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'which',
+        ['git'],
+        expect.objectContaining({ signal: expect.any(AbortSignal) }),
+        expect.any(Function),
+      );
+    });
+
+    it('returns false when git binary is not found', async () => {
+      mockFailure('not found');
+      const result = await isGitInstalled();
+      expect(result).toBe(false);
+    });
+  });
+
+  // ── isGhInstalled ──────────────────────────────────────────────
+  describe('isGhInstalled', () => {
+    it('returns true when gh binary is found', async () => {
+      mockSuccess('/usr/bin/gh');
+      const result = await isGhInstalled();
+      expect(result).toBe(true);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'which',
+        ['gh'],
+        expect.objectContaining({ signal: expect.any(AbortSignal) }),
+        expect.any(Function),
+      );
+    });
+
+    it('returns false when gh binary is not found', async () => {
+      mockFailure('not found');
+      const result = await isGhInstalled();
+      expect(result).toBe(false);
+    });
+  });
+
+  // ── gitInit ─────────────────────────────────────────────────────
+  describe('gitInit', () => {
+    it('returns { ok: true } on success', async () => {
+      mockSuccess('Initialized empty Git repository');
+      const result = await gitInit('/tmp/my-project');
+      expect(result).toEqual({ ok: true });
+    });
+
+    it('returns { ok: false, error } on failure', async () => {
+      mockFailure('fatal: not a git repository', 'fatal: not a git repository');
+      const result = await gitInit('/tmp/my-project');
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('passes correct args with cwd', async () => {
+      mockSuccess();
+      await gitInit('/tmp/my-project');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'git',
+        ['init'],
+        expect.objectContaining({ cwd: '/tmp/my-project' }),
+        expect.any(Function),
+      );
+    });
+  });
+
+  // ── gitInitialCommit ────────────────────────────────────────────
+  describe('gitInitialCommit', () => {
+    it('returns { ok: true } when both add and commit succeed', async () => {
+      mockSequence([{ stdout: '' }, { stdout: '' }]);
+      const result = await gitInitialCommit('/tmp/proj', 'Initial commit');
+      expect(result).toEqual({ ok: true });
+      // Two calls: git add . and git commit -m ...
+      expect(mockExecFile).toHaveBeenCalledTimes(2);
+    });
+
+    it('returns { ok: false } when git add fails (does not attempt commit)', async () => {
+      mockSequence([{ error: 'add failed', stderr: 'add failed' }]);
+      const result = await gitInitialCommit('/tmp/proj', 'Initial commit');
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain('add failed');
+      // Only one call — git add; commit should not be attempted
+      expect(mockExecFile).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns { ok: false } when add succeeds but commit fails', async () => {
+      mockSequence([{ stdout: '' }, { error: 'nothing to commit', stderr: 'nothing to commit' }]);
+      const result = await gitInitialCommit('/tmp/proj', 'Initial commit');
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain('nothing to commit');
+      expect(mockExecFile).toHaveBeenCalledTimes(2);
+    });
+
+    it('passes the correct commit message', async () => {
+      mockSequence([{ stdout: '' }, { stdout: '' }]);
+      await gitInitialCommit('/tmp/proj', 'feat: initial scaffold');
+      // Second call should be git commit -m <message>
+      const commitCall = mockExecFile.mock.calls[1];
+      expect(commitCall[0]).toBe('git');
+      expect(commitCall[1]).toEqual(['commit', '-m', 'feat: initial scaffold']);
+    });
+  });
+
+  // ── gitAddRemote ────────────────────────────────────────────────
+  describe('gitAddRemote', () => {
+    it('returns { ok: true } on success', async () => {
+      mockSuccess();
+      const result = await gitAddRemote('/tmp/proj', 'https://github.com/user/repo.git');
+      expect(result).toEqual({ ok: true });
+    });
+
+    it('passes correct args', async () => {
+      mockSuccess();
+      await gitAddRemote('/tmp/proj', 'https://github.com/user/repo.git');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'git',
+        ['remote', 'add', 'origin', 'https://github.com/user/repo.git'],
+        expect.objectContaining({ cwd: '/tmp/proj' }),
+        expect.any(Function),
+      );
+    });
+
+    it('returns { ok: false } on failure', async () => {
+      mockFailure('remote origin already exists', 'remote origin already exists');
+      const result = await gitAddRemote('/tmp/proj', 'https://github.com/user/repo.git');
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  // ── gitPush ─────────────────────────────────────────────────────
+  describe('gitPush', () => {
+    it('returns { ok: true } on success', async () => {
+      mockSuccess();
+      const result = await gitPush('/tmp/proj');
+      expect(result).toEqual({ ok: true });
+    });
+
+    it('returns { ok: false } on network error', async () => {
+      mockFailure('Could not resolve host', 'Could not resolve host');
+      const result = await gitPush('/tmp/proj');
+      expect(result.ok).toBe(false);
+      expect(result.error).toContain('Could not resolve host');
+    });
+
+    it('uses NETWORK_TIMEOUT (60s) via AbortSignal', async () => {
+      mockSuccess();
+      await gitPush('/tmp/proj');
+      const callOpts = mockExecFile.mock.calls[0][2] as { signal: AbortSignal };
+      // AbortSignal.timeout(60000) — verify it is an AbortSignal (we can't read the timeout
+      // value directly, but we can verify it's present and is an AbortSignal)
+      expect(callOpts.signal).toBeInstanceOf(AbortSignal);
+    });
+  });
+
+  // ── ghCreateRepo ────────────────────────────────────────────────
+  describe('ghCreateRepo', () => {
+    it('returns { ok: true, url } on success', async () => {
+      mockSuccess('https://github.com/user/my-repo\n');
+      const result = await ghCreateRepo('my-repo', { visibility: 'public', dir: '/tmp/proj' });
+      expect(result.ok).toBe(true);
+      expect(result.url).toBe('https://github.com/user/my-repo');
+    });
+
+    it('returns { ok: false } on failure', async () => {
+      mockFailure('authentication required', 'authentication required');
+      const result = await ghCreateRepo('my-repo', { visibility: 'public', dir: '/tmp/proj' });
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('passes --public flag for public visibility', async () => {
+      mockSuccess('https://github.com/user/my-repo');
+      await ghCreateRepo('my-repo', { visibility: 'public', dir: '/tmp/proj' });
+      const args = mockExecFile.mock.calls[0][1] as string[];
+      expect(args).toContain('--public');
+      expect(args).not.toContain('--private');
+    });
+
+    it('passes --private flag for private visibility', async () => {
+      mockSuccess('https://github.com/user/my-repo');
+      await ghCreateRepo('my-repo', { visibility: 'private', dir: '/tmp/proj' });
+      const args = mockExecFile.mock.calls[0][1] as string[];
+      expect(args).toContain('--private');
+      expect(args).not.toContain('--public');
+    });
+
+    it('includes --source, --remote, and --push flags', async () => {
+      mockSuccess('https://github.com/user/my-repo');
+      await ghCreateRepo('my-repo', { visibility: 'public', dir: '/tmp/proj' });
+      const args = mockExecFile.mock.calls[0][1] as string[];
+      expect(args).toContain('--source=/tmp/proj');
+      expect(args).toContain('--remote=origin');
+      expect(args).toContain('--push');
+    });
+
+    it('returns undefined url when stdout is empty', async () => {
+      mockSuccess('');
+      const result = await ghCreateRepo('my-repo', { visibility: 'public', dir: '/tmp/proj' });
+      expect(result.ok).toBe(true);
+      expect(result.url).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/scaffold-git-e2e.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { scaffoldFileTree } from '@soleri/forge/lib';
+import { gitInit, gitInitialCommit } from '../utils/git.js';
+import type { AgentYamlInput } from '@soleri/forge/lib';
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+const MINIMAL_AGENT: AgentYamlInput = {
+  id: 'test-agent',
+  name: 'Test Agent',
+  role: 'Testing assistant',
+  description: 'A minimal agent used for scaffold + git E2E tests',
+};
+
+function gitCommand(dir: string, ...args: string[]): string {
+  return execFileSync('git', args, {
+    cwd: dir,
+    stdio: 'pipe',
+    encoding: 'utf-8',
+  }).trim();
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────
+
+describe('scaffold + git init (E2E)', () => {
+  const tempDirs: string[] = [];
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'soleri-git-e2e-'));
+    tempDirs.push(dir);
+    return dir;
+  }
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  it('scaffold with git init produces a valid git repo', async () => {
+    const outputDir = makeTempDir();
+    const result = scaffoldFileTree(MINIMAL_AGENT, outputDir);
+    expect(result.success).toBe(true);
+
+    const agentDir = result.agentDir;
+
+    // Initialize git and create initial commit
+    const initResult = await gitInit(agentDir);
+    expect(initResult.ok).toBe(true);
+
+    const commitResult = await gitInitialCommit(agentDir, 'feat: scaffold agent "test-agent"');
+    expect(commitResult.ok).toBe(true);
+
+    // .git directory exists
+    expect(existsSync(join(agentDir, '.git'))).toBe(true);
+
+    // Exactly 1 commit
+    const log = gitCommand(agentDir, 'log', '--oneline');
+    const commits = log.split('\n').filter(Boolean);
+    expect(commits).toHaveLength(1);
+
+    // Commit message contains expected text
+    expect(commits[0]).toContain('feat: scaffold agent');
+
+    // Working tree is clean — no untracked files
+    const status = gitCommand(agentDir, 'status', '--porcelain');
+    expect(status).toBe('');
+  });
+
+  it('.gitignore exclusions are respected', async () => {
+    const outputDir = makeTempDir();
+    const result = scaffoldFileTree(MINIMAL_AGENT, outputDir);
+    expect(result.success).toBe(true);
+
+    const agentDir = result.agentDir;
+
+    await gitInit(agentDir);
+    await gitInitialCommit(agentDir, 'feat: scaffold agent "test-agent"');
+
+    const trackedFiles = gitCommand(agentDir, 'ls-files');
+
+    // Auto-generated files must NOT be tracked
+    expect(trackedFiles).not.toContain('CLAUDE.md');
+    expect(trackedFiles).not.toContain('AGENTS.md');
+    expect(trackedFiles).not.toContain('instructions/_engine.md');
+
+    // Important source-of-truth files MUST be tracked
+    expect(trackedFiles).toContain('agent.yaml');
+    expect(trackedFiles).toContain('.gitignore');
+  });
+
+  it('scaffold without git does not create a .git directory', () => {
+    const outputDir = makeTempDir();
+    const result = scaffoldFileTree(MINIMAL_AGENT, outputDir);
+    expect(result.success).toBe(true);
+
+    // No git init called — .git must not exist
+    expect(existsSync(join(result.agentDir, '.git'))).toBe(false);
+  });
+});

package/src/commands/add-domain.ts

@@ -24,6 +24,7 @@ export function registerAddDomain(program: Command): void {
           agentPath: ctx.agentPath,
           domain,
           noBuild: !opts.build,
+          format: ctx.format,
         });
 
         s.stop(result.success ? result.summary : 'Failed');

package/src/commands/add-pack.ts

@@ -1,170 +1,17 @@
-// @ts-nocheck — TODO: rewrite for v7 file-tree agents (uses removed @soleri/core APIs)
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
-import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { detectAgent } from '../utils/agent-context.js';
 
 export function registerAddPack(program: Command): void {
   program
     .command('add-pack')
-    .argument('<package>', 'npm package name (e.g., "@soleri/domain-design")')
-    .option('--no-install', 'Skip npm install (assume already installed)')
-    .option('--no-inject', 'Skip forge inject (CLAUDE.md, entry-point regeneration)')
-    .option('--force', 'Overwrite existing skills')
-    .description('Add a domain pack to the agent in the current directory')
-    .action(
-      async (packageName: string, opts: { install: boolean; inject: boolean; force: 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();
-
-        // Step 1: npm install
-        if (opts.install) {
-          s.start(`Installing ${packageName}...`);
-          try {
-            execFileSync('npm', ['install', packageName], {
-              cwd: ctx.agentPath,
-              stdio: 'pipe',
-            });
-            s.stop(`Installed ${packageName}`);
-          } catch (err) {
-            s.stop('npm install failed');
-            p.log.error(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-          }
-        }
-
-        // Step 2: Validate it's a DomainPack
-        s.start('Validating domain pack...');
-        let pack;
-        try {
-          const { loadDomainPack } = await import('@soleri/core');
-          pack = await loadDomainPack(packageName);
-          s.stop(
-            `Validated: ${pack.name} v${pack.version} (${pack.ops.length} ops, ${pack.domains.length} domains${pack.facades?.length ? `, ${pack.facades.length} facades` : ''})`,
-          );
-        } catch (err) {
-          s.stop('Validation failed');
-          p.log.error(err instanceof Error ? err.message : String(err));
-          process.exit(1);
-        }
-
-        // Step 3: Update agent-config.json
-        s.start('Updating agent config...');
-        const configPath = join(ctx.agentPath, 'agent-config.json');
-        if (existsSync(configPath)) {
-          try {
-            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-            if (!config.domainPacks) config.domainPacks = [];
-
-            const existing = config.domainPacks.find(
-              (ref: { package: string }) => ref.package === packageName,
-            );
-            if (existing) {
-              existing.version = pack.version;
-              s.stop('Updated existing pack reference in config');
-            } else {
-              config.domainPacks.push({
-                name: pack.name,
-                package: packageName,
-                version: pack.version,
-              });
-              s.stop('Added pack reference to config');
-            }
-
-            writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-          } catch (err) {
-            s.stop('Config update failed');
-            p.log.error(err instanceof Error ? err.message : String(err));
-            process.exit(1);
-          }
-        } else {
-          s.stop('No agent-config.json found — skipped config update');
-        }
-
-        // Step 4: Install knowledge (tiered)
-        s.start('Installing knowledge...');
-        try {
-          const { installKnowledge, createAgentRuntime } = await import('@soleri/core');
-          const runtime = createAgentRuntime({
-            agentId: ctx.agentId,
-            vaultPath: join(ctx.agentPath, '.vault', 'vault.db'),
-          });
-          const resolvedDir = join(ctx.agentPath, 'node_modules', packageName);
-          const knowledgeResult = await installKnowledge(pack, runtime, resolvedDir);
-          runtime.close();
-          const total =
-            knowledgeResult.canonical + knowledgeResult.curated + knowledgeResult.captured;
-          s.stop(
-            total > 0
-              ? `Installed ${total} knowledge entries (${knowledgeResult.canonical} canonical, ${knowledgeResult.curated} curated, ${knowledgeResult.captured} captured)`
-              : 'No knowledge to install',
-          );
-        } catch (err) {
-          s.stop('Knowledge install skipped (non-fatal)');
-          p.log.warn(err instanceof Error ? err.message : String(err));
-        }
-
-        // Step 5: Install skills
-        s.start('Installing skills...');
-        try {
-          const { installSkills } = await import('@soleri/core');
-          const resolvedDir = join(ctx.agentPath, 'node_modules', packageName);
-          const skillsDir = join(ctx.agentPath, 'skills');
-          const skillsResult = installSkills(pack, skillsDir, resolvedDir, opts.force);
-          s.stop(
-            skillsResult.installed > 0
-              ? `Installed ${skillsResult.installed} skills (${skillsResult.skipped} skipped)`
-              : 'No skills to install',
-          );
-        } catch (err) {
-          s.stop('Skills install skipped (non-fatal)');
-          p.log.warn(err instanceof Error ? err.message : String(err));
-        }
-
-        // Step 6: Inject CLAUDE.md domain rules
-        if (pack.rules) {
-          s.start('Injecting CLAUDE.md domain rules...');
-          try {
-            const { injectDomainRules } = await import('@soleri/core');
-            const claudeMdPath = join(ctx.agentPath, 'CLAUDE.md');
-            injectDomainRules(claudeMdPath, pack.name, pack.rules);
-            s.stop('Injected domain rules into CLAUDE.md');
-          } catch (err) {
-            s.stop('CLAUDE.md injection skipped (non-fatal)');
-            p.log.warn(err instanceof Error ? err.message : String(err));
-          }
-        }
-
-        // Step 7: Run forge inject (regenerate entry-point, tests)
-        if (opts.inject) {
-          s.start('Regenerating agent code...');
-          try {
-            execFileSync('npx', ['soleri', 'agent', 'refresh'], {
-              cwd: ctx.agentPath,
-              stdio: 'pipe',
-            });
-            s.stop('Regenerated entry-point, tests, and CLAUDE.md');
-          } catch {
-            s.stop('Forge inject skipped — run `soleri agent refresh` manually');
-          }
-        }
-
-        // Summary
-        p.log.success(`\nDomain pack "${pack.name}" added to ${ctx.agentId}`);
-        p.log.info(`  Domains: ${pack.domains.join(', ')}`);
-        p.log.info(`  Ops: ${pack.ops.length} custom operations`);
-        if (pack.facades?.length) {
-          p.log.info(`  Facades: ${pack.facades.map((f) => f.name).join(', ')}`);
-        }
-      },
-    );
+    .argument('<pack>', 'Pack name')
+    .description('[DEPRECATED] Use "soleri pack install" or "soleri hooks add-pack" instead')
+    .action(async () => {
+      p.log.warn(
+        'The "add-pack" command is deprecated.\n\n' +
+          'Use these commands instead:\n' +
+          '  • soleri pack install <pack>    — install knowledge/domain packs\n' +
+          '  • soleri hooks add-pack <pack>  — install hook packs\n',
+      );
+    });
 }