jfl 0.5.0 → 0.6.0

package/dist/commands/context-hub.d.ts

@@ -17,5 +17,6 @@ export declare function contextHubCommand(action?: string, options?: {
     port?: number;
     global?: boolean;
     quiet?: boolean;
+    projectRoot?: string;
 }): Promise<void>;
 //# sourceMappingURL=context-hub.d.ts.map

package/dist/commands/context-hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-hub.d.ts","sourceRoot":"","sources":["../../src/commands/context-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAguEH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBjF;AAkMD,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAiHxF;AAMD,wBAAsB,iBAAiB,CACrC,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,iBA8lBnE"}
+{"version":3,"file":"context-hub.d.ts","sourceRoot":"","sources":["../../src/commands/context-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAy9EH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBjF;AAkMD,wBAAsB,qBAAqB,CAAC,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAiHxF;AAMD,wBAAsB,iBAAiB,CACrC,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,iBA8lBzF"}

package/dist/commands/context-hub.js

@@ -547,6 +547,20 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             res.end(JSON.stringify({ status: "ok", port }));
             return;
         }
+        // Setup report — serves .jfl/setup-report.json for dashboard consumption
+        if (url.pathname === "/api/setup-report" && req.method === "GET") {
+            const reportPath = path.join(projectRoot, ".jfl", "setup-report.json");
+            if (fs.existsSync(reportPath)) {
+                const report = fs.readFileSync(reportPath, "utf-8");
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(report);
+            }
+            else {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No setup report. Run: jfl setup" }));
+            }
+            return;
+        }
         // Dashboard - served without API auth (has its own token flow in JS)
         if (url.pathname.startsWith("/dashboard")) {
             import("../dashboard/index.js").then(({ handleDashboardRoutes }) => {
@@ -1785,6 +1799,236 @@ function createServer(projectRoot, port, eventBus, flowEngine) {
             });
             return;
         }
+        // ── Session Parity API ────────────────────────────────────────────
+        // These endpoints provide runtime-agnostic session lifecycle.
+        // Both Claude Code hooks and Pi extensions call these instead of
+        // duplicating logic. Single source of truth for session init/end.
+        // POST /api/session/init — sync repos, create branch, run doctor
+        if (url.pathname === "/api/session/init" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { runtime } = JSON.parse(body || "{}");
+                    const warnings = [];
+                    const scriptDir = path.join(projectRoot, "scripts", "session");
+                    // Step 1: Sync repos
+                    const syncScript = path.join(scriptDir, "session-sync.sh");
+                    let syncOk = true;
+                    if (fs.existsSync(syncScript)) {
+                        try {
+                            execSync(`bash "${syncScript}"`, { cwd: projectRoot, timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        catch (err) {
+                            syncOk = false;
+                            warnings.push(`Sync warning: ${(err.message || "").split("\n")[0]}`);
+                        }
+                    }
+                    // Step 2: Doctor check
+                    const doctorScript = path.join(scriptDir, "jfl-doctor.sh");
+                    let doctorErrors = 0;
+                    let doctorWarnings = 0;
+                    if (fs.existsSync(doctorScript)) {
+                        try {
+                            const doctorOut = execSync(`bash "${doctorScript}"`, { cwd: projectRoot, timeout: 30000, stdio: ["pipe", "pipe", "pipe"] }).toString();
+                            const em = doctorOut.match(/(\d+) error\(s\)/);
+                            const wm = doctorOut.match(/(\d+) warning\(s\)/);
+                            doctorErrors = em ? parseInt(em[1]) : 0;
+                            doctorWarnings = wm ? parseInt(wm[1]) : 0;
+                            if (doctorErrors > 0)
+                                warnings.push(`Doctor: ${doctorErrors} errors`);
+                        }
+                        catch { }
+                    }
+                    // Step 3: Create session branch
+                    let currentBranch = "";
+                    try {
+                        currentBranch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                    }
+                    catch { }
+                    let sessionBranch = currentBranch;
+                    if (!currentBranch.startsWith("session-")) {
+                        const user = (() => {
+                            try {
+                                return execSync("git config user.name", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] })
+                                    .toString().trim().replace(/\s+/g, "-").toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 30) || "user";
+                            }
+                            catch {
+                                return "user";
+                            }
+                        })();
+                        const now = new Date();
+                        const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
+                        const timeStr = now.toISOString().slice(11, 16).replace(":", "");
+                        const randomId = Math.random().toString(16).slice(2, 8);
+                        sessionBranch = `session-${user}-${dateStr}-${timeStr}-${randomId}`;
+                        try {
+                            execSync(`git checkout -b "${sessionBranch}"`, { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        catch {
+                            sessionBranch = currentBranch || "main";
+                            warnings.push("Could not create session branch");
+                        }
+                    }
+                    // Step 4: Save session info
+                    const jflDir = path.join(projectRoot, ".jfl");
+                    fs.mkdirSync(path.join(jflDir, "logs"), { recursive: true });
+                    fs.mkdirSync(path.join(jflDir, "journal"), { recursive: true });
+                    fs.writeFileSync(path.join(jflDir, "current-session-branch.txt"), sessionBranch);
+                    fs.writeFileSync(path.join(jflDir, "current-worktree.txt"), "direct");
+                    // Emit session start event
+                    if (eventBus) {
+                        eventBus.emit({
+                            type: "session:started",
+                            source: `hub:${runtime || "unknown"}`,
+                            data: { branch: sessionBranch, runtime, warnings },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        ok: true,
+                        branch: sessionBranch,
+                        syncOk,
+                        doctor: { errors: doctorErrors, warnings: doctorWarnings },
+                        warnings,
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/prompt — get system prompt injection (CLAUDE.md + context)
+        if (url.pathname === "/api/prompt" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { taskType, maxItems } = JSON.parse(body || "{}");
+                    const parts = [];
+                    // 1. Load CLAUDE.md
+                    const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
+                    if (fs.existsSync(claudeMdPath)) {
+                        const content = fs.readFileSync(claudeMdPath, "utf-8");
+                        if (content.length > 50000) {
+                            const sections = content.split(/^## /m);
+                            const critical = sections.filter((s) => /CRITICAL|Session Sync|Journal Protocol|Immediate Decision|Working Mode|Core Architecture/i.test(s.slice(0, 100)));
+                            if (critical.length > 0) {
+                                parts.push("# Project Instructions (CLAUDE.md — critical sections)\n");
+                                parts.push("## " + critical.join("\n\n## "));
+                            }
+                            else {
+                                parts.push("# Project Instructions (CLAUDE.md — truncated)\n");
+                                parts.push(content.slice(0, 30000));
+                            }
+                        }
+                        else {
+                            parts.push("# Project Instructions (CLAUDE.md)\n");
+                            parts.push(content);
+                        }
+                    }
+                    // 2. Load recent context
+                    try {
+                        const contextItems = readJournalEntries(projectRoot, maxItems ?? 20);
+                        if (contextItems.length > 0) {
+                            parts.push("\n## Recent Project Context\n");
+                            parts.push(contextItems.map(item => {
+                                const prefix = item.source ? `[${item.source}] ` : "";
+                                return `${prefix}${item.content}`;
+                            }).join("\n\n"));
+                        }
+                    }
+                    catch { }
+                    // 3. Load knowledge docs summaries
+                    const knowledgeDir = path.join(projectRoot, "knowledge");
+                    if (fs.existsSync(knowledgeDir)) {
+                        const knowledgeDocs = ["VISION.md", "ROADMAP.md", "NARRATIVE.md", "THESIS.md"];
+                        const summaries = [];
+                        for (const doc of knowledgeDocs) {
+                            const docPath = path.join(knowledgeDir, doc);
+                            if (fs.existsSync(docPath)) {
+                                const content = fs.readFileSync(docPath, "utf-8");
+                                if (content.length > 100) {
+                                    summaries.push(`### ${doc}\n${content.slice(0, 500)}${content.length > 500 ? "\n..." : ""}`);
+                                }
+                            }
+                        }
+                        if (summaries.length > 0) {
+                            parts.push("\n## Knowledge Documents\n");
+                            parts.push(summaries.join("\n\n"));
+                        }
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        prompt: parts.join("\n"),
+                        claudeMdSize: fs.existsSync(path.join(projectRoot, "CLAUDE.md"))
+                            ? fs.statSync(path.join(projectRoot, "CLAUDE.md")).size : 0,
+                        taskType: taskType ?? "general",
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
+        // POST /api/session/end — cleanup session (merge, commit, etc)
+        if (url.pathname === "/api/session/end" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => body += chunk);
+            req.on("end", async () => {
+                try {
+                    const { runtime, skipCleanup } = JSON.parse(body || "{}");
+                    // Check journal exists
+                    let hasJournal = false;
+                    try {
+                        const branch = execSync("git branch --show-current", { cwd: projectRoot, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+                        const journalPath = path.join(projectRoot, ".jfl", "journal", `${branch}.jsonl`);
+                        hasJournal = fs.existsSync(journalPath) && fs.statSync(journalPath).size > 0;
+                    }
+                    catch { }
+                    let cleanupResult = "skipped";
+                    if (!skipCleanup) {
+                        const cleanupScript = path.join(projectRoot, "scripts", "session", "session-cleanup.sh");
+                        if (fs.existsSync(cleanupScript)) {
+                            try {
+                                execSync(`bash "${cleanupScript}"`, { cwd: projectRoot, timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+                                cleanupResult = "ok";
+                            }
+                            catch (err) {
+                                cleanupResult = `error: ${(err.message || "").split("\n")[0]}`;
+                            }
+                        }
+                        else {
+                            cleanupResult = "no cleanup script";
+                        }
+                    }
+                    // Emit session end event
+                    if (eventBus) {
+                        eventBus.emit({
+                            type: "session:ended",
+                            source: `hub:${runtime || "unknown"}`,
+                            data: { hasJournal, cleanupResult, runtime },
+                        });
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        ok: true,
+                        hasJournal,
+                        cleanupResult,
+                        warnings: hasJournal ? [] : ["No journal entry for this session"],
+                    }));
+                }
+                catch (err) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+            return;
+        }
         // ── Findings API ──────────────────────────────────────────────────
         // GET /api/v1/findings — list current findings
         if (url.pathname === "/api/v1/findings" && req.method === "GET") {
@@ -2060,7 +2304,7 @@ async function startDaemon(projectRoot, port) {
     }
     // Start as detached process with CONTEXT_HUB_DAEMON=1 so the serve
     // action knows to ignore SIGTERM during its startup grace period
-    const child = spawn(jflCmd, ["context-hub", "serve", "--port", String(port)], {
+    const child = spawn(jflCmd, ["context-hub", "serve", "--port", String(port), "--project-root", projectRoot], {
         cwd: projectRoot,
         detached: true,
         stdio: ["ignore", fs.openSync(logFile, "a"), fs.openSync(logFile, "a")],
@@ -2245,7 +2489,7 @@ export async function ensureDaemonInstalled(opts) {
 // ============================================================================
 export async function contextHubCommand(action, options = {}) {
     const isGlobal = options.global || false;
-    const projectRoot = isGlobal ? homedir() : process.cwd();
+    const projectRoot = options.projectRoot || (isGlobal ? homedir() : process.cwd());
     const port = options.port || getProjectPort(projectRoot);
     // Ensure directories exist (skip for actions that don't need local project root)
     const globalActions = ["ensure-all", "doctor", "install-daemon", "uninstall-daemon"];