javi-forge 0.1.0

package/src/commands/doctor.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ── Mock fs-extra ────────────────────────────────────────────────────────────
+vi.mock('fs-extra', () => {
+  const mockFs = {
+    pathExists: vi.fn(),
+    readFile: vi.fn(),
+    readJson: vi.fn(),
+    readdir: vi.fn(),
+    copy: vi.fn(),
+    ensureDir: vi.fn(),
+  }
+  return { default: mockFs, ...mockFs }
+})
+
+// ── Mock child_process ───────────────────────────────────────────────────────
+vi.mock('child_process', () => ({
+  execFile: vi.fn((_cmd: string, _args: string[], cb: unknown) => {
+    if (typeof cb === 'function') cb(null, { stdout: '', stderr: '' })
+    return undefined as any
+  }),
+}))
+
+// ── Mock common module ───────────────────────────────────────────────────────
+vi.mock('../lib/common.js', () => ({
+  detectStack: vi.fn(),
+  backupIfExists: vi.fn().mockResolvedValue(false),
+  ensureDirExists: vi.fn().mockResolvedValue(undefined),
+  STACK_LABELS: {
+    'node': 'Node.js / TypeScript',
+    'python': 'Python',
+    'go': 'Go',
+    'rust': 'Rust',
+    'java-gradle': 'Java (Gradle)',
+    'java-maven': 'Java (Maven)',
+    'elixir': 'Elixir',
+  },
+}))
+
+import fs from 'fs-extra'
+import { execFile } from 'child_process'
+import { runDoctor } from './doctor.js'
+import { detectStack } from '../lib/common.js'
+
+const mockedFs = vi.mocked(fs)
+const mockedExecFile = vi.mocked(execFile)
+const mockedDetectStack = vi.mocked(detectStack)
+
+beforeEach(() => {
+  vi.resetAllMocks()
+
+  // Default: all paths exist, readdir returns items
+  mockedFs.pathExists.mockResolvedValue(true as never)
+  mockedFs.readdir.mockResolvedValue(['file1', 'file2', '.hidden'] as never)
+
+  // Default: which + version succeed
+  mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, cb: unknown) => {
+    const cmd = String(_cmd)
+    if (cmd === 'which') {
+      if (typeof cb === 'function') cb(null, { stdout: '/usr/bin/tool', stderr: '' })
+    } else {
+      if (typeof cb === 'function') cb(null, { stdout: 'v1.0.0', stderr: '' })
+    }
+    return undefined as any
+  })
+
+  // Default: no stack detected
+  mockedDetectStack.mockResolvedValue(null)
+})
+
+describe('runDoctor', () => {
+  it('reports all tools as ok when present', async () => {
+    const result = await runDoctor('/test/project')
+    const toolSection = result.sections.find(s => s.title === 'System Tools')
+    expect(toolSection).toBeDefined()
+    const allOk = toolSection!.checks.every(c => c.status === 'ok')
+    expect(allOk).toBe(true)
+  })
+
+  it('reports fail for missing required tool', async () => {
+    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, cb: unknown) => {
+      const cmd = String(_cmd)
+      const args = _args as string[]
+      if (cmd === 'which' && args?.[0] === 'git') {
+        if (typeof cb === 'function') cb(new Error('not found'), { stdout: '', stderr: '' })
+      } else if (cmd === 'which') {
+        if (typeof cb === 'function') cb(null, { stdout: '/usr/bin/tool', stderr: '' })
+      } else {
+        if (typeof cb === 'function') cb(null, { stdout: 'v1.0.0', stderr: '' })
+      }
+      return undefined as any
+    })
+
+    const result = await runDoctor('/test/project')
+    const toolSection = result.sections.find(s => s.title === 'System Tools')!
+    const gitCheck = toolSection.checks.find(c => c.label === 'Git')
+    expect(gitCheck!.status).toBe('fail')
+  })
+
+  it('reports skip for missing optional tool (docker)', async () => {
+    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, cb: unknown) => {
+      const cmd = String(_cmd)
+      const args = _args as string[]
+      if (cmd === 'which' && args?.[0] === 'docker') {
+        if (typeof cb === 'function') cb(new Error('not found'), { stdout: '', stderr: '' })
+      } else if (cmd === 'which') {
+        if (typeof cb === 'function') cb(null, { stdout: '/usr/bin/tool', stderr: '' })
+      } else {
+        if (typeof cb === 'function') cb(null, { stdout: 'v1.0.0', stderr: '' })
+      }
+      return undefined as any
+    })
+
+    const result = await runDoctor('/test/project')
+    const toolSection = result.sections.find(s => s.title === 'System Tools')!
+    const dockerCheck = toolSection.checks.find(c => c.label === 'Docker')
+    expect(dockerCheck!.status).toBe('skip')
+  })
+
+  it('shows skip when no manifest found', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.includes('manifest.json')) return false as never
+      return true as never
+    })
+
+    const result = await runDoctor('/test/project')
+    const manifestSection = result.sections.find(s => s.title === 'Project Manifest')!
+    const manifestCheck = manifestSection.checks.find(c => c.label === 'Forge manifest')
+    expect(manifestCheck!.status).toBe('skip')
+    expect(manifestCheck!.detail).toContain('not a forge-managed project')
+  })
+
+  it('shows manifest details when found', async () => {
+    mockedFs.readJson.mockResolvedValue({
+      version: '0.1.0',
+      projectName: 'test-project',
+      stack: 'node',
+      ciProvider: 'github',
+      memory: 'engram',
+      createdAt: '2025-01-15T10:00:00Z',
+      updatedAt: '2025-01-15T10:00:00Z',
+      modules: ['engram', 'ghagga'],
+    } as never)
+
+    const result = await runDoctor('/test/project')
+    const manifestSection = result.sections.find(s => s.title === 'Project Manifest')!
+    const manifestCheck = manifestSection.checks.find(c => c.label === 'Forge manifest')
+    expect(manifestCheck!.status).toBe('ok')
+    expect(manifestCheck!.detail).toContain('test-project')
+
+    const modulesCheck = manifestSection.checks.find(c => c.label === 'Modules')
+    expect(modulesCheck!.status).toBe('ok')
+    expect(modulesCheck!.detail).toContain('engram')
+  })
+
+  it('reports ok for existing framework dirs', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    mockedFs.readdir.mockResolvedValue(['a', 'b', '.dotfile'] as never)
+
+    const result = await runDoctor('/test/project')
+    const structSection = result.sections.find(s => s.title === 'Framework Structure')!
+    expect(structSection.checks.every(c => c.status === 'ok')).toBe(true)
+    // countDir should filter dotfiles → "2 entries"
+    expect(structSection.checks[0].detail).toBe('2 entries')
+  })
+
+  it('reports fail for missing framework dirs', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.includes('templates')) return false as never
+      if (s.includes('manifest.json')) return false as never
+      // Modules directory for installed modules
+      if (s.includes('.javi-forge')) return false as never
+      return true as never
+    })
+    mockedFs.readdir.mockResolvedValue(['a'] as never)
+
+    const result = await runDoctor('/test/project')
+    const structSection = result.sections.find(s => s.title === 'Framework Structure')!
+    const templatesCheck = structSection.checks.find(c => c.label === 'templates/')
+    expect(templatesCheck!.status).toBe('fail')
+  })
+
+  it('shows stack when detected', async () => {
+    mockedDetectStack.mockResolvedValue({
+      stackType: 'node',
+      buildTool: 'pnpm',
+    })
+
+    const result = await runDoctor('/test/project')
+    const stackSection = result.sections.find(s => s.title === 'Stack Detection')!
+    const stackCheck = stackSection.checks[0]
+    expect(stackCheck.status).toBe('ok')
+    expect(stackCheck.detail).toContain('node')
+    expect(stackCheck.detail).toContain('pnpm')
+  })
+
+  it('countDir filters dotfiles', async () => {
+    mockedFs.readdir.mockResolvedValue(['.hidden', 'file1', '.git', 'file2'] as never)
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    const result = await runDoctor('/test/project')
+    const structSection = result.sections.find(s => s.title === 'Framework Structure')!
+    // Filtered: file1, file2 → 2 entries
+    expect(structSection.checks[0].detail).toBe('2 entries')
+  })
+})

package/src/commands/doctor.ts

@@ -0,0 +1,163 @@
+import fs from 'fs-extra'
+import path from 'path'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import { detectStack } from '../lib/common.js'
+import { FORGE_ROOT, TEMPLATES_DIR, MODULES_DIR, AI_CONFIG_DIR } from '../constants.js'
+import type { DoctorResult, DoctorSection, DoctorCheck, ForgeManifest } from '../types/index.js'
+
+const execFileAsync = promisify(execFile)
+
+export type CheckStatus = 'ok' | 'fail' | 'skip'
+
+/** Resolve a binary name to its full path, returns null if not found */
+async function which(bin: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync('which', [bin])
+    return stdout.trim() || null
+  } catch {
+    return null
+  }
+}
+
+/** Read the forge manifest from a project directory */
+async function readManifest(projectDir: string): Promise<ForgeManifest | null> {
+  const manifestPath = path.join(projectDir, '.javi-forge', 'manifest.json')
+  if (!await fs.pathExists(manifestPath)) return null
+  try {
+    return await fs.readJson(manifestPath) as ForgeManifest
+  } catch {
+    return null
+  }
+}
+
+/** Count entries in a directory */
+async function countDir(dir: string): Promise<number> {
+  if (!await fs.pathExists(dir)) return 0
+  const entries = await fs.readdir(dir)
+  return entries.filter(e => !e.startsWith('.')).length
+}
+
+/**
+ * Run comprehensive health checks for the project and framework.
+ */
+export async function runDoctor(projectDir?: string): Promise<DoctorResult> {
+  const cwd = projectDir ?? process.cwd()
+  const sections: DoctorSection[] = []
+
+  // ── 1. System Tools ────────────────────────────────────────────────────────
+  const toolChecks: DoctorCheck[] = []
+  const tools = [
+    { name: 'git', label: 'Git' },
+    { name: 'docker', label: 'Docker' },
+    { name: 'semgrep', label: 'Semgrep' },
+    { name: 'node', label: 'Node.js' },
+    { name: 'pnpm', label: 'pnpm' },
+  ]
+
+  for (const tool of tools) {
+    const bin = await which(tool.name)
+    if (bin) {
+      // Try to get version
+      let version = ''
+      try {
+        const { stdout } = await execFileAsync(tool.name, ['--version'])
+        version = stdout.trim().split('\n')[0] ?? ''
+      } catch { /* ignore */ }
+      toolChecks.push({
+        label: tool.label,
+        status: 'ok',
+        detail: version ? `${version}` : `found at ${bin}`,
+      })
+    } else {
+      toolChecks.push({
+        label: tool.label,
+        status: tool.name === 'docker' || tool.name === 'semgrep' ? 'skip' : 'fail',
+        detail: 'not found in PATH',
+      })
+    }
+  }
+  sections.push({ title: 'System Tools', checks: toolChecks })
+
+  // ── 2. Framework Structure ─────────────────────────────────────────────────
+  const structureChecks: DoctorCheck[] = []
+  const expectedDirs = [
+    { path: TEMPLATES_DIR, label: 'templates/' },
+    { path: MODULES_DIR, label: 'modules/' },
+    { path: AI_CONFIG_DIR, label: 'ai-config/' },
+    { path: path.join(FORGE_ROOT, 'workflows'), label: 'workflows/' },
+    { path: path.join(FORGE_ROOT, 'schemas'), label: 'schemas/' },
+    { path: path.join(FORGE_ROOT, 'ci-local'), label: 'ci-local/' },
+  ]
+
+  for (const dir of expectedDirs) {
+    if (await fs.pathExists(dir.path)) {
+      const count = await countDir(dir.path)
+      structureChecks.push({ label: dir.label, status: 'ok', detail: `${count} entries` })
+    } else {
+      structureChecks.push({ label: dir.label, status: 'fail', detail: 'missing' })
+    }
+  }
+  sections.push({ title: 'Framework Structure', checks: structureChecks })
+
+  // ── 3. Stack Detection ─────────────────────────────────────────────────────
+  const stackChecks: DoctorCheck[] = []
+  const detection = await detectStack(cwd)
+  if (detection) {
+    stackChecks.push({
+      label: 'Detected stack',
+      status: 'ok',
+      detail: `${detection.stackType} (${detection.buildTool})${detection.javaVersion ? ` Java ${detection.javaVersion}` : ''}`,
+    })
+  } else {
+    stackChecks.push({
+      label: 'Detected stack',
+      status: 'skip',
+      detail: 'no recognizable project files in current directory',
+    })
+  }
+  sections.push({ title: 'Stack Detection', checks: stackChecks })
+
+  // ── 4. Project Manifest ────────────────────────────────────────────────────
+  const manifestChecks: DoctorCheck[] = []
+  const manifest = await readManifest(cwd)
+  if (manifest) {
+    manifestChecks.push({
+      label: 'Forge manifest',
+      status: 'ok',
+      detail: `project: ${manifest.projectName}, stack: ${manifest.stack}`,
+    })
+    manifestChecks.push({
+      label: 'Created',
+      status: 'ok',
+      detail: manifest.createdAt.split('T')[0],
+    })
+    manifestChecks.push({
+      label: 'Modules',
+      status: manifest.modules.length > 0 ? 'ok' : 'skip',
+      detail: manifest.modules.length > 0 ? manifest.modules.join(', ') : 'none installed',
+    })
+  } else {
+    manifestChecks.push({
+      label: 'Forge manifest',
+      status: 'skip',
+      detail: 'not a forge-managed project (run javi-forge init)',
+    })
+  }
+  sections.push({ title: 'Project Manifest', checks: manifestChecks })
+
+  // ── 5. Installed Modules ───────────────────────────────────────────────────
+  const moduleChecks: DoctorCheck[] = []
+  const moduleNames = ['engram', 'obsidian-brain', 'memory-simple', 'ghagga']
+  for (const mod of moduleNames) {
+    const modPath = path.join(cwd, '.javi-forge', 'modules', mod)
+    if (await fs.pathExists(modPath)) {
+      moduleChecks.push({ label: mod, status: 'ok', detail: 'installed' })
+    } else {
+      moduleChecks.push({ label: mod, status: 'skip', detail: 'not installed' })
+    }
+  }
+  sections.push({ title: 'Installed Modules', checks: moduleChecks })
+
+  return { sections }
+}

package/src/commands/init.test.ts

@@ -0,0 +1,298 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { InitOptions, InitStep } from '../types/index.js'
+
+// ── Mock fs-extra ────────────────────────────────────────────────────────────
+vi.mock('fs-extra', () => {
+  const mockFs = {
+    pathExists: vi.fn(),
+    readFile: vi.fn(),
+    readJson: vi.fn(),
+    writeFile: vi.fn(),
+    writeJson: vi.fn(),
+    copy: vi.fn(),
+    ensureDir: vi.fn(),
+  }
+  return { default: mockFs, ...mockFs }
+})
+
+// ── Mock child_process ───────────────────────────────────────────────────────
+vi.mock('child_process', () => ({
+  execFile: vi.fn((_cmd: string, _args: string[], _opts: unknown, cb: Function) => {
+    cb(null, { stdout: '', stderr: '' })
+  }),
+}))
+
+// ── Mock template module ─────────────────────────────────────────────────────
+vi.mock('../lib/template.js', () => ({
+  generateDependabotYml: vi.fn().mockResolvedValue('dependabot-content'),
+  generateCIWorkflow: vi.fn().mockResolvedValue('ci-workflow-content'),
+  getCIDestination: vi.fn().mockReturnValue('.github/workflows/ci.yml'),
+}))
+
+// ── Mock common module ───────────────────────────────────────────────────────
+vi.mock('../lib/common.js', () => ({
+  backupIfExists: vi.fn().mockResolvedValue(false),
+  ensureDirExists: vi.fn().mockResolvedValue(undefined),
+}))
+
+import fs from 'fs-extra'
+import { execFile } from 'child_process'
+import { initProject } from './init.js'
+import { generateCIWorkflow, getCIDestination } from '../lib/template.js'
+
+const mockedFs = vi.mocked(fs)
+const mockedExecFile = vi.mocked(execFile)
+const mockedGenerateCIWorkflow = vi.mocked(generateCIWorkflow)
+const mockedGetCIDestination = vi.mocked(getCIDestination)
+
+beforeEach(() => {
+  vi.resetAllMocks()
+
+  // Default: most things exist
+  mockedFs.pathExists.mockResolvedValue(true as never)
+  mockedFs.writeFile.mockResolvedValue(undefined as never)
+  mockedFs.writeJson.mockResolvedValue(undefined as never)
+  mockedFs.copy.mockResolvedValue(undefined as never)
+  mockedFs.ensureDir.mockResolvedValue(undefined as never)
+
+  // Default: execFile succeeds (promisified version)
+  mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
+    if (typeof cb === 'function') cb(null, { stdout: '', stderr: '' })
+    return undefined as any
+  })
+
+  // Default: CI workflow available
+  mockedGenerateCIWorkflow.mockResolvedValue('ci-workflow-content')
+  mockedGetCIDestination.mockReturnValue('.github/workflows/ci.yml')
+})
+
+function makeOptions(overrides: Partial<InitOptions> = {}): InitOptions {
+  return {
+    projectName: 'test-project',
+    projectDir: '/test/project',
+    stack: 'node',
+    ciProvider: 'github',
+    memory: 'engram',
+    aiSync: true,
+    sdd: true,
+    ghagga: true,
+    dryRun: false,
+    ...overrides,
+  }
+}
+
+function collectSteps(options: InitOptions): Promise<InitStep[]> {
+  const steps: InitStep[] = []
+  return initProject(options, (step) => steps.push(step)).then(() => steps)
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// initProject
+// ═══════════════════════════════════════════════════════════════════════════════
+describe('initProject', () => {
+  it('completes full happy path — all steps report done', async () => {
+    // .git doesn't exist yet so it initializes
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions())
+    const doneSteps = steps.filter(s => s.status === 'done')
+    // Should have multiple 'done' status steps
+    expect(doneSteps.length).toBeGreaterThanOrEqual(8)
+  })
+
+  it('dry-run: no filesystem writes are made', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions({ dryRun: true }))
+    // In dry-run, fs.writeFile and fs.writeJson should not be called
+    expect(mockedFs.writeFile).not.toHaveBeenCalled()
+    expect(mockedFs.writeJson).not.toHaveBeenCalled()
+  })
+
+  it('continues other steps when one step errors', async () => {
+    // Make CI generation throw
+    mockedGenerateCIWorkflow.mockRejectedValue(new Error('CI template error'))
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions())
+    // Should have both error and done steps
+    const errorSteps = steps.filter(s => s.status === 'error')
+    const doneSteps = steps.filter(s => s.status === 'done')
+    expect(errorSteps.length).toBeGreaterThanOrEqual(1)
+    expect(doneSteps.length).toBeGreaterThanOrEqual(5)
+  })
+
+  it('skips memory when memory is none', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions({ memory: 'none' }))
+    const memStep = steps.find(s => s.id === 'memory' && s.status === 'skipped')
+    expect(memStep).toBeDefined()
+  })
+
+  it('skips ghagga when ghagga is false', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions({ ghagga: false }))
+    const ghStep = steps.find(s => s.id === 'ghagga' && s.status === 'skipped')
+    expect(ghStep).toBeDefined()
+  })
+
+  it('skips SDD when sdd is false', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions({ sdd: false }))
+    const sddStep = steps.find(s => s.id === 'sdd' && s.status === 'skipped')
+    expect(sddStep).toBeDefined()
+  })
+
+  it('skips AI sync when aiSync is false', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions({ aiSync: false }))
+    const aiStep = steps.find(s => s.id === 'ai-sync' && s.status === 'skipped')
+    expect(aiStep).toBeDefined()
+  })
+
+  it('reports already exists when .git directory is present', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions())
+    const gitStep = steps.find(s => s.id === 'git-init' && s.status === 'done' && s.detail === 'already exists')
+    expect(gitStep).toBeDefined()
+  })
+
+  it('skips CI step when no template found', async () => {
+    mockedGenerateCIWorkflow.mockResolvedValue(null)
+    mockedFs.pathExists.mockResolvedValue(true as never)
+
+    const steps = await collectSteps(makeOptions())
+    const ciStep = steps.find(s => s.id === 'ci-template' && s.status === 'skipped')
+    expect(ciStep).toBeDefined()
+  })
+
+  it('writes manifest with correct structure', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    await collectSteps(makeOptions({
+      projectName: 'test-manifest',
+      stack: 'node',
+      ciProvider: 'github',
+      memory: 'engram',
+      ghagga: true,
+      sdd: true,
+      aiSync: true,
+    }))
+
+    expect(mockedFs.writeJson).toHaveBeenCalled()
+    const [manifestPath, manifestData] = mockedFs.writeJson.mock.calls[0]
+    expect(String(manifestPath)).toContain('manifest.json')
+    expect(manifestData).toMatchObject({
+      version: '0.1.0',
+      projectName: 'test-manifest',
+      stack: 'node',
+      ciProvider: 'github',
+      memory: 'engram',
+    })
+    expect((manifestData as any).modules).toContain('engram')
+    expect((manifestData as any).modules).toContain('ghagga')
+    expect((manifestData as any).modules).toContain('sdd')
+    expect((manifestData as any).modules).toContain('ai-config')
+  })
+
+  it('reports error with helpful message when javi-ai not found', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return true as never
+      return true as never
+    })
+
+    // Make javi-ai sync fail with ENOENT
+    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
+      const cmdStr = String(_cmd)
+      const argsArr = _args as string[]
+      if (cmdStr === 'npx' && argsArr?.includes('javi-ai')) {
+        if (typeof cb === 'function') cb(new Error('ENOENT: command not found'), { stdout: '', stderr: '' })
+      } else {
+        if (typeof cb === 'function') cb(null, { stdout: '', stderr: '' })
+      }
+      return undefined as any
+    })
+
+    const steps = await collectSteps(makeOptions({ aiSync: true }))
+    const aiStep = steps.find(s => s.id === 'ai-sync' && s.status === 'error')
+    expect(aiStep).toBeDefined()
+    expect(aiStep!.detail).toContain('javi-ai not found')
+  })
+
+  it('reports steps in order via callback', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions())
+    const stepIds = steps.map(s => s.id)
+
+    // First step should be git-init
+    expect(stepIds[0]).toBe('git-init')
+
+    // Manifest should be among the last
+    const manifestIdx = stepIds.lastIndexOf('manifest')
+    expect(manifestIdx).toBeGreaterThan(stepIds.indexOf('git-init'))
+  })
+
+  it('skips dependabot for non-github providers', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions({ ciProvider: 'gitlab' }))
+    const depStep = steps.find(s => s.id === 'dependabot' && s.status === 'skipped')
+    expect(depStep).toBeDefined()
+  })
+
+  it('skips gitignore when .gitignore already exists', async () => {
+    mockedFs.pathExists.mockResolvedValue(true as never)
+    const steps = await collectSteps(makeOptions())
+    const giStep = steps.find(s => s.id === 'gitignore' && s.detail === 'already exists')
+    expect(giStep).toBeDefined()
+  })
+
+  it('skips hooks when ci-local dir is missing', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      if (s.includes('ci-local')) return false as never
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions())
+    const hookStep = steps.find(s => s.id === 'git-hooks' && s.status === 'skipped')
+    expect(hookStep).toBeDefined()
+  })
+
+  it('reports error when memory module not found', async () => {
+    mockedFs.pathExists.mockImplementation(async (p: unknown) => {
+      const s = String(p)
+      // Module source directory doesn't exist
+      if (s.includes('modules/engram') && !s.includes('.javi-forge')) return false as never
+      if (s.endsWith('.git')) return false as never
+      return true as never
+    })
+
+    const steps = await collectSteps(makeOptions({ memory: 'engram' }))
+    const memStep = steps.find(s => s.id === 'memory' && s.status === 'error')
+    expect(memStep).toBeDefined()
+    expect(memStep!.detail).toContain('module not found')
+  })
+})