jfl 0.9.1 → 0.9.3

package/packages/pi/extensions/journal.ts

@@ -12,7 +12,7 @@ import { existsSync, readFileSync, appendFileSync, mkdirSync } from "fs"
 import { join } from "path"
 import { execSync } from "child_process"
 import type { PiContext, PiTheme, JflConfig, AgentEndEvent, ToolExecutionEvent } from "./types.js"
-import { getCurrentBranch } from "./session.js"
+import { getCurrentBranch, getSessionBranch } from "./session.js"
 import { emitCustomEvent } from "./map-bridge.js"
 
 let projectRoot = ""
@@ -33,7 +33,9 @@ interface JournalEntry {
 }
 
 function getJournalPath(root: string): string {
-  const branch = getCurrentBranch(root)
+  // Prefer the session branch tracked by session.ts — git HEAD may differ
+  // if checkout failed due to dirty working tree
+  const branch = getSessionBranch() || getCurrentBranch(root)
   return join(root, ".jfl", "journal", `${branch}.jsonl`)
 }
 
@@ -57,7 +59,7 @@ function readRecentEntries(root: string, count = 5): JournalEntry[] {
   }
 }
 
-function hasJournalEntryForSession(root: string, sessionBranch: string): boolean {
+export function hasJournalEntryForSession(root: string, sessionBranch: string): boolean {
   const journalPath = join(root, ".jfl", "journal", `${sessionBranch}.jsonl`)
   if (!existsSync(journalPath)) return false
   const content = readFileSync(journalPath, "utf-8").trim()
@@ -117,7 +119,7 @@ export async function setupJournal(ctx: PiContext, _config: JflConfig): Promise<
         const entry: JournalEntry = {
           v: 1,
           ts: new Date().toISOString(),
-          session: getCurrentBranch(projectRoot),
+          session: getSessionBranch() || getCurrentBranch(projectRoot),
           type,
           status: "complete",
           title: title.trim(),
@@ -134,7 +136,7 @@ export async function setupJournal(ctx: PiContext, _config: JflConfig): Promise<
       }
 
       // Fallback: raw JSON input for non-interactive mode
-      const branch = getCurrentBranch(projectRoot)
+      const branch = getSessionBranch() || getCurrentBranch(projectRoot)
       const template = JSON.stringify({
         v: 1,
         ts: new Date().toISOString(),
@@ -172,6 +174,21 @@ export async function onToolExecutionEnd(
   event: ToolExecutionEvent
 ): Promise<void> {
   const toolName = event.toolName ?? event.tool ?? ""
+
+  // TaskUpdate completed → journal nudge (parity with CC PostToolUse hook)
+  if (toolName === "TaskUpdate") {
+    const input = event.input ?? event.args ?? {}
+    const inputStr = typeof input === "string" ? input : JSON.stringify(input)
+    if (/"status"\s*:\s*"completed"/.test(inputStr)) {
+      const branch = getCurrentBranch(projectRoot)
+      ctx.ui.notify(
+        `Task completed — write journal entry\nFile: .jfl/journal/${branch}.jsonl`,
+        { level: "info" }
+      )
+    }
+    return
+  }
+
   if (toolName.toLowerCase() !== "bash") return
 
   const result = String(event.result ?? "")
@@ -202,10 +219,78 @@ export async function onJournalAgentEnd(
   // Removed: "Journal entry recommended" nudge (noisy)
 }
 
+/**
+ * Check @purpose header on Write/Edit to code files.
+ * Equivalent to Claude Code's PostToolUse(Write|Edit) hook.
+ */
+export function checkPurposeHeader(
+  ctx: PiContext,
+  event: ToolExecutionEvent
+): void {
+  const toolName = (event.toolName ?? event.tool ?? "").toLowerCase()
+  if (toolName !== "write" && toolName !== "edit") return
+
+  // Extract file path from tool input
+  const input = event.input ?? event.args ?? {}
+  const filePath = typeof input === "string"
+    ? input
+    : (input as any).path ?? (input as any).file_path ?? ""
+
+  if (!filePath) return
+  if (!/\.(ts|tsx|js|jsx)$/.test(filePath)) return
+
+  const fullPath = filePath.startsWith("/") ? filePath : join(projectRoot, filePath)
+  if (!existsSync(fullPath)) return
+
+  try {
+    const head = readFileSync(fullPath, "utf-8").slice(0, 800)
+    if (!head.includes("@purpose")) {
+      ctx.ui.notify(
+        `⚠️ Missing @purpose header in ${filePath}\n   Add: /** @purpose One-line description */`,
+        { level: "warn" }
+      )
+    }
+  } catch {}
+}
+
+/**
+ * Auto-commit changes before context compaction.
+ * Equivalent to Claude Code's PreCompact hook that runs:
+ *   git add knowledge/ previews/ content/ suggestions/ .jfl/ && git commit
+ */
+function autoCommitBeforeCompact(ctx: PiContext): void {
+  const trackedDirs = ["knowledge", "previews", "content", "suggestions", ".jfl", "CLAUDE.md"]
+  const addPaths = trackedDirs
+    .filter((d) => existsSync(join(projectRoot, d)))
+    .join(" ")
+
+  if (!addPaths) return
+
+  try {
+    const status = execSync(`git status --porcelain -- ${addPaths}`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+    }).trim()
+
+    if (!status) return // nothing to commit
+
+    execSync(`git add ${addPaths} && git commit -m "auto-commit: pre-compact save"`, {
+      cwd: projectRoot,
+      stdio: "pipe",
+    })
+    ctx.log("Pre-compact auto-commit saved changes", "debug")
+  } catch {
+    // Not critical — auto-commit daemon is the primary safety net
+  }
+}
+
 export async function checkJournalBeforeCompact(
   ctx: PiContext
 ): Promise<{ cancel: true } | void> {
-  const branch = getCurrentBranch(projectRoot)
+  // Auto-commit changes before compaction (safety net)
+  autoCommitBeforeCompact(ctx)
+
+  const branch = getSessionBranch() || getCurrentBranch(projectRoot)
   if (!hasJournalEntryForSession(projectRoot, branch)) {
     if (ctx.ui.hasUI) {
       const ok = await ctx.ui.confirm(

package/packages/pi/extensions/map-bridge.ts

@@ -143,6 +143,37 @@ export async function setupMapBridge(ctx: PiContext, config: JflConfig): Promise
     if (port) hubUrl = `http://localhost:${port}`
   }
 
+  // Verify the hub is actually reachable on this port.
+  // If not, try discovering the real port from the running process.
+  try {
+    const healthResp = await fetch(`${hubUrl}/health`, { signal: AbortSignal.timeout(3000) })
+    if (!healthResp.ok) throw new Error("unhealthy")
+  } catch {
+    ctx.log(`Hub unreachable at ${hubUrl}, attempting port discovery...`, "warn")
+    // Try to find the actual port from the running hub process
+    try {
+      const { execSync } = await import("child_process")
+      const psOut = execSync(
+        `ps aux | grep "context-hub serve.*--project-root ${root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}" | grep -v grep`,
+        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim()
+      const portMatch = psOut.match(/--port\s+(\d+)/)
+      if (portMatch) {
+        const discoveredPort = portMatch[1]
+        const testResp = await fetch(`http://localhost:${discoveredPort}/health`, { signal: AbortSignal.timeout(3000) })
+        if (testResp.ok) {
+          hubUrl = `http://localhost:${discoveredPort}`
+          // Fix the stale port file
+          const { writeFileSync } = await import("fs")
+          writeFileSync(join(root, ".jfl", "context-hub.port"), discoveredPort)
+          ctx.log(`Hub discovered on port ${discoveredPort} — fixed stale port file`, "warn")
+        }
+      }
+    } catch {
+      ctx.log("Hub port discovery failed — hub tools will be unavailable", "warn")
+    }
+  }
+
   ctx.on("hook:session-start", (data) => postToHub({ type: "hook:session-start", source: "pi-session", data, ts: new Date().toISOString() }))
   ctx.on("hook:session-end", (data) => postToHub({ type: "hook:session-end", source: "pi-session", data, ts: new Date().toISOString() }))
 

package/packages/pi/extensions/memory-tool.ts

@@ -110,9 +110,9 @@ export function setupMemoryTool(ctx: PiContext): void {
         })
 
         if (!resp.ok) return "Failed to add memory — hub returned error."
-        const data = await resp.json() as { ok?: boolean; id?: string }
-        return data.ok
-          ? `Memory added: "${title}" (${type ?? "note"})`
+        const data = await resp.json() as { ok?: boolean; id?: string | number }
+        return (data.ok || data.id)
+          ? `Memory added: "${title}" (${type ?? "note"})${data.id ? ` [id: ${data.id}]` : ""}`
           : "Memory add returned unexpected response."
       } catch {
         return "Memory add unavailable — Context Hub may not be running."