javi-forge 1.5.0 → 1.6.1

package/dist/commands/ci.js

@@ -1,73 +1,74 @@
-import { execFile, spawn } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs-extra';
-import path from 'path';
-import { isDockerAvailable, ensureImage, runInContainer, openShell } from '../lib/docker.js';
+import { execFile, spawn } from "child_process";
+import fs from "fs-extra";
+import path from "path";
+import { promisify } from "util";
+import { refreshContextDir } from "../lib/context.js";
+import { ensureImage, isDockerAvailable, openShell, runInContainer, } from "../lib/docker.js";
 const execFileAsync = promisify(execFile);
 // =============================================================================
 // Stack detection
 // =============================================================================
 export async function detectCIStack(projectDir) {
-    let stackType = 'node';
-    let buildTool = 'npm';
-    let javaVersion = '21';
+    let stackType = "node";
+    let buildTool = "npm";
+    let javaVersion = "21";
     // Java Gradle
-    if (await fs.pathExists(path.join(projectDir, 'build.gradle.kts')) ||
-        await fs.pathExists(path.join(projectDir, 'build.gradle'))) {
-        stackType = 'java-gradle';
-        buildTool = 'gradle';
+    if ((await fs.pathExists(path.join(projectDir, "build.gradle.kts"))) ||
+        (await fs.pathExists(path.join(projectDir, "build.gradle")))) {
+        stackType = "java-gradle";
+        buildTool = "gradle";
         // Try to read java version from build files
-        const ktsPath = path.join(projectDir, 'build.gradle.kts');
-        const gradlePath = path.join(projectDir, 'build.gradle');
+        const ktsPath = path.join(projectDir, "build.gradle.kts");
+        const gradlePath = path.join(projectDir, "build.gradle");
         if (await fs.pathExists(ktsPath)) {
-            const content = await fs.readFile(ktsPath, 'utf-8');
+            const content = await fs.readFile(ktsPath, "utf-8");
             const match = content.match(/JavaLanguageVersion\.of\((\d+)\)/);
             if (match?.[1])
                 javaVersion = match[1];
         }
         else if (await fs.pathExists(gradlePath)) {
-            const content = await fs.readFile(gradlePath, 'utf-8');
+            const content = await fs.readFile(gradlePath, "utf-8");
             const match = content.match(/sourceCompatibility\s*=\s*['"]*(\d+)/);
             if (match?.[1])
                 javaVersion = match[1];
         }
     }
     // Java Maven
-    else if (await fs.pathExists(path.join(projectDir, 'pom.xml'))) {
-        stackType = 'java-maven';
-        buildTool = 'mvn';
+    else if (await fs.pathExists(path.join(projectDir, "pom.xml"))) {
+        stackType = "java-maven";
+        buildTool = "mvn";
     }
     // Node
-    else if (await fs.pathExists(path.join(projectDir, 'package.json'))) {
-        stackType = 'node';
-        if (await fs.pathExists(path.join(projectDir, 'pnpm-lock.yaml')))
-            buildTool = 'pnpm';
-        else if (await fs.pathExists(path.join(projectDir, 'yarn.lock')))
-            buildTool = 'yarn';
+    else if (await fs.pathExists(path.join(projectDir, "package.json"))) {
+        stackType = "node";
+        if (await fs.pathExists(path.join(projectDir, "pnpm-lock.yaml")))
+            buildTool = "pnpm";
+        else if (await fs.pathExists(path.join(projectDir, "yarn.lock")))
+            buildTool = "yarn";
         else
-            buildTool = 'npm';
+            buildTool = "npm";
     }
     // Go
-    else if (await fs.pathExists(path.join(projectDir, 'go.mod'))) {
-        stackType = 'go';
-        buildTool = 'go';
+    else if (await fs.pathExists(path.join(projectDir, "go.mod"))) {
+        stackType = "go";
+        buildTool = "go";
     }
     // Rust
-    else if (await fs.pathExists(path.join(projectDir, 'Cargo.toml'))) {
-        stackType = 'rust';
-        buildTool = 'cargo';
+    else if (await fs.pathExists(path.join(projectDir, "Cargo.toml"))) {
+        stackType = "rust";
+        buildTool = "cargo";
     }
     // Python
-    else if (await fs.pathExists(path.join(projectDir, 'pyproject.toml')) ||
-        await fs.pathExists(path.join(projectDir, 'requirements.txt')) ||
-        await fs.pathExists(path.join(projectDir, 'setup.py'))) {
-        stackType = 'python';
-        if (await fs.pathExists(path.join(projectDir, 'uv.lock')))
-            buildTool = 'uv';
-        else if (await fs.pathExists(path.join(projectDir, 'poetry.lock')))
-            buildTool = 'poetry';
+    else if ((await fs.pathExists(path.join(projectDir, "pyproject.toml"))) ||
+        (await fs.pathExists(path.join(projectDir, "requirements.txt"))) ||
+        (await fs.pathExists(path.join(projectDir, "setup.py")))) {
+        stackType = "python";
+        if (await fs.pathExists(path.join(projectDir, "uv.lock")))
+            buildTool = "uv";
+        else if (await fs.pathExists(path.join(projectDir, "poetry.lock")))
+            buildTool = "poetry";
         else
-            buildTool = 'pip';
+            buildTool = "pip";
     }
     // Build CI commands per stack
     const { lintCmd, compileCmd, testCmd } = await buildCICommands(stackType, buildTool, projectDir);
@@ -75,52 +76,58 @@ export async function detectCIStack(projectDir) {
 }
 async function buildCICommands(stack, buildTool, projectDir) {
     switch (stack) {
-        case 'java-gradle':
+        case "java-gradle":
             return {
-                lintCmd: './gradlew spotlessCheck --no-daemon',
-                compileCmd: './gradlew clean classes testClasses --no-daemon && chown -R runner:runner build/ .gradle/ 2>/dev/null || true',
-                testCmd: './gradlew test --no-daemon',
+                lintCmd: "./gradlew spotlessCheck --no-daemon",
+                compileCmd: "./gradlew clean classes testClasses --no-daemon && chown -R runner:runner build/ .gradle/ 2>/dev/null || true",
+                testCmd: "./gradlew test --no-daemon",
             };
-        case 'java-maven':
+        case "java-maven":
             return {
-                lintCmd: './mvnw spotless:check',
-                compileCmd: './mvnw clean compile test-compile && chown -R runner:runner target/ .mvn/ 2>/dev/null || true',
-                testCmd: './mvnw test',
+                lintCmd: "./mvnw spotless:check",
+                compileCmd: "./mvnw clean compile test-compile && chown -R runner:runner target/ .mvn/ 2>/dev/null || true",
+                testCmd: "./mvnw test",
             };
-        case 'node': {
-            const pkgPath = path.join(projectDir, 'package.json');
-            let pkgContent = '';
+        case "node": {
+            const pkgPath = path.join(projectDir, "package.json");
+            let pkgContent = "";
             try {
-                pkgContent = await fs.readFile(pkgPath, 'utf-8');
+                pkgContent = await fs.readFile(pkgPath, "utf-8");
+            }
+            catch {
+                /* no package.json */
             }
-            catch { /* no package.json */ }
             // Clean dist/ before build and chown after so tests (as runner) can access output.
             // Runs as root inside the container to handle host-owned output dirs.
-            const buildPrefix = 'rm -rf dist/ && ';
-            const buildSuffix = ' && chown -R runner:runner dist/ 2>/dev/null || true';
+            const buildPrefix = "rm -rf dist/ && ";
+            const buildSuffix = " && chown -R runner:runner dist/ 2>/dev/null || true";
             return {
                 lintCmd: pkgContent.includes('"lint"') ? `${buildTool} run lint` : null,
-                compileCmd: pkgContent.includes('"build"') ? `${buildPrefix}${buildTool} run build${buildSuffix}` : null,
-                testCmd: pkgContent.includes('"test"') ? `${buildTool} ${buildTool === 'npm' ? 'test' : 'run test'}` : null,
+                compileCmd: pkgContent.includes('"build"')
+                    ? `${buildPrefix}${buildTool} run build${buildSuffix}`
+                    : null,
+                testCmd: pkgContent.includes('"test"')
+                    ? `${buildTool} ${buildTool === "npm" ? "test" : "run test"}`
+                    : null,
             };
         }
-        case 'python':
+        case "python":
             return {
-                lintCmd: 'ruff check . && { pylint **/*.py 2>/dev/null || true; }',
+                lintCmd: "ruff check . && { pylint **/*.py 2>/dev/null || true; }",
                 compileCmd: null,
-                testCmd: 'pytest',
+                testCmd: "pytest",
             };
-        case 'go':
+        case "go":
             return {
-                lintCmd: 'golangci-lint run',
-                compileCmd: 'go clean -cache && go build ./... && chown -R runner:runner . 2>/dev/null || true',
-                testCmd: 'go test ./...',
+                lintCmd: "golangci-lint run",
+                compileCmd: "go clean -cache && go build ./... && chown -R runner:runner . 2>/dev/null || true",
+                testCmd: "go test ./...",
             };
-        case 'rust':
+        case "rust":
             return {
-                lintCmd: 'cargo clippy -- -D warnings',
-                compileCmd: 'cargo clean && cargo build && chown -R runner:runner target/ 2>/dev/null || true',
-                testCmd: 'cargo test',
+                lintCmd: "cargo clippy -- -D warnings",
+                compileCmd: "cargo clean && cargo build && chown -R runner:runner target/ 2>/dev/null || true",
+                testCmd: "cargo test",
             };
         default:
             return { lintCmd: null, compileCmd: null, testCmd: null };
@@ -131,7 +138,7 @@ async function buildCICommands(stack, buildTool, projectDir) {
 // =============================================================================
 async function isGhaggaAvailable() {
     try {
-        await execFileAsync('ghagga', ['--version'], { timeout: 3000 });
+        await execFileAsync("ghagga", ["--version"], { timeout: 3000 });
         return true;
     }
     catch {
@@ -145,35 +152,38 @@ function report(onStep, id, label, status, detail) {
     onStep({ id, label, status, detail });
 }
 export async function runCI(options, onStep) {
-    const { projectDir = process.cwd(), mode = 'full', noDocker = false, noGhagga = false, noSecurity = false, timeout = 600, } = options;
+    const { projectDir = process.cwd(), mode = "full", noDocker = false, noGhagga = false, noSecurity = false, timeout = 600, } = options;
     // ── Detect stack ────────────────────────────────────────────────────────────
-    const stepDetect = 'detect';
-    report(onStep, stepDetect, 'Detecting stack', 'running');
+    const stepDetect = "detect";
+    report(onStep, stepDetect, "Detecting stack", "running");
     let stackInfo;
     try {
         stackInfo = await detectCIStack(projectDir);
-        report(onStep, stepDetect, `Stack: ${stackInfo.stackType} (${stackInfo.buildTool})`, 'done');
+        report(onStep, stepDetect, `Stack: ${stackInfo.stackType} (${stackInfo.buildTool})`, "done");
     }
     catch (e) {
-        report(onStep, stepDetect, 'Detecting stack', 'error', String(e));
+        report(onStep, stepDetect, "Detecting stack", "error", String(e));
         throw e;
     }
     // ── Detect mode ─────────────────────────────────────────────────────────────
-    if (mode === 'detect')
+    if (mode === "detect")
         return;
     // ── Shell mode ──────────────────────────────────────────────────────────────
-    if (mode === 'shell') {
+    if (mode === "shell") {
         if (noDocker) {
-            report(onStep, 'shell', 'Shell', 'error', '--shell requires Docker');
-            throw new Error('--shell requires Docker');
+            report(onStep, "shell", "Shell", "error", "--shell requires Docker");
+            throw new Error("--shell requires Docker");
         }
-        report(onStep, 'docker-image', 'Building Docker image', 'running');
+        report(onStep, "docker-image", "Building Docker image", "running");
         try {
-            await ensureImage({ stack: stackInfo.stackType, javaVersion: stackInfo.javaVersion });
-            report(onStep, 'docker-image', 'Docker image ready', 'done');
+            await ensureImage({
+                stack: stackInfo.stackType,
+                javaVersion: stackInfo.javaVersion,
+            });
+            report(onStep, "docker-image", "Docker image ready", "done");
         }
         catch (e) {
-            report(onStep, 'docker-image', 'Building Docker image', 'error', String(e));
+            report(onStep, "docker-image", "Building Docker image", "error", String(e));
             throw e;
         }
         await openShell(projectDir);
@@ -181,103 +191,122 @@ export async function runCI(options, onStep) {
     }
     // ── Check Docker ─────────────────────────────────────────────────────────────
     if (!noDocker) {
-        const stepDocker = 'docker-check';
-        report(onStep, stepDocker, 'Checking Docker', 'running');
+        const stepDocker = "docker-check";
+        report(onStep, stepDocker, "Checking Docker", "running");
         const dockerOk = await isDockerAvailable();
         if (!dockerOk) {
-            report(onStep, stepDocker, 'Docker not available', 'error', 'Start Docker or use --no-docker');
-            throw new Error('Docker is not available');
+            report(onStep, stepDocker, "Docker not available", "error", "Start Docker or use --no-docker");
+            throw new Error("Docker is not available");
         }
-        report(onStep, stepDocker, 'Docker available', 'done');
+        report(onStep, stepDocker, "Docker available", "done");
         // Build image
-        const stepImage = 'docker-image';
-        report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, 'running');
+        const stepImage = "docker-image";
+        report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, "running");
         try {
-            await ensureImage({ stack: stackInfo.stackType, javaVersion: stackInfo.javaVersion });
-            report(onStep, stepImage, 'Docker image ready', 'done');
+            await ensureImage({
+                stack: stackInfo.stackType,
+                javaVersion: stackInfo.javaVersion,
+            });
+            report(onStep, stepImage, "Docker image ready", "done");
         }
         catch (e) {
-            report(onStep, stepImage, 'Building Docker image', 'error', String(e));
+            report(onStep, stepImage, "Building Docker image", "error", String(e));
             throw e;
         }
     }
+    // ── Refresh .context/ ────────────────────────────────────────────────────────
+    const stepContext = "context-refresh";
+    report(onStep, stepContext, "Refresh .context/ directory", "running");
+    try {
+        const ctxResult = await refreshContextDir(projectDir);
+        if (ctxResult) {
+            report(onStep, stepContext, "Refresh .context/ directory", "done", "INDEX.md + summary.md updated");
+        }
+        else {
+            report(onStep, stepContext, "Refresh .context/ directory", "skipped", "no .context/ or no manifest");
+        }
+    }
+    catch (e) {
+        // Non-fatal: context refresh failure should not block CI
+        report(onStep, stepContext, "Refresh .context/ directory", "error", String(e));
+    }
     // ── Lint ─────────────────────────────────────────────────────────────────────
     if (stackInfo.lintCmd) {
-        const stepLint = 'lint';
-        report(onStep, stepLint, `Lint: ${stackInfo.lintCmd}`, 'running');
+        const stepLint = "lint";
+        report(onStep, stepLint, `Lint: ${stackInfo.lintCmd}`, "running");
         try {
             await runStep(stackInfo.lintCmd, projectDir, noDocker, timeout);
-            report(onStep, stepLint, 'Lint passed', 'done');
+            report(onStep, stepLint, "Lint passed", "done");
         }
         catch (e) {
-            report(onStep, stepLint, 'Lint failed', 'error', String(e));
+            report(onStep, stepLint, "Lint failed", "error", String(e));
             throw e;
         }
     }
     // ── Compile ──────────────────────────────────────────────────────────────────
     if (stackInfo.compileCmd) {
-        const stepCompile = 'compile';
-        report(onStep, stepCompile, `Compile: ${stackInfo.compileCmd}`, 'running');
+        const stepCompile = "compile";
+        report(onStep, stepCompile, `Compile: ${stackInfo.compileCmd}`, "running");
         try {
             // Run as root inside the container to rm/build output dirs owned by any host user,
             // then chown back to runner so subsequent test steps can read the output.
-            await runStep(stackInfo.compileCmd, projectDir, noDocker, timeout, 'root');
-            report(onStep, stepCompile, 'Compile passed', 'done');
+            await runStep(stackInfo.compileCmd, projectDir, noDocker, timeout, "root");
+            report(onStep, stepCompile, "Compile passed", "done");
         }
         catch (e) {
-            report(onStep, stepCompile, 'Compile failed', 'error', String(e));
+            report(onStep, stepCompile, "Compile failed", "error", String(e));
             throw e;
         }
     }
     // ── Test (full mode only) ────────────────────────────────────────────────────
-    if (mode === 'full' && stackInfo.testCmd) {
-        const stepTest = 'test';
-        report(onStep, stepTest, `Test: ${stackInfo.testCmd}`, 'running');
+    if (mode === "full" && stackInfo.testCmd) {
+        const stepTest = "test";
+        report(onStep, stepTest, `Test: ${stackInfo.testCmd}`, "running");
         try {
             await runStep(stackInfo.testCmd, projectDir, noDocker, timeout);
-            report(onStep, stepTest, 'Tests passed', 'done');
+            report(onStep, stepTest, "Tests passed", "done");
         }
         catch (e) {
-            report(onStep, stepTest, 'Tests failed', 'error', String(e));
+            report(onStep, stepTest, "Tests failed", "error", String(e));
             throw e;
         }
     }
     // ── Security scan (full mode only) ──────────────────────────────────────────
-    if (mode === 'full' && !noSecurity) {
-        const stepSecurity = 'security';
+    if (mode === "full" && !noSecurity) {
+        const stepSecurity = "security";
         const semgrepAvailable = await isSemgrepAvailable();
         if (semgrepAvailable) {
-            report(onStep, stepSecurity, 'Security scan (Semgrep)', 'running');
+            report(onStep, stepSecurity, "Security scan (Semgrep)", "running");
             try {
                 await runSemgrep(projectDir);
-                report(onStep, stepSecurity, 'Security scan passed', 'done');
+                report(onStep, stepSecurity, "Security scan passed", "done");
             }
             catch (e) {
-                report(onStep, stepSecurity, 'Security scan failed', 'error', String(e));
+                report(onStep, stepSecurity, "Security scan failed", "error", String(e));
                 throw e;
             }
         }
         else {
-            report(onStep, stepSecurity, 'Security scan', 'skipped', 'Semgrep not available — install semgrep or Docker');
+            report(onStep, stepSecurity, "Security scan", "skipped", "Semgrep not available — install semgrep or Docker");
         }
     }
     // ── GHAGGA review (full mode only) ──────────────────────────────────────────
-    if (mode === 'full' && !noGhagga) {
-        const stepGhagga = 'ghagga';
+    if (mode === "full" && !noGhagga) {
+        const stepGhagga = "ghagga";
         const ghagga = await isGhaggaAvailable();
         if (ghagga) {
-            report(onStep, stepGhagga, 'GHAGGA review', 'running');
+            report(onStep, stepGhagga, "GHAGGA review", "running");
             try {
                 await runGhagga(projectDir);
-                report(onStep, stepGhagga, 'GHAGGA review passed', 'done');
+                report(onStep, stepGhagga, "GHAGGA review passed", "done");
             }
             catch (e) {
-                report(onStep, stepGhagga, 'GHAGGA review failed', 'error', String(e));
+                report(onStep, stepGhagga, "GHAGGA review failed", "error", String(e));
                 throw e;
             }
         }
         else {
-            report(onStep, stepGhagga, 'GHAGGA review', 'skipped', 'ghagga not installed');
+            report(onStep, stepGhagga, "GHAGGA review", "skipped", "ghagga not installed");
         }
     }
 }
@@ -288,13 +317,15 @@ async function runStep(command, projectDir, noDocker, timeout, user) {
     if (noDocker) {
         // Run natively
         await new Promise((resolve, reject) => {
-            const proc = spawn('bash', ['-c', command], {
+            const proc = spawn("bash", ["-c", command], {
                 cwd: projectDir,
-                stdio: 'inherit',
-                env: { ...process.env, CI: 'true' },
+                stdio: "inherit",
+                env: { ...process.env, CI: "true" },
             });
-            proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Command failed with code ${code}`)));
-            proc.on('error', reject);
+            proc.on("close", (code) => code === 0
+                ? resolve()
+                : reject(new Error(`Command failed with code ${code}`)));
+            proc.on("error", reject);
         });
     }
     else {
@@ -312,7 +343,7 @@ async function runStep(command, projectDir, noDocker, timeout, user) {
 }
 async function isSemgrepAvailable() {
     try {
-        await execFileAsync('semgrep', ['--version'], { timeout: 3000 });
+        await execFileAsync("semgrep", ["--version"], { timeout: 3000 });
         return true;
     }
     catch {
@@ -321,26 +352,30 @@ async function isSemgrepAvailable() {
 }
 async function runSemgrep(projectDir) {
     // Look for semgrep config in project or use auto
-    const semgrepConfig = await fs.pathExists(path.join(projectDir, '.semgrep.yml'))
-        ? path.join(projectDir, '.semgrep.yml')
-        : 'auto';
+    const semgrepConfig = (await fs.pathExists(path.join(projectDir, ".semgrep.yml")))
+        ? path.join(projectDir, ".semgrep.yml")
+        : "auto";
     await new Promise((resolve, reject) => {
-        const proc = spawn('semgrep', ['--config', semgrepConfig, '--severity', 'ERROR', '--quiet', '.'], {
+        const proc = spawn("semgrep", ["--config", semgrepConfig, "--severity", "ERROR", "--quiet", "."], {
             cwd: projectDir,
-            stdio: 'inherit',
+            stdio: "inherit",
         });
-        proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Semgrep found issues (exit ${code})`)));
-        proc.on('error', reject);
+        proc.on("close", (code) => code === 0
+            ? resolve()
+            : reject(new Error(`Semgrep found issues (exit ${code})`)));
+        proc.on("error", reject);
     });
 }
 async function runGhagga(projectDir) {
     await new Promise((resolve, reject) => {
-        const proc = spawn('ghagga', ['review', '--plain', '--exit-on-issues'], {
+        const proc = spawn("ghagga", ["review", "--plain", "--exit-on-issues"], {
             cwd: projectDir,
-            stdio: 'inherit',
+            stdio: "inherit",
         });
-        proc.on('close', code => code === 0 ? resolve() : reject(new Error(`GHAGGA review found issues (exit ${code})`)));
-        proc.on('error', reject);
+        proc.on("close", (code) => code === 0
+            ? resolve()
+            : reject(new Error(`GHAGGA review found issues (exit ${code})`)));
+        proc.on("error", reject);
     });
 }
 // =============================================================================
@@ -386,8 +421,8 @@ fi || {
 const COMMIT_MSG_HOOK = `#!/bin/bash
 # Commit-msg: block AI attribution in commit messages
 set -e
-COMMIT_MSG_FILE="\$1"
-COMMIT_MSG=\$(cat "\$COMMIT_MSG_FILE")
+COMMIT_MSG_FILE="$1"
+COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")
 
 AI_PATTERNS=(
   "co-authored-by:.*claude" "co-authored-by:.*anthropic"
@@ -403,10 +438,10 @@ AI_PATTERNS=(
 )
 
 for pattern in "\${AI_PATTERNS[@]}"; do
-  if echo "\$COMMIT_MSG" | grep -iqE "\$pattern"; then
+  if echo "$COMMIT_MSG" | grep -iqE "$pattern"; then
     echo ""
     echo "COMMIT BLOCKED: AI Attribution Detected"
-    echo "  Pattern: \$pattern"
+    echo "  Pattern: $pattern"
     echo "  Remove AI attribution. You are the sole author."
     echo ""
     exit 1
@@ -415,16 +450,19 @@ done
 exit 0
 `;
 export async function installCIHooks(projectDir) {
-    const gitDir = path.join(projectDir, '.git');
-    if (!await fs.pathExists(gitDir)) {
-        return { installed: [], errors: ['Not a git repository. Run git init first.'] };
+    const gitDir = path.join(projectDir, ".git");
+    if (!(await fs.pathExists(gitDir))) {
+        return {
+            installed: [],
+            errors: ["Not a git repository. Run git init first."],
+        };
     }
-    const hooksDir = path.join(gitDir, 'hooks');
+    const hooksDir = path.join(gitDir, "hooks");
     await fs.ensureDir(hooksDir);
     const hooks = [
-        { name: 'pre-commit', content: PRE_COMMIT_HOOK },
-        { name: 'pre-push', content: PRE_PUSH_HOOK },
-        { name: 'commit-msg', content: COMMIT_MSG_HOOK },
+        { name: "pre-commit", content: PRE_COMMIT_HOOK },
+        { name: "pre-push", content: PRE_PUSH_HOOK },
+        { name: "commit-msg", content: COMMIT_MSG_HOOK },
     ];
     const installed = [];
     const errors = [];

package/dist/commands/crash-recovery.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Crash recovery — reconstruct pipeline state from git commit history
+ * when checkpoint files are corrupted or lost. Git is the single
+ * source of truth for what was actually done.
+ */
+export interface RecoveredTask {
+    commitHash: string;
+    message: string;
+    timestamp: string;
+    filesChanged: string[];
+    taskId: string | null;
+    phase: string | null;
+}
+export interface RecoveryReport {
+    branch: string;
+    totalCommits: number;
+    tasks: RecoveredTask[];
+    phases: Record<string, number>;
+    lastActivity: string | null;
+}
+export declare function getGitLog(projectDir: string, options?: {
+    maxCommits?: number;
+    since?: string;
+}): Promise<string>;
+export declare function getCurrentBranch(projectDir: string): Promise<string>;
+export declare function parseCommitPhase(message: string): string | null;
+export declare function extractTaskId(message: string): string | null;
+export declare function parseGitLog(raw: string): RecoveredTask[];
+export declare function recoverFromGit(projectDir: string, options?: {
+    maxCommits?: number;
+    since?: string;
+}): Promise<RecoveryReport>;
+export declare function formatRecovery(report: RecoveryReport): string;
+//# sourceMappingURL=crash-recovery.d.ts.map