javi-forge 0.1.0 → 1.0.0

package/src/commands/init.test.ts

@@ -1,298 +0,0 @@
-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')
-  })
-})

package/src/commands/init.ts

@@ -1,285 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-import type { InitOptions, InitStep, ForgeManifest } from '../types/index.js'
-import { backupIfExists, ensureDirExists } from '../lib/common.js'
-import { generateDependabotYml, generateCIWorkflow, getCIDestination } from '../lib/template.js'
-import {
-  FORGE_ROOT,
-  TEMPLATES_DIR,
-  MODULES_DIR,
-  CI_LOCAL_DIR,
-} from '../constants.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 })
-}
-
-/**
- * Main init orchestrator: bootstraps a project with CI, git hooks,
- * memory module, AI config sync, SDD, and ghagga.
- */
-export async function initProject(
-  options: InitOptions,
-  onStep: StepCallback
-): Promise<void> {
-  const { projectDir, projectName, stack, ciProvider, memory, aiSync, sdd, ghagga, dryRun } = options
-
-  // Ensure project directory exists before any steps
-  if (!dryRun && projectDir) {
-    await ensureDirExists(projectDir)
-  }
-
-  // ── Step 1: Initialize git ────────────────────────────────────────────────
-  const stepGit = 'git-init'
-  report(onStep, stepGit, 'Initialize git repository', 'running')
-  try {
-    const gitDir = path.join(projectDir, '.git')
-    if (!await fs.pathExists(gitDir)) {
-      if (!dryRun) {
-        await execFileAsync('git', ['init'], { cwd: projectDir })
-      }
-      report(onStep, stepGit, 'Initialize git repository', 'done', 'initialized')
-    } else {
-      report(onStep, stepGit, 'Initialize git repository', 'done', 'already exists')
-    }
-  } catch (e) {
-    report(onStep, stepGit, 'Initialize git repository', 'error', String(e))
-  }
-
-  // ── Step 2: Configure git hooks path ──────────────────────────────────────
-  const stepHooks = 'git-hooks'
-  report(onStep, stepHooks, 'Configure git hooks path', 'running')
-  try {
-    const ciLocalSrc = CI_LOCAL_DIR
-    const ciLocalDest = path.join(projectDir, 'ci-local')
-    if (await fs.pathExists(ciLocalSrc)) {
-      if (!dryRun) {
-        await fs.copy(ciLocalSrc, ciLocalDest, { overwrite: false, errorOnExist: false })
-        // Set core.hooksPath to ci-local/hooks
-        const hooksDir = path.join(ciLocalDest, 'hooks')
-        if (await fs.pathExists(hooksDir)) {
-          await execFileAsync('git', ['config', 'core.hooksPath', 'ci-local/hooks'], { cwd: projectDir })
-        }
-      }
-      report(onStep, stepHooks, 'Configure git hooks path', 'done', 'ci-local/hooks')
-    } else {
-      report(onStep, stepHooks, 'Configure git hooks path', 'skipped', 'no ci-local dir')
-    }
-  } catch (e) {
-    report(onStep, stepHooks, 'Configure git hooks path', 'error', String(e))
-  }
-
-  // ── Step 3: Copy CI template ──────────────────────────────────────────────
-  const stepCI = 'ci-template'
-  report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'running')
-  try {
-    const ciContent = await generateCIWorkflow(stack, ciProvider)
-    if (ciContent) {
-      const dest = path.join(projectDir, getCIDestination(ciProvider))
-      if (!dryRun) {
-        await backupIfExists(dest)
-        await ensureDirExists(path.dirname(dest))
-        await fs.writeFile(dest, ciContent, 'utf-8')
-      }
-      report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'done', getCIDestination(ciProvider))
-    } else {
-      report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'skipped', `no template for ${stack}`)
-    }
-  } catch (e) {
-    report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'error', String(e))
-  }
-
-  // ── Step 4: Generate .gitignore ───────────────────────────────────────────
-  const stepGitignore = 'gitignore'
-  report(onStep, stepGitignore, 'Generate .gitignore', 'running')
-  try {
-    const templatePath = path.join(FORGE_ROOT, '.gitignore.template')
-    const dest = path.join(projectDir, '.gitignore')
-    if (await fs.pathExists(templatePath) && !await fs.pathExists(dest)) {
-      if (!dryRun) {
-        await fs.copy(templatePath, dest)
-      }
-      report(onStep, stepGitignore, 'Generate .gitignore', 'done', 'from template')
-    } else if (await fs.pathExists(dest)) {
-      report(onStep, stepGitignore, 'Generate .gitignore', 'done', 'already exists')
-    } else {
-      report(onStep, stepGitignore, 'Generate .gitignore', 'skipped', 'no template')
-    }
-  } catch (e) {
-    report(onStep, stepGitignore, 'Generate .gitignore', 'error', String(e))
-  }
-
-  // ── Step 5: Generate dependabot.yml ───────────────────────────────────────
-  const stepDeps = 'dependabot'
-  report(onStep, stepDeps, 'Generate dependabot.yml', 'running')
-  try {
-    if (ciProvider === 'github') {
-      const content = await generateDependabotYml([stack], true)
-      const dest = path.join(projectDir, '.github', 'dependabot.yml')
-      if (!dryRun) {
-        await backupIfExists(dest)
-        await ensureDirExists(path.dirname(dest))
-        await fs.writeFile(dest, content, 'utf-8')
-      }
-      report(onStep, stepDeps, 'Generate dependabot.yml', 'done')
-    } else {
-      report(onStep, stepDeps, 'Generate dependabot.yml', 'skipped', `not needed for ${ciProvider}`)
-    }
-  } catch (e) {
-    report(onStep, stepDeps, 'Generate dependabot.yml', 'error', String(e))
-  }
-
-  // ── Step 6: Install memory module ─────────────────────────────────────────
-  const stepMem = 'memory'
-  report(onStep, stepMem, `Install memory module: ${memory}`, 'running')
-  try {
-    if (memory !== 'none') {
-      const moduleSrc = path.join(MODULES_DIR, memory)
-      if (await fs.pathExists(moduleSrc)) {
-        if (!dryRun) {
-          // Copy module files to project
-          const moduleDest = path.join(projectDir, '.javi-forge', 'modules', memory)
-          await ensureDirExists(moduleDest)
-          await fs.copy(moduleSrc, moduleDest, { overwrite: false, errorOnExist: false })
-
-          // If engram, copy .mcp-config-snippet.json to project
-          if (memory === 'engram') {
-            const snippetSrc = path.join(moduleSrc, '.mcp-config-snippet.json')
-            if (await fs.pathExists(snippetSrc)) {
-              const snippetDest = path.join(projectDir, '.mcp-config-snippet.json')
-              await fs.copy(snippetSrc, snippetDest, { overwrite: false })
-            }
-          }
-        }
-        report(onStep, stepMem, `Install memory module: ${memory}`, 'done')
-      } else {
-        report(onStep, stepMem, `Install memory module: ${memory}`, 'error', 'module not found')
-      }
-    } else {
-      report(onStep, stepMem, `Install memory module: ${memory}`, 'skipped', 'none selected')
-    }
-  } catch (e) {
-    report(onStep, stepMem, `Install memory module: ${memory}`, 'error', String(e))
-  }
-
-  // ── Step 7: AI config sync (delegated to javi-ai) ──────────────────────────
-  const stepAI = 'ai-sync'
-  report(onStep, stepAI, 'Sync AI config via javi-ai', 'running')
-  try {
-    if (aiSync) {
-      if (!dryRun) {
-        try {
-          await execFileAsync('npx', ['javi-ai', 'sync', '--project-dir', projectDir, '--target', 'all'], {
-            cwd: projectDir,
-            timeout: 120_000,
-          })
-          report(onStep, stepAI, 'Sync AI config via javi-ai', 'done', 'javi-ai sync --target all')
-        } catch (syncErr: unknown) {
-          const msg = syncErr instanceof Error ? syncErr.message : String(syncErr)
-          if (msg.includes('ENOENT') || msg.includes('not found') || msg.includes('ERR_MODULE_NOT_FOUND')) {
-            report(onStep, stepAI, 'Sync AI config via javi-ai', 'error',
-              'javi-ai not found. Install with: npm install -g javi-ai (or run npx javi-ai sync manually)')
-          } else {
-            report(onStep, stepAI, 'Sync AI config via javi-ai', 'error', msg)
-          }
-        }
-      } else {
-        report(onStep, stepAI, 'Sync AI config via javi-ai', 'done', 'dry-run: would run javi-ai sync --target all')
-      }
-    } else {
-      report(onStep, stepAI, 'Sync AI config via javi-ai', 'skipped', 'not selected')
-    }
-  } catch (e) {
-    report(onStep, stepAI, 'Sync AI config via javi-ai', 'error', String(e))
-  }
-
-  // ── Step 8: SDD (Spec-Driven Development) ─────────────────────────────────
-  const stepSDD = 'sdd'
-  report(onStep, stepSDD, 'Set up SDD (openspec/)', 'running')
-  try {
-    if (sdd) {
-      if (!dryRun) {
-        const openspecDir = path.join(projectDir, 'openspec')
-        await ensureDirExists(openspecDir)
-        // Create a README if none exists
-        const readmePath = path.join(openspecDir, 'README.md')
-        if (!await fs.pathExists(readmePath)) {
-          await fs.writeFile(readmePath, `# openspec/\n\nSpec-Driven Development artifacts for ${projectName}.\n\nSee: /sdd:new <name> to start a new change.\n`, 'utf-8')
-        }
-      }
-      report(onStep, stepSDD, 'Set up SDD (openspec/)', 'done')
-    } else {
-      report(onStep, stepSDD, 'Set up SDD (openspec/)', 'skipped', 'not selected')
-    }
-  } catch (e) {
-    report(onStep, stepSDD, 'Set up SDD (openspec/)', 'error', String(e))
-  }
-
-  // ── Step 9: GHAGGA ────────────────────────────────────────────────────────
-  const stepGhagga = 'ghagga'
-  report(onStep, stepGhagga, 'Install GHAGGA review system', 'running')
-  try {
-    if (ghagga) {
-      const ghaggaSrc = path.join(MODULES_DIR, 'ghagga')
-      if (await fs.pathExists(ghaggaSrc)) {
-        if (!dryRun) {
-          const ghaggaDest = path.join(projectDir, '.javi-forge', 'modules', 'ghagga')
-          await ensureDirExists(ghaggaDest)
-          await fs.copy(ghaggaSrc, ghaggaDest, { overwrite: false, errorOnExist: false })
-
-          // Copy ghagga workflow to CI provider location
-          if (ciProvider === 'github') {
-            const workflowSrc = path.join(FORGE_ROOT, 'workflows', 'reusable-ghagga-review.yml')
-            if (await fs.pathExists(workflowSrc)) {
-              const workflowDest = path.join(projectDir, '.github', 'workflows', 'ghagga-review.yml')
-              await ensureDirExists(path.dirname(workflowDest))
-              await fs.copy(workflowSrc, workflowDest, { overwrite: false })
-            }
-          }
-        }
-        report(onStep, stepGhagga, 'Install GHAGGA review system', 'done')
-      } else {
-        report(onStep, stepGhagga, 'Install GHAGGA review system', 'error', 'module not found')
-      }
-    } else {
-      report(onStep, stepGhagga, 'Install GHAGGA review system', 'skipped', 'not selected')
-    }
-  } catch (e) {
-    report(onStep, stepGhagga, 'Install GHAGGA review system', 'error', String(e))
-  }
-
-  // ── Step 10: Write manifest ───────────────────────────────────────────────
-  const stepManifest = 'manifest'
-  report(onStep, stepManifest, 'Write forge manifest', 'running')
-  try {
-    if (!dryRun) {
-      const manifestDir = path.join(projectDir, '.javi-forge')
-      await ensureDirExists(manifestDir)
-      const manifest: ForgeManifest = {
-        version: '0.1.0',
-        projectName,
-        stack,
-        ciProvider,
-        memory,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        modules: [
-          ...(memory !== 'none' ? [memory] : []),
-          ...(ghagga ? ['ghagga'] : []),
-          ...(sdd ? ['sdd'] : []),
-          ...(aiSync ? ['ai-config'] : []),
-        ],
-      }
-      await fs.writeJson(path.join(manifestDir, 'manifest.json'), manifest, { spaces: 2 })
-    }
-    report(onStep, stepManifest, 'Write forge manifest', 'done', '.javi-forge/manifest.json')
-  } catch (e) {
-    report(onStep, stepManifest, 'Write forge manifest', 'error', String(e))
-  }
-}

package/src/constants.ts

@@ -1,69 +0,0 @@
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-
-/** Root of the javi-forge package (one level up from dist/) */
-export const FORGE_ROOT = path.resolve(__dirname, '..')
-
-/** Templates directory */
-export const TEMPLATES_DIR = path.join(FORGE_ROOT, 'templates')
-
-/** Modules directory */
-export const MODULES_DIR = path.join(FORGE_ROOT, 'modules')
-
-/** Workflows directory */
-export const WORKFLOWS_DIR = path.join(FORGE_ROOT, 'workflows')
-
-/** AI config directory */
-export const AI_CONFIG_DIR = path.join(FORGE_ROOT, 'ai-config')
-
-/** Schemas directory */
-export const SCHEMAS_DIR = path.join(FORGE_ROOT, 'schemas')
-
-/** CI-local directory */
-export const CI_LOCAL_DIR = path.join(FORGE_ROOT, 'ci-local')
-
-/** Dependabot fragment directory */
-export const DEPENDABOT_FRAGMENTS_DIR = path.join(TEMPLATES_DIR, 'common', 'dependabot')
-
-/** Stack-to-dependabot fragment mapping */
-export const STACK_DEPENDABOT_MAP: Record<string, string[]> = {
-  'node':        ['npm'],
-  'python':      ['pip'],
-  'go':          ['gomod'],
-  'rust':        ['cargo'],
-  'java-gradle': ['gradle'],
-  'java-maven':  ['maven'],
-  'elixir':      [],
-}
-
-/** Stack-to-CI template filename mapping */
-export const STACK_CI_MAP: Record<string, Record<string, string>> = {
-  github: {
-    'node':        'ci-node.yml',
-    'python':      'ci-python.yml',
-    'go':          'ci-go.yml',
-    'rust':        'ci-rust.yml',
-    'java-gradle': 'ci-java.yml',
-    'java-maven':  'ci-java.yml',
-  },
-  gitlab: {
-    'node':        'gitlab-ci-node.yml',
-    'python':      'gitlab-ci-python.yml',
-    'go':          'gitlab-ci-go.yml',
-    'rust':        'gitlab-ci-rust.yml',
-    'java-gradle': 'gitlab-ci-java.yml',
-    'java-maven':  'gitlab-ci-java.yml',
-  },
-  woodpecker: {
-    'node':        'woodpecker-node.yml',
-    'python':      'woodpecker-python.yml',
-    'go':          'woodpecker-go.yml',
-    'rust':        'woodpecker-rust.yml',
-    'java-gradle': 'woodpecker-java.yml',
-    'java-maven':  'woodpecker-java.yml',
-  },
-}
-
-