javi-forge 1.6.0 → 1.7.0

package/dist/lib/codex-export.js

@@ -1,8 +1,8 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { PLUGINS_DIR, PLUGIN_MANIFEST_FILE } from '../constants.js';
-import { parseFrontmatter } from './frontmatter.js';
-const DEFAULT_MODEL = 'o4-mini';
+import path from "node:path";
+import fs from "fs-extra";
+import { PLUGIN_MANIFEST_FILE, PLUGINS_DIR } from "../constants.js";
+import { parseFrontmatter } from "./frontmatter.js";
+const DEFAULT_MODEL = "o4-mini";
 // ── Conversion ─────────────────────────────────────────────────────────────
 /**
  * Convert a SKILL.md raw content string into a CodexTomlEntry.
@@ -12,15 +12,11 @@ export function skillToCodexToml(raw) {
     const parsed = parseFrontmatter(raw);
     if (!parsed)
         return null;
-    const name = parsed.data['name'];
-    if (typeof name !== 'string' || !name)
+    const name = parsed.data.name;
+    if (typeof name !== "string" || !name)
         return null;
-    const description = typeof parsed.data['description'] === 'string'
-        ? parsed.data['description']
-        : '';
-    const model = typeof parsed.data['model'] === 'string'
-        ? parsed.data['model']
-        : DEFAULT_MODEL;
+    const description = typeof parsed.data.description === "string" ? parsed.data.description : "";
+    const model = typeof parsed.data.model === "string" ? parsed.data.model : DEFAULT_MODEL;
     const instructions = description
         ? `${description}\n\n${parsed.content}`.trim()
         : parsed.content.trim();
@@ -39,8 +35,8 @@ export function serializeToml(entry) {
         `instructions = """`,
         escapedInstructions,
         `"""`,
-        '',
-    ].join('\n');
+        "",
+    ].join("\n");
 }
 // ── File I/O ───────────────────────────────────────────────────────────────
 /**
@@ -49,35 +45,35 @@ export function serializeToml(entry) {
  */
 export async function exportPluginAsCodexToml(name) {
     const pluginDir = path.join(PLUGINS_DIR, name);
-    if (!await fs.pathExists(pluginDir)) {
+    if (!(await fs.pathExists(pluginDir))) {
         return { success: false, error: `plugin "${name}" is not installed` };
     }
     // Read plugin manifest for skill list
     const manifestPath = path.join(pluginDir, PLUGIN_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) {
-        return { success: false, error: 'plugin.json not found' };
+    if (!(await fs.pathExists(manifestPath))) {
+        return { success: false, error: "plugin.json not found" };
     }
     let manifest;
     try {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     catch {
-        return { success: false, error: 'invalid plugin.json' };
+        return { success: false, error: "invalid plugin.json" };
     }
     const skillNames = manifest.skills ?? [];
     if (skillNames.length === 0) {
-        return { success: false, error: 'plugin has no skills to export' };
+        return { success: false, error: "plugin has no skills to export" };
     }
-    const codexDir = path.join(pluginDir, 'codex');
+    const codexDir = path.join(pluginDir, "codex");
     await fs.ensureDir(codexDir);
     const writtenFiles = [];
     for (const skillName of skillNames) {
-        const skillPath = path.join(pluginDir, 'skills', skillName, 'SKILL.md');
-        if (!await fs.pathExists(skillPath))
+        const skillPath = path.join(pluginDir, "skills", skillName, "SKILL.md");
+        if (!(await fs.pathExists(skillPath)))
             continue;
         let raw;
         try {
-            raw = await fs.readFile(skillPath, 'utf-8');
+            raw = await fs.readFile(skillPath, "utf-8");
         }
         catch {
             continue;
@@ -87,25 +83,23 @@ export async function exportPluginAsCodexToml(name) {
             continue;
         const toml = serializeToml(entry);
         const outPath = path.join(codexDir, `${skillName}.toml`);
-        await fs.writeFile(outPath, toml, 'utf-8');
+        await fs.writeFile(outPath, toml, "utf-8");
         writtenFiles.push(outPath);
     }
     if (writtenFiles.length === 0) {
-        return { success: false, error: 'no skills with valid frontmatter found' };
+        return { success: false, error: "no skills with valid frontmatter found" };
     }
     return { success: true, files: writtenFiles };
 }
 // ── Helpers ────────────────────────────────────────────────────────────────
 function escapeTomlString(value) {
     return value
-        .replace(/\\/g, '\\\\')
+        .replace(/\\/g, "\\\\")
         .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n');
+        .replace(/\n/g, "\\n");
 }
 function escapeTomlMultiline(value) {
     // In TOML multiline basic strings ("""), only backslashes and triple quotes need escaping
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"""/g, '"\\"\"');
+    return value.replace(/\\/g, "\\\\").replace(/"""/g, '"\\""');
 }
 //# sourceMappingURL=codex-export.js.map

package/dist/lib/common.d.ts

@@ -1,4 +1,4 @@
-import type { Stack, StackDetection } from '../types/index.js';
+import type { Stack, StackDetection } from "../types/index.js";
 /**
  * Detect the project stack by looking for well-known build/config files.
  * Returns the first match (precedence order matters).

package/dist/lib/common.js

@@ -1,5 +1,5 @@
-import fs from 'fs-extra';
-import path from 'path';
+import path from "node:path";
+import fs from "fs-extra";
 /**
  * Detect the project stack by looking for well-known build/config files.
  * Returns the first match (precedence order matters).
@@ -7,70 +7,78 @@ import path from 'path';
 export async function detectStack(projectDir) {
     const exists = async (file) => fs.pathExists(path.join(projectDir, file));
     // Java — Gradle
-    if (await exists('build.gradle') || await exists('build.gradle.kts')) {
+    if ((await exists("build.gradle")) || (await exists("build.gradle.kts"))) {
         const javaVersion = await detectJavaVersion(projectDir);
-        return { stackType: 'java-gradle', buildTool: 'gradle', javaVersion };
+        return { stackType: "java-gradle", buildTool: "gradle", javaVersion };
     }
     // Java — Maven
-    if (await exists('pom.xml')) {
+    if (await exists("pom.xml")) {
         const javaVersion = await detectJavaVersion(projectDir);
-        return { stackType: 'java-maven', buildTool: 'maven', javaVersion };
+        return { stackType: "java-maven", buildTool: "maven", javaVersion };
     }
     // Node.js
-    if (await exists('package.json')) {
-        const pkg = await fs.readJson(path.join(projectDir, 'package.json')).catch(() => ({}));
-        const buildTool = await exists('pnpm-lock.yaml') ? 'pnpm'
-            : await exists('yarn.lock') ? 'yarn'
-                : 'npm';
-        return { stackType: 'node', buildTool };
+    if (await exists("package.json")) {
+        const _pkg = await fs
+            .readJson(path.join(projectDir, "package.json"))
+            .catch(() => ({}));
+        const buildTool = (await exists("pnpm-lock.yaml"))
+            ? "pnpm"
+            : (await exists("yarn.lock"))
+                ? "yarn"
+                : "npm";
+        return { stackType: "node", buildTool };
     }
     // Python
-    if (await exists('pyproject.toml') || await exists('requirements.txt') || await exists('setup.py')) {
-        const buildTool = await exists('pyproject.toml') ? 'pyproject'
-            : await exists('Pipfile') ? 'pipenv'
-                : 'pip';
-        return { stackType: 'python', buildTool };
+    if ((await exists("pyproject.toml")) ||
+        (await exists("requirements.txt")) ||
+        (await exists("setup.py"))) {
+        const buildTool = (await exists("pyproject.toml"))
+            ? "pyproject"
+            : (await exists("Pipfile"))
+                ? "pipenv"
+                : "pip";
+        return { stackType: "python", buildTool };
     }
     // Go
-    if (await exists('go.mod')) {
-        return { stackType: 'go', buildTool: 'go' };
+    if (await exists("go.mod")) {
+        return { stackType: "go", buildTool: "go" };
     }
     // Rust
-    if (await exists('Cargo.toml')) {
-        return { stackType: 'rust', buildTool: 'cargo' };
+    if (await exists("Cargo.toml")) {
+        return { stackType: "rust", buildTool: "cargo" };
     }
     // Elixir
-    if (await exists('mix.exs')) {
-        return { stackType: 'elixir', buildTool: 'mix' };
+    if (await exists("mix.exs")) {
+        return { stackType: "elixir", buildTool: "mix" };
     }
     return null;
 }
 /** Try to detect Java version from gradle or maven config */
 async function detectJavaVersion(projectDir) {
     // Try build.gradle
-    const gradleFile = path.join(projectDir, 'build.gradle');
+    const gradleFile = path.join(projectDir, "build.gradle");
     if (await fs.pathExists(gradleFile)) {
-        const content = await fs.readFile(gradleFile, 'utf-8');
-        const match = content.match(/sourceCompatibility\s*=\s*['"]?(\d+)/)
-            || content.match(/JavaVersion\.VERSION_(\d+)/);
+        const content = await fs.readFile(gradleFile, "utf-8");
+        const match = content.match(/sourceCompatibility\s*=\s*['"]?(\d+)/) ||
+            content.match(/JavaVersion\.VERSION_(\d+)/);
         if (match)
             return match[1];
     }
     // Try build.gradle.kts
-    const ktsFile = path.join(projectDir, 'build.gradle.kts');
+    const ktsFile = path.join(projectDir, "build.gradle.kts");
     if (await fs.pathExists(ktsFile)) {
-        const content = await fs.readFile(ktsFile, 'utf-8');
-        const match = content.match(/jvmTarget\s*=\s*['"](\d+)['"]/)
-            || content.match(/JavaVersion\.VERSION_(\d+)/);
+        const content = await fs.readFile(ktsFile, "utf-8");
+        const match = content.match(/jvmTarget\s*=\s*['"](\d+)['"]/) ||
+            content.match(/JavaVersion\.VERSION_(\d+)/);
         if (match)
             return match[1];
     }
     // Try pom.xml
-    const pomFile = path.join(projectDir, 'pom.xml');
+    const pomFile = path.join(projectDir, "pom.xml");
     if (await fs.pathExists(pomFile)) {
-        const content = await fs.readFile(pomFile, 'utf-8');
-        const match = content.match(/<java\.version>(\d+)</)
-            || content.match(/<maven\.compiler\.source>(\d+)</);
+        const content = await fs.readFile(pomFile, "utf-8");
+        const match = content.match(/<java\.version>(\d+)</) ||
+            content.match(/<maven\.compiler\.source>(\d+)</);
         if (match)
             return match[1];
     }
@@ -90,22 +98,22 @@ export async function ensureDirExists(dirPath) {
 }
 /** Check if a directory is a git repository */
 export async function isGitRepo(dir) {
-    return fs.pathExists(path.join(dir, '.git'));
+    return fs.pathExists(path.join(dir, ".git"));
 }
 /** Resolve the forge assets root (the package root directory) */
 export function getForgeRoot() {
     // When running from dist/, go up one level
     const thisDir = path.dirname(new URL(import.meta.url).pathname);
-    return path.resolve(thisDir, '..');
+    return path.resolve(thisDir, "..");
 }
 /** Stack display names */
 export const STACK_LABELS = {
-    'node': 'Node.js / TypeScript',
-    'python': 'Python',
-    'go': 'Go',
-    'rust': 'Rust',
-    'java-gradle': 'Java (Gradle)',
-    'java-maven': 'Java (Maven)',
-    'elixir': 'Elixir',
+    node: "Node.js / TypeScript",
+    python: "Python",
+    go: "Go",
+    rust: "Rust",
+    "java-gradle": "Java (Gradle)",
+    "java-maven": "Java (Maven)",
+    elixir: "Elixir",
 };
 //# sourceMappingURL=common.js.map

package/dist/lib/context.d.ts

@@ -1,6 +1,11 @@
-import type { InitOptions, StackContextEntry } from '../types/index.js';
+import type { InitOptions, StackContextEntry } from "../types/index.js";
 export declare function buildIndexMd(projectName: string, stackCtx: StackContextEntry, ciProvider: string, memory: string): string;
-export declare function buildSummaryMd(projectName: string, stack: string, ciProvider: string, memory: string, modules: string[]): string;
+export declare function buildSummaryMd(projectName: string, stack: string, ciProvider: string, memory: string, modules: string[], dependencies?: string[]): string;
+/**
+ * Detect top-level dependencies from project manifest files.
+ * Returns up to 10 dependency names (key deps only, not devDeps).
+ */
+export declare function detectDependencies(projectDir: string, stack: string): Promise<string[]>;
 /**
  * Generate .context/ directory content from InitOptions metadata.
  * Pure function — does NOT perform filesystem I/O.
@@ -9,4 +14,14 @@ export declare function generateContextDir(options: InitOptions): Promise<{
     index: string;
     summary: string;
 }>;
+/**
+ * Refresh .context/ directory from the forge manifest and live project state.
+ * Reads manifest, detects current dependencies, regenerates INDEX.md + summary.md.
+ * Returns null if the project is not forge-managed or has no .context/ dir.
+ */
+export declare function refreshContextDir(projectDir: string): Promise<{
+    index: string;
+    summary: string;
+    updated: boolean;
+} | null>;
 //# sourceMappingURL=context.d.ts.map

package/dist/lib/context.js

@@ -1,14 +1,16 @@
-import { STACK_CONTEXT_MAP } from '../constants.js';
+import path from "node:path";
+import fs from "fs-extra";
+import { STACK_CONTEXT_MAP } from "../constants.js";
 // =============================================================================
 // Internal helpers
 // =============================================================================
 function getStackContext(stack) {
-    return STACK_CONTEXT_MAP[stack] ?? STACK_CONTEXT_MAP['default'];
+    return STACK_CONTEXT_MAP[stack] ?? STACK_CONTEXT_MAP.default;
 }
 export function buildIndexMd(projectName, stackCtx, ciProvider, memory) {
-    return `# ${projectName} — File Index
+    return `# ${projectName} — Project Index
 
-## Directory Structure
+## Structure
 
 \`\`\`
 ${stackCtx.tree}
@@ -20,13 +22,14 @@ ${stackCtx.tree}
 
 ## Conventions
 
-- **Stack conventions**: ${stackCtx.conventions}
+- **Stack**: ${stackCtx.conventions}
 - **CI**: ${ciProvider}
 - **Memory**: ${memory}
 `;
 }
-export function buildSummaryMd(projectName, stack, ciProvider, memory, modules) {
-    const modulesList = modules.length > 0 ? modules.join(', ') : 'none';
+export function buildSummaryMd(projectName, stack, ciProvider, memory, modules, dependencies = []) {
+    const modulesList = modules.length > 0 ? modules.join(", ") : "none";
+    const depsList = dependencies.length > 0 ? dependencies.join(", ") : "none detected";
     return `# ${projectName}
 
 ## Overview
@@ -35,10 +38,11 @@ ${stack}-based project scaffolded with javi-forge.
 
 ## Stack
 
-- **Language/Runtime**: ${stack}
+- **Runtime**: ${stack}
 - **CI**: ${ciProvider}
 - **Memory**: ${memory}
 - **Modules**: ${modulesList}
+- **Dependencies**: ${depsList}
 
 ## Key Decisions
 
@@ -47,6 +51,99 @@ ${stack}-based project scaffolded with javi-forge.
 `;
 }
 // =============================================================================
+// Dependency detection
+// =============================================================================
+/**
+ * Detect top-level dependencies from project manifest files.
+ * Returns up to 10 dependency names (key deps only, not devDeps).
+ */
+export async function detectDependencies(projectDir, stack) {
+    const MAX_DEPS = 10;
+    try {
+        switch (stack) {
+            case "node": {
+                const pkgPath = path.join(projectDir, "package.json");
+                if (!(await fs.pathExists(pkgPath)))
+                    return [];
+                const pkg = await fs.readJson(pkgPath).catch(() => ({}));
+                const deps = Object.keys(pkg.dependencies ?? {});
+                return deps.slice(0, MAX_DEPS);
+            }
+            case "python": {
+                const pyprojectPath = path.join(projectDir, "pyproject.toml");
+                if (await fs.pathExists(pyprojectPath)) {
+                    const content = await fs.readFile(pyprojectPath, "utf-8");
+                    const match = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+                    if (match?.[1]) {
+                        const deps = match[1]
+                            .split("\n")
+                            .map((l) => l.replace(/[",]/g, "").trim())
+                            .filter((l) => l.length > 0 && !l.startsWith("#"))
+                            .map((l) => l.split(/[>=<~!]/)[0].trim())
+                            .filter(Boolean);
+                        return deps.slice(0, MAX_DEPS);
+                    }
+                }
+                const reqPath = path.join(projectDir, "requirements.txt");
+                if (await fs.pathExists(reqPath)) {
+                    const content = await fs.readFile(reqPath, "utf-8");
+                    const deps = content
+                        .split("\n")
+                        .map((l) => l.trim())
+                        .filter((l) => l.length > 0 && !l.startsWith("#") && !l.startsWith("-"))
+                        .map((l) => l.split(/[>=<~!]/)[0].trim())
+                        .filter(Boolean);
+                    return deps.slice(0, MAX_DEPS);
+                }
+                return [];
+            }
+            case "go": {
+                const goModPath = path.join(projectDir, "go.mod");
+                if (!(await fs.pathExists(goModPath)))
+                    return [];
+                const content = await fs.readFile(goModPath, "utf-8");
+                const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
+                if (requireBlock?.[1]) {
+                    const deps = requireBlock[1]
+                        .split("\n")
+                        .map((l) => l.trim())
+                        .filter((l) => l.length > 0 && !l.startsWith("//"))
+                        .map((l) => {
+                        const parts = l.split(/\s+/);
+                        const mod = parts[0] ?? "";
+                        return mod.split("/").pop() ?? mod;
+                    })
+                        .filter(Boolean);
+                    return deps.slice(0, MAX_DEPS);
+                }
+                return [];
+            }
+            case "rust": {
+                const cargoPath = path.join(projectDir, "Cargo.toml");
+                if (!(await fs.pathExists(cargoPath)))
+                    return [];
+                const content = await fs.readFile(cargoPath, "utf-8");
+                const depsSection = content.match(/\[dependencies\]([\s\S]*?)(?=\n\[|$)/);
+                if (depsSection?.[1]) {
+                    const deps = depsSection[1]
+                        .split("\n")
+                        .map((l) => l.trim())
+                        .filter((l) => l.length > 0 && !l.startsWith("#"))
+                        .map((l) => l.split(/\s*=/)[0].trim())
+                        .filter(Boolean);
+                    return deps.slice(0, MAX_DEPS);
+                }
+                return [];
+            }
+            default:
+                return [];
+        }
+    }
+    catch {
+        return [];
+    }
+}
+// =============================================================================
 // Public API
 // =============================================================================
 /**
@@ -59,17 +156,49 @@ export async function generateContextDir(options) {
     // Collect enabled modules for summary
     const modules = [];
     if (options.aiSync)
-        modules.push('ai-sync');
+        modules.push("ai-sync");
     if (options.sdd)
-        modules.push('sdd');
+        modules.push("sdd");
     if (options.ghagga)
-        modules.push('ghagga');
+        modules.push("ghagga");
     if (options.mock)
-        modules.push('mock');
+        modules.push("mock");
     if (options.contextDir)
-        modules.push('context');
+        modules.push("context");
     const index = buildIndexMd(projectName, stackCtx, ciProvider, memory);
     const summary = buildSummaryMd(projectName, stack, ciProvider, memory, modules);
     return { index, summary };
 }
+/**
+ * Refresh .context/ directory from the forge manifest and live project state.
+ * Reads manifest, detects current dependencies, regenerates INDEX.md + summary.md.
+ * Returns null if the project is not forge-managed or has no .context/ dir.
+ */
+export async function refreshContextDir(projectDir) {
+    const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
+    const contextDirPath = path.join(projectDir, ".context");
+    // Only refresh if forge-managed and .context/ exists
+    if (!(await fs.pathExists(manifestPath)) ||
+        !(await fs.pathExists(contextDirPath))) {
+        return null;
+    }
+    let manifest;
+    try {
+        manifest = (await fs.readJson(manifestPath));
+    }
+    catch {
+        return null;
+    }
+    const stackCtx = getStackContext(manifest.stack);
+    const dependencies = await detectDependencies(projectDir, manifest.stack);
+    const index = buildIndexMd(manifest.projectName, stackCtx, manifest.ciProvider, manifest.memory);
+    const summary = buildSummaryMd(manifest.projectName, manifest.stack, manifest.ciProvider, manifest.memory, manifest.modules, dependencies);
+    // Write updated files
+    await fs.writeFile(path.join(contextDirPath, "INDEX.md"), index, "utf-8");
+    await fs.writeFile(path.join(contextDirPath, "summary.md"), summary, "utf-8");
+    // Update manifest timestamp
+    manifest.updatedAt = new Date().toISOString();
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+    return { index, summary, updated: true };
+}
 //# sourceMappingURL=context.js.map

package/dist/lib/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