@soleri/cli 9.7.1 → 9.8.0

package/src/__tests__/create-wizard-git.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/**
+ * Mock @clack/prompts — every prompt function the wizard uses.
+ */
+vi.mock('@clack/prompts', () => ({
+  confirm: vi.fn(),
+  select: vi.fn(),
+  text: vi.fn(),
+  intro: vi.fn(),
+  note: vi.fn(),
+  isCancel: vi.fn().mockReturnValue(false),
+}));
+
+/**
+ * Mock the git utility so we control gh availability.
+ */
+vi.mock('../utils/git.js', () => ({
+  isGhInstalled: vi.fn().mockReturnValue(true),
+}));
+
+import * as p from '@clack/prompts';
+import { isGhInstalled } from '../utils/git.js';
+import { runCreateWizard } from '../prompts/create-wizard.js';
+import type { CreateWizardResult, WizardGitConfig } from '../prompts/create-wizard.js';
+
+const mockText = p.text as unknown as ReturnType<typeof vi.fn>;
+const mockSelect = p.select as unknown as ReturnType<typeof vi.fn>;
+const mockConfirm = p.confirm as unknown as ReturnType<typeof vi.fn>;
+const mockIsCancel = p.isCancel as unknown as ReturnType<typeof vi.fn>;
+const mockGhInstalled = isGhInstalled as unknown as ReturnType<typeof vi.fn>;
+
+/**
+ * Helper: set up the standard wizard prompts that precede git questions.
+ * Returns after the "Create this agent?" confirm (step 4).
+ *
+ * Call order:
+ *   1. text — agent name
+ *   2. select — persona choice
+ *   3. note — summary (no return value needed)
+ *   4. confirm — create confirmation
+ */
+function mockBaseWizard() {
+  mockText.mockResolvedValueOnce('TestAgent'); // name
+  mockSelect.mockResolvedValueOnce('default'); // persona
+  mockConfirm.mockResolvedValueOnce(true); // create confirm
+}
+
+describe('create-wizard git prompts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIsCancel.mockReturnValue(false);
+    mockGhInstalled.mockReturnValue(true);
+  });
+
+  // ── 1. Git init defaults to true ──────────────────────────────
+  it('should default git init to true when user accepts all defaults', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init = yes
+    mockConfirm.mockResolvedValueOnce(false); // push to remote = no
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.init).toBe(true);
+    expect(result.git.remote).toBeUndefined();
+  });
+
+  // ── 2. Git init can be declined ───────────────────────────────
+  it('should set git.init to false when user declines', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(false); // git init = no
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.init).toBe(false);
+    expect(result.git.remote).toBeUndefined();
+    // No push prompt should have been called — only 2 confirms total
+    // (create + git init)
+    expect(mockConfirm).toHaveBeenCalledTimes(2);
+  });
+
+  // ── 3. Remote prompts only when init=true, no push ────────────
+  it('should leave remote undefined when init=true but push=false', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(false); // push to remote = no
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.init).toBe(true);
+    expect(result.git.remote).toBeUndefined();
+  });
+
+  // ── 4. gh path: GitHub repo creation ──────────────────────────
+  it('should configure gh remote when user selects gh path', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(true); // push to remote
+    mockSelect.mockResolvedValueOnce('gh'); // remote choice
+    mockSelect.mockResolvedValueOnce('public'); // visibility
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.remote).toEqual({
+      type: 'gh',
+      visibility: 'public',
+    });
+  });
+
+  // ── 5. gh path: private by default ────────────────────────────
+  it('should default visibility to private when selecting gh', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(true); // push to remote
+    mockSelect.mockResolvedValueOnce('gh'); // remote choice
+    mockSelect.mockResolvedValueOnce('private'); // visibility = private
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.remote!.type).toBe('gh');
+    expect(result.git.remote!.visibility).toBe('private');
+  });
+
+  // ── 6. Manual path: URL input ─────────────────────────────────
+  it('should configure manual remote with URL when user selects manual', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(true); // push to remote
+    mockSelect.mockResolvedValueOnce('manual'); // remote choice
+    mockText.mockResolvedValueOnce('https://github.com/test/repo.git'); // URL
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.remote).toEqual({
+      type: 'manual',
+      url: 'https://github.com/test/repo.git',
+    });
+  });
+
+  // ── 7. Manual path forced when gh not available ───────────────
+  it('should skip gh/manual select and go straight to URL when gh is not installed', async () => {
+    mockGhInstalled.mockReturnValue(false);
+
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(true); // push to remote
+    // No select for gh/manual — goes straight to text for URL
+    mockText.mockResolvedValueOnce('https://gitlab.com/test/repo.git');
+
+    const result = (await runCreateWizard()) as CreateWizardResult;
+
+    expect(result).not.toBeNull();
+    expect(result.git.remote).toEqual({
+      type: 'manual',
+      url: 'https://gitlab.com/test/repo.git',
+    });
+    // select should only be called once (persona), not twice
+    expect(mockSelect).toHaveBeenCalledTimes(1);
+  });
+
+  // ── 8. Cancellation at git init prompt ────────────────────────
+  it('should return null when user cancels at git init prompt', async () => {
+    mockBaseWizard();
+    // The third confirm call (git init) returns a cancel symbol
+    const cancelSymbol = Symbol('cancel');
+    mockConfirm.mockResolvedValueOnce(cancelSymbol);
+    mockIsCancel.mockImplementation((val) => val === cancelSymbol);
+
+    const result = await runCreateWizard();
+
+    expect(result).toBeNull();
+  });
+
+  // ── 9. Cancellation at push prompt ────────────────────────────
+  it('should return null when user cancels at push prompt', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init = yes
+
+    const cancelSymbol = Symbol('cancel');
+    mockConfirm.mockResolvedValueOnce(cancelSymbol); // push = cancel
+    mockIsCancel.mockImplementation((val) => val === cancelSymbol);
+
+    const result = await runCreateWizard();
+
+    expect(result).toBeNull();
+  });
+
+  // ── 10. Cancellation at remote choice ─────────────────────────
+  it('should return null when user cancels at remote choice prompt', async () => {
+    mockBaseWizard();
+    mockConfirm.mockResolvedValueOnce(true); // git init
+    mockConfirm.mockResolvedValueOnce(true); // push to remote
+
+    const cancelSymbol = Symbol('cancel');
+    mockSelect.mockResolvedValueOnce(cancelSymbol); // remote choice = cancel
+    mockIsCancel.mockImplementation((val) => val === cancelSymbol);
+
+    const result = await runCreateWizard();
+
+    expect(result).toBeNull();
+  });
+});

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__/hook-packs.test.ts

@@ -176,7 +176,11 @@ describe('hook-packs', () => {
       const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
       expect(settings.hooks).toBeDefined();
       expect(settings.hooks.PreToolUse).toHaveLength(1);
-      expect(settings.hooks.PreToolUse[0].command).toBe('sh ~/.claude/hooks/anti-deletion.sh');
+      expect(settings.hooks.PreToolUse[0].matcher).toBe('Bash');
+      expect(settings.hooks.PreToolUse[0].hooks).toHaveLength(1);
+      expect(settings.hooks.PreToolUse[0].hooks[0].command).toBe(
+        'sh ~/.claude/hooks/anti-deletion.sh',
+      );
       expect(settings.hooks.PreToolUse[0]._soleriPack).toBe('safety');
     });
 

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');