javi-forge 0.1.0 → 1.0.0

package/src/commands/analyze.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import type { InitStep } from '../types/index.js'
-
-// ── Mock child_process ───────────────────────────────────────────────────────
-vi.mock('child_process', () => ({
-  execFile: vi.fn((_cmd: string, _args: string[], _opts: unknown, cb: unknown) => {
-    if (typeof cb === 'function') cb(null, { stdout: '', stderr: '' })
-    return undefined as any
-  }),
-}))
-
-import { execFile } from 'child_process'
-import { runAnalyze } from './analyze.js'
-
-const mockedExecFile = vi.mocked(execFile)
-
-beforeEach(() => {
-  vi.resetAllMocks()
-})
-
-function collectSteps(projectDir: string, dryRun: boolean): Promise<InitStep[]> {
-  const steps: InitStep[] = []
-  return runAnalyze(projectDir, dryRun, (step) => steps.push(step)).then(() => steps)
-}
-
-describe('runAnalyze', () => {
-  it('reports error when repoforge not found', async () => {
-    // which fails → repoforge not found
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      // The 'which' call is execFile('which', ['repoforge']) with 2 args (no opts)
-      // promisify(execFile) passes (cmd, args) → node adds callback
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(new Error('not found'))
-      }
-      return undefined as any
-    })
-
-    const steps = await collectSteps('/project', false)
-    const errorStep = steps.find(s => s.status === 'error')
-    expect(errorStep).toBeDefined()
-    expect(errorStep!.detail).toContain('repoforge not found')
-    expect(errorStep!.detail).toContain('pip install repoforge')
-  })
-
-  it('reports done when repoforge succeeds', async () => {
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '/usr/bin/repoforge', stderr: '' })
-      } else if (cmd === 'repoforge') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: 'Analysis complete\nGenerated 5 skills', stderr: '' })
-      }
-      return undefined as any
-    })
-
-    const steps = await collectSteps('/project', false)
-    const doneStep = steps.find(s => s.id === 'analyze-repoforge' && s.status === 'done')
-    expect(doneStep).toBeDefined()
-    expect(doneStep!.detail).toContain('Generated 5 skills')
-  })
-
-  it('passes --dry-run when dryRun is true', async () => {
-    let capturedArgs: string[] = []
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '/usr/bin/repoforge', stderr: '' })
-      } else if (cmd === 'repoforge') {
-        capturedArgs = (_args as string[]) ?? []
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '', stderr: '' })
-      }
-      return undefined as any
-    })
-
-    await collectSteps('/project', true)
-    expect(capturedArgs).toContain('--dry-run')
-  })
-
-  it('reports error when repoforge execution fails', async () => {
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '/usr/bin/repoforge', stderr: '' })
-      } else if (cmd === 'repoforge') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(new Error('Analysis crashed'))
-      }
-      return undefined as any
-    })
-
-    const steps = await collectSteps('/project', false)
-    const errorStep = steps.find(s => s.id === 'analyze-repoforge' && s.status === 'error')
-    expect(errorStep).toBeDefined()
-    expect(errorStep!.detail).toContain('Analysis crashed')
-  })
-
-  it('reports done with dry-run message when no stdout and dryRun', async () => {
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '/usr/bin/repoforge', stderr: '' })
-      } else if (cmd === 'repoforge') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '', stderr: '' })
-      }
-      return undefined as any
-    })
-
-    const steps = await collectSteps('/project', true)
-    const doneStep = steps.find(s => s.id === 'analyze-repoforge' && s.status === 'done')
-    expect(doneStep).toBeDefined()
-    expect(doneStep!.detail).toContain('dry-run')
-  })
-
-  it('reports warning when stderr has output', async () => {
-    mockedExecFile.mockImplementation((_cmd: unknown, _args: unknown, _opts: unknown, cb: unknown) => {
-      const cmd = String(_cmd)
-      if (cmd === 'which') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, { stdout: '/usr/bin/repoforge', stderr: '' })
-      } else if (cmd === 'repoforge') {
-        const callback = typeof _opts === 'function' ? _opts : cb
-        if (typeof callback === 'function') (callback as Function)(null, {
-          stdout: 'Analysis done',
-          stderr: 'Warning: deprecated API\nWarning: slow scan',
-        })
-      }
-      return undefined as any
-    })
-
-    const steps = await collectSteps('/project', false)
-    const warnStep = steps.find(s => s.id === 'analyze-warnings')
-    expect(warnStep).toBeDefined()
-    expect(warnStep!.status).toBe('skipped')
-    expect(warnStep!.detail).toContain('Warning: slow scan')
-  })
-})

package/src/commands/analyze.ts

@@ -1,69 +0,0 @@
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-import type { InitStep } from '../types/index.js'
-
-const execFileAsync = promisify(execFile)
-
-type StepCallback = (step: InitStep) => void
-
-function report(onStep: StepCallback, id: string, label: string, status: InitStep['status'], detail?: string) {
-  onStep({ id, label, status, detail })
-}
-
-/** Check if a binary is available in PATH */
-async function which(bin: string): Promise<boolean> {
-  try {
-    await execFileAsync('which', [bin])
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Run repoforge skills analysis on a project directory.
- * This is a thin wrapper that delegates to the repoforge CLI.
- */
-export async function runAnalyze(
-  projectDir: string,
-  dryRun: boolean,
-  onStep: StepCallback
-): Promise<void> {
-  const stepId = 'analyze-repoforge'
-  report(onStep, stepId, 'Run repoforge skills analysis', 'running')
-
-  try {
-    // Check if repoforge is installed
-    const hasRepoforge = await which('repoforge')
-
-    if (!hasRepoforge) {
-      report(onStep, stepId, 'Run repoforge skills analysis', 'error',
-        'repoforge not found. Install with: pip install repoforge')
-      return
-    }
-
-    const args = ['skills', '-w', projectDir]
-    if (dryRun) {
-      args.push('--dry-run')
-    }
-
-    const { stdout, stderr } = await execFileAsync('repoforge', args, {
-      cwd: projectDir,
-      timeout: 300_000, // 5 min — analysis can take a while on large repos
-    })
-
-    if (stdout) {
-      report(onStep, stepId, 'Run repoforge skills analysis', 'done', stdout.trim().split('\n').pop() ?? 'complete')
-    } else {
-      report(onStep, stepId, 'Run repoforge skills analysis', 'done', dryRun ? 'dry-run complete' : 'complete')
-    }
-
-    if (stderr) {
-      const warnId = 'analyze-warnings'
-      report(onStep, warnId, 'Analysis warnings', 'skipped', stderr.trim().split('\n').pop() ?? '')
-    }
-  } catch (e: unknown) {
-    const msg = e instanceof Error ? e.message : String(e)
-    report(onStep, stepId, 'Run repoforge skills analysis', 'error', msg)
-  }
-}

package/src/commands/doctor.test.ts

@@ -1,208 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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 }
-}