jfl 0.9.0 → 0.9.2

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

@@ -1,11 +1,10 @@
 /**
  * Memory Tool Extension
  *
- * Registers jfl_memory_search tool with custom TUI rendering.
- * Queries Context Hub memory API and renders results with
- * type-colored headers and collapsible sections.
+ * Registers jfl_memory_search, jfl_memory_add, and jfl_memory_status tools.
+ * Full parity with the Context Hub MCP server's memory tools.
  *
- * @purpose jfl_memory_search tool — themed semantic memory search results
+ * @purpose Memory tools — search, add, and status for project memory
  */
 
 import type { PiContext } from "./types.js"
@@ -13,6 +12,7 @@ import { hubUrl, authToken } from "./map-bridge.js"
 import { memoryRenderCall, memoryRenderResult } from "./tool-renderers.js"
 
 export function setupMemoryTool(ctx: PiContext): void {
+  // ─── jfl_memory_search ───────────────────────────────────────────────────
   ctx.registerTool({
     name: "jfl_memory_search",
     description: "Search JFL project memory — find past decisions, learnings, and patterns across all sessions",
@@ -70,4 +70,84 @@ export function setupMemoryTool(ctx: PiContext): void {
     renderCall: memoryRenderCall,
     renderResult: memoryRenderResult,
   })
+
+  // ─── jfl_memory_add ──────────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_memory_add",
+    description: "Manually add a memory or note to the project memory system. Use to capture insights, decisions, or important context that should persist across sessions.",
+    promptSnippet: "Add a memory/note to project memory",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Title for the memory entry",
+        },
+        content: {
+          type: "string",
+          description: "Content of the memory — the insight, decision, or note",
+        },
+        type: {
+          type: "string",
+          description: "Type of memory entry",
+          enum: ["decision", "discovery", "insight", "note"],
+        },
+      },
+      required: ["title", "content"],
+    },
+    async handler(input) {
+      const { title, content, type } = input as { title: string; content: string; type?: string }
+
+      try {
+        const resp = await fetch(`${hubUrl}/api/memory/add`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+          },
+          body: JSON.stringify({ title, content, type: type ?? "note" }),
+          signal: AbortSignal.timeout(5000),
+        })
+
+        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"})`
+          : "Memory add returned unexpected response."
+      } catch {
+        return "Memory add unavailable — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── jfl_memory_status ───────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_memory_status",
+    description: "Get memory system statistics and health — total entries, indexed count, embedding status.",
+    promptSnippet: "Check memory system health and stats",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    async handler() {
+      try {
+        const resp = await fetch(`${hubUrl}/api/memory/status`, {
+          method: "GET",
+          headers: {
+            ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+          },
+          signal: AbortSignal.timeout(5000),
+        })
+
+        if (!resp.ok) return "Memory status unavailable."
+        const data = await resp.json() as Record<string, unknown>
+
+        return Object.entries(data)
+          .map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`)
+          .join("\n")
+      } catch {
+        return "Memory status unavailable — Context Hub may not be running."
+      }
+    },
+  })
 }