javi-forge 1.5.0 → 1.6.1

package/dist/commands/crash-recovery.js

@@ -0,0 +1,123 @@
+/**
+ * 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.
+ */
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+// ── Git operations ──
+export async function getGitLog(projectDir, options = {}) {
+    const args = [
+        "log",
+        `--max-count=${options.maxCommits ?? 50}`,
+        "--pretty=format:%H|%s|%aI",
+        "--name-only",
+    ];
+    if (options.since)
+        args.push(`--since=${options.since}`);
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd: projectDir,
+            timeout: 10_000,
+        });
+        return stdout;
+    }
+    catch {
+        return "";
+    }
+}
+export async function getCurrentBranch(projectDir) {
+    try {
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd: projectDir, timeout: 5_000 });
+        return stdout.trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+// ── Parsing ──
+const CONVENTIONAL_RE = /^(feat|fix|test|refactor|docs|chore|ci|perf|style|build)(?:\(([^)]*)\))?:\s*(.+)/;
+const TASK_ID_RE = /#(\d+)|task[- ](\d+[.\d]*)/i;
+export function parseCommitPhase(message) {
+    const match = CONVENTIONAL_RE.exec(message);
+    return match ? match[1] : null;
+}
+export function extractTaskId(message) {
+    const match = TASK_ID_RE.exec(message);
+    if (match)
+        return match[1] ?? match[2] ?? null;
+    return null;
+}
+export function parseGitLog(raw) {
+    if (!raw.trim())
+        return [];
+    const tasks = [];
+    const blocks = raw.split("\n\n").filter((b) => b.trim());
+    for (const block of blocks) {
+        const lines = block.split("\n").filter((l) => l.trim());
+        if (lines.length === 0)
+            continue;
+        const headerLine = lines[0];
+        const parts = headerLine.split("|");
+        if (parts.length < 3)
+            continue;
+        const [hash, message, timestamp] = parts;
+        const filesChanged = lines.slice(1).filter((l) => !l.includes("|"));
+        tasks.push({
+            commitHash: hash.slice(0, 7),
+            message,
+            timestamp,
+            filesChanged,
+            taskId: extractTaskId(message),
+            phase: parseCommitPhase(message),
+        });
+    }
+    return tasks;
+}
+// ── Recovery ──
+export async function recoverFromGit(projectDir, options = {}) {
+    const branch = await getCurrentBranch(projectDir);
+    const raw = await getGitLog(projectDir, options);
+    const tasks = parseGitLog(raw);
+    const phases = {};
+    for (const task of tasks) {
+        if (task.phase) {
+            phases[task.phase] = (phases[task.phase] ?? 0) + 1;
+        }
+    }
+    return {
+        branch,
+        totalCommits: tasks.length,
+        tasks,
+        phases,
+        lastActivity: tasks[0]?.timestamp ?? null,
+    };
+}
+// ── Formatting ──
+export function formatRecovery(report) {
+    const lines = [];
+    lines.push(`## Crash Recovery Report`);
+    lines.push(`**Branch**: ${report.branch} | **Commits**: ${report.totalCommits}`);
+    if (report.lastActivity) {
+        lines.push(`**Last activity**: ${report.lastActivity}`);
+    }
+    lines.push("");
+    if (Object.keys(report.phases).length > 0) {
+        const phaseStr = Object.entries(report.phases)
+            .map(([p, c]) => `${p}: ${c}`)
+            .join(", ");
+        lines.push(`**Phases**: ${phaseStr}`);
+        lines.push("");
+    }
+    for (const task of report.tasks.slice(0, 10)) {
+        const tag = task.phase ? `[${task.phase}]` : "";
+        const id = task.taskId ? ` #${task.taskId}` : "";
+        lines.push(`- \`${task.commitHash}\` ${tag}${id} ${task.message} (${task.filesChanged.length} files)`);
+    }
+    if (report.totalCommits > 10) {
+        lines.push(`\n... and ${report.totalCommits - 10} more commits`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=crash-recovery.js.map

package/dist/commands/doctor.d.ts

@@ -1,5 +1,5 @@
-import type { DoctorResult } from '../types/index.js';
-export type CheckStatus = 'ok' | 'fail' | 'skip';
+import type { DoctorResult } from "../types/index.js";
+export type CheckStatus = "ok" | "fail" | "skip";
 /**
  * Run comprehensive health checks for the project and framework.
  */

package/dist/commands/doctor.js

@@ -1,15 +1,16 @@
-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 { listInstalledPlugins } from '../lib/plugin.js';
-import { FORGE_ROOT, TEMPLATES_DIR, MODULES_DIR, PLUGINS_DIR } from '../constants.js';
+import { execFile } from "child_process";
+import fs from "fs-extra";
+import path from "path";
+import { promisify } from "util";
+import { FORGE_ROOT, MODULES_DIR, PLUGINS_DIR, TEMPLATES_DIR, } from "../constants.js";
+import { detectStack } from "../lib/common.js";
+import { refreshContextDir } from "../lib/context.js";
+import { listInstalledPlugins } from "../lib/plugin.js";
 const execFileAsync = promisify(execFile);
 /** Resolve a binary name to its full path, returns null if not found */
 async function which(bin) {
     try {
-        const { stdout } = await execFileAsync('which', [bin]);
+        const { stdout } = await execFileAsync("which", [bin]);
         return stdout.trim() || null;
     }
     catch {
@@ -18,11 +19,11 @@ async function which(bin) {
 }
 /** Read the forge manifest from a project directory */
 async function readManifest(projectDir) {
-    const manifestPath = path.join(projectDir, '.javi-forge', 'manifest.json');
-    if (!await fs.pathExists(manifestPath))
+    const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
+    if (!(await fs.pathExists(manifestPath)))
         return null;
     try {
-        return await fs.readJson(manifestPath);
+        return (await fs.readJson(manifestPath));
     }
     catch {
         return null;
@@ -30,10 +31,10 @@ async function readManifest(projectDir) {
 }
 /** Count entries in a directory */
 async function countDir(dir) {
-    if (!await fs.pathExists(dir))
+    if (!(await fs.pathExists(dir)))
         return 0;
     const entries = await fs.readdir(dir);
-    return entries.filter(e => !e.startsWith('.')).length;
+    return entries.filter((e) => !e.startsWith(".")).length;
 }
 /**
  * Run comprehensive health checks for the project and framework.
@@ -44,114 +45,130 @@ export async function runDoctor(projectDir) {
     // ── 1. System Tools ────────────────────────────────────────────────────────
     const toolChecks = [];
     const tools = [
-        { name: 'git', label: 'Git' },
-        { name: 'docker', label: 'Docker' },
-        { name: 'semgrep', label: 'Semgrep' },
-        { name: 'node', label: 'Node.js' },
-        { name: 'pnpm', label: 'pnpm' },
+        { 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 = '';
+            let version = "";
             try {
-                const { stdout } = await execFileAsync(tool.name, ['--version']);
-                version = stdout.trim().split('\n')[0] ?? '';
+                const { stdout } = await execFileAsync(tool.name, ["--version"]);
+                version = stdout.trim().split("\n")[0] ?? "";
+            }
+            catch {
+                /* ignore */
             }
-            catch { /* ignore */ }
             toolChecks.push({
                 label: tool.label,
-                status: 'ok',
+                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',
+                status: tool.name === "docker" || tool.name === "semgrep" ? "skip" : "fail",
+                detail: "not found in PATH",
             });
         }
     }
-    sections.push({ title: 'System Tools', checks: toolChecks });
+    sections.push({ title: "System Tools", checks: toolChecks });
     // ── 2. Framework Structure ─────────────────────────────────────────────────
     const structureChecks = [];
     const expectedDirs = [
-        { path: TEMPLATES_DIR, label: 'templates/' },
-        { path: MODULES_DIR, label: 'modules/' },
-        { path: path.join(FORGE_ROOT, 'workflows'), label: 'workflows/' },
-        { path: path.join(FORGE_ROOT, 'ci-local'), label: 'ci-local/' },
+        { path: TEMPLATES_DIR, label: "templates/" },
+        { path: MODULES_DIR, label: "modules/" },
+        { path: path.join(FORGE_ROOT, "workflows"), label: "workflows/" },
+        { 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` });
+            structureChecks.push({
+                label: dir.label,
+                status: "ok",
+                detail: `${count} entries`,
+            });
         }
         else {
-            structureChecks.push({ label: dir.label, status: 'fail', detail: 'missing' });
+            structureChecks.push({
+                label: dir.label,
+                status: "fail",
+                detail: "missing",
+            });
         }
     }
-    sections.push({ title: 'Framework Structure', checks: structureChecks });
+    sections.push({ title: "Framework Structure", checks: structureChecks });
     // ── 3. Stack Detection ─────────────────────────────────────────────────────
     const stackChecks = [];
     const detection = await detectStack(cwd);
     if (detection) {
         stackChecks.push({
-            label: 'Detected stack',
-            status: 'ok',
-            detail: `${detection.stackType} (${detection.buildTool})${detection.javaVersion ? ` Java ${detection.javaVersion}` : ''}`,
+            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',
+            label: "Detected stack",
+            status: "skip",
+            detail: "no recognizable project files in current directory",
         });
     }
-    sections.push({ title: 'Stack Detection', checks: stackChecks });
+    sections.push({ title: "Stack Detection", checks: stackChecks });
     // ── 4. Project Manifest ────────────────────────────────────────────────────
     const manifestChecks = [];
     const manifest = await readManifest(cwd);
     if (manifest) {
         manifestChecks.push({
-            label: 'Forge manifest',
-            status: 'ok',
+            label: "Forge manifest",
+            status: "ok",
             detail: `project: ${manifest.projectName}, stack: ${manifest.stack}`,
         });
         manifestChecks.push({
-            label: 'Created',
-            status: 'ok',
-            detail: manifest.createdAt.split('T')[0],
+            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',
+            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)',
+            label: "Forge manifest",
+            status: "skip",
+            detail: "not a forge-managed project (run javi-forge init)",
         });
     }
-    sections.push({ title: 'Project Manifest', checks: manifestChecks });
+    sections.push({ title: "Project Manifest", checks: manifestChecks });
     // ── 5. Installed Modules ───────────────────────────────────────────────────
     const moduleChecks = [];
-    const moduleNames = ['engram', 'obsidian-brain', 'memory-simple', 'ghagga'];
+    const moduleNames = ["engram", "obsidian-brain", "memory-simple", "ghagga"];
     for (const mod of moduleNames) {
-        const modPath = path.join(cwd, '.javi-forge', 'modules', mod);
+        const modPath = path.join(cwd, ".javi-forge", "modules", mod);
         if (await fs.pathExists(modPath)) {
-            moduleChecks.push({ label: mod, status: 'ok', detail: 'installed' });
+            moduleChecks.push({ label: mod, status: "ok", detail: "installed" });
         }
         else {
-            moduleChecks.push({ label: mod, status: 'skip', detail: 'not installed' });
+            moduleChecks.push({
+                label: mod,
+                status: "skip",
+                detail: "not installed",
+            });
         }
     }
-    sections.push({ title: 'Installed Modules', checks: moduleChecks });
+    sections.push({ title: "Installed Modules", checks: moduleChecks });
     // ── 6. Plugins ─────────────────────────────────────────────────────────────
     const pluginChecks = [];
     const pluginsDirExists = await fs.pathExists(PLUGINS_DIR);
@@ -161,19 +178,54 @@ export async function runDoctor(projectDir) {
             for (const plugin of plugins) {
                 pluginChecks.push({
                     label: plugin.name,
-                    status: 'ok',
+                    status: "ok",
                     detail: `v${plugin.version} from ${plugin.source}`,
                 });
             }
         }
         else {
-            pluginChecks.push({ label: 'Plugins', status: 'skip', detail: 'none installed' });
+            pluginChecks.push({
+                label: "Plugins",
+                status: "skip",
+                detail: "none installed",
+            });
         }
     }
     else {
-        pluginChecks.push({ label: 'Plugins directory', status: 'skip', detail: 'not created yet' });
+        pluginChecks.push({
+            label: "Plugins directory",
+            status: "skip",
+            detail: "not created yet",
+        });
+    }
+    sections.push({ title: "Plugins", checks: pluginChecks });
+    // ── 7. Context Directory Refresh ───────────────────────────────────────────
+    const contextChecks = [];
+    try {
+        const result = await refreshContextDir(cwd);
+        if (result) {
+            contextChecks.push({
+                label: ".context/ refresh",
+                status: "ok",
+                detail: "INDEX.md + summary.md updated",
+            });
+        }
+        else {
+            contextChecks.push({
+                label: ".context/ refresh",
+                status: "skip",
+                detail: "no .context/ or no manifest found",
+            });
+        }
+    }
+    catch (e) {
+        contextChecks.push({
+            label: ".context/ refresh",
+            status: "fail",
+            detail: `refresh failed: ${String(e)}`,
+        });
     }
-    sections.push({ title: 'Plugins', checks: pluginChecks });
+    sections.push({ title: "Context Directory", checks: contextChecks });
     return { sections };
 }
 //# sourceMappingURL=doctor.js.map

package/dist/commands/harness-audit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Harness audit — scores how well-configured the AI agent development
+ * environment is (hooks, skills, memory, configs). Detects which AI
+ * agent harness is installed and generates appropriate config.
+ */
+export type Harness = "claude" | "cursor" | "codex" | "copilot" | "windsurf" | "none";
+export interface HarnessDetection {
+    harness: Harness;
+    configDir: string | null;
+    version: string | null;
+}
+export interface AuditCategory {
+    name: string;
+    score: number;
+    maxScore: number;
+    checks: AuditCheck[];
+}
+export interface AuditCheck {
+    id: string;
+    label: string;
+    passed: boolean;
+    points: number;
+    detail?: string;
+}
+export interface HarnessAuditResult {
+    harness: Harness;
+    totalScore: number;
+    maxScore: number;
+    grade: string;
+    categories: AuditCategory[];
+}
+export declare function detectHarness(projectDir: string): HarnessDetection;
+export declare function detectAllHarnesses(projectDir: string): HarnessDetection[];
+export declare function runHarnessAudit(projectDir: string): HarnessAuditResult;
+//# sourceMappingURL=harness-audit.d.ts.map