jfl 0.5.0 → 0.6.1

package/packages/pi/extensions/context.ts

@@ -1,11 +1,11 @@
 /**
  * Context Extension
  *
- * Ensures Context Hub is running, injects recent context before each agent turn,
- * and registers the jfl_context tool with custom TUI rendering.
- * Context results show type-colored headers and collapsible sections.
+ * Ensures Context Hub is running, injects CLAUDE.md + recent context before
+ * each agent turn via POST /api/prompt, and registers the jfl_context tool.
+ * Hub is the single source of truth — no local CLAUDE.md reading.
  *
- * @purpose Context Hub integration — inject context, register themed jfl_context tool
+ * @purpose Context Hub + system prompt injection via Hub API (parity with Claude Code)
  */
 
 import { existsSync, readFileSync } from "fs"
@@ -13,55 +13,35 @@ import { join } from "path"
 import { execSync } from "child_process"
 import type { PiContext, JflConfig, AgentStartEvent } from "./types.js"
 import { contextRenderCall, contextRenderResult } from "./tool-renderers.js"
+import { readHubUrl, readToken } from "./hub-resolver.js"
 
 let hubBaseUrl = "http://localhost:4242"
 let hubToken: string | null = null
 let projectRoot = ""
-
-function readToken(root: string): string | null {
-  const tokenPath = join(root, ".jfl", "context-hub.token")
-  if (existsSync(tokenPath)) {
-    return readFileSync(tokenPath, "utf-8").trim()
-  }
-  return null
-}
-
-function getHubUrl(root: string): string {
-  // 1. Runtime port file (written by context-hub when it starts)
-  const portFile = join(root, ".jfl", "context-hub.port")
-  if (existsSync(portFile)) {
-    const port = readFileSync(portFile, "utf-8").trim()
-    if (port) return `http://localhost:${port}`
-  }
-
-  // 2. Project config (static port assignment)
-  const configFile = join(root, ".jfl", "config.json")
-  if (existsSync(configFile)) {
-    try {
-      const config = JSON.parse(readFileSync(configFile, "utf-8"))
-      const port = config.contextHub?.port
-      if (port) return `http://localhost:${port}`
-    } catch {}
-  }
-
-  return "http://localhost:4242"
-}
+let cachedPrompt: string | null = null
 
 function refreshHubUrl(): void {
-  hubBaseUrl = getHubUrl(projectRoot)
+  hubBaseUrl = readHubUrl(projectRoot)
   hubToken = readToken(projectRoot)
 }
 
 async function fetchContext(query?: string, limit = 10): Promise<string> {
-  // Try current URL first, then refresh and retry once on failure
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       const params = new URLSearchParams()
       if (query) params.set("query", query)
       params.set("limit", String(limit))
 
-      const resp = await fetch(`${hubBaseUrl}/api/context?${params}`, {
-        headers: hubToken ? { Authorization: `Bearer ${hubToken}` } : {},
+      const body: Record<string, unknown> = { maxItems: limit }
+      if (query) body.query = query
+
+      const resp = await fetch(`${hubBaseUrl}/api/context`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(hubToken ? { Authorization: `Bearer ${hubToken}` } : {}),
+        },
+        body: JSON.stringify(body),
         signal: AbortSignal.timeout(5000),
       })
 
@@ -87,6 +67,26 @@ async function fetchContext(query?: string, limit = 10): Promise<string> {
   return ""
 }
 
+async function fetchPrompt(taskType?: string): Promise<string> {
+  try {
+    const resp = await fetch(`${hubBaseUrl}/api/prompt`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(hubToken ? { Authorization: `Bearer ${hubToken}` } : {}),
+      },
+      body: JSON.stringify({ taskType: taskType ?? "general", maxItems: 20 }),
+      signal: AbortSignal.timeout(10000),
+    })
+
+    if (!resp.ok) return ""
+    const data = await resp.json() as { prompt?: string }
+    return data.prompt ?? ""
+  } catch {
+    return ""
+  }
+}
+
 export async function setupContext(ctx: PiContext, _config: JflConfig): Promise<void> {
   const root = ctx.session.projectRoot
   projectRoot = root
@@ -101,31 +101,54 @@ export async function setupContext(ctx: PiContext, _config: JflConfig): Promise<
   }
 
   // Now read the port (hub may have written .jfl/context-hub.port during ensure)
-  hubBaseUrl = getHubUrl(root)
+  hubBaseUrl = readHubUrl(root)
   hubToken = readToken(root)
   ctx.log(`Context Hub URL: ${hubBaseUrl}`, "debug")
 
+  // Pre-fetch prompt for first turn (cache it)
+  cachedPrompt = await fetchPrompt("general")
+  if (cachedPrompt) {
+    ctx.log(`System prompt loaded via Hub (${cachedPrompt.length} chars)`, "debug")
+  }
+
   ctx.registerTool({
     name: "jfl_context",
-    description: "Search JFL project context: journal entries, knowledge docs, memory. Use this to look up what happened in previous sessions, project decisions, or any project-specific knowledge.",
-    promptSnippet: "Search project context: journals, knowledge docs, decisions",
+    description: "Get unified project context: journal entries, knowledge docs, code headers. Use at session start and when you need project state. Equivalent to MCP context_get.",
+    promptSnippet: "Get project context: journals, knowledge, code — use at session start",
+    promptGuidelines: [
+      "Call this tool at the start of every session to understand project state",
+      "Use taskType to prioritize context for your current task",
+      "Call without query to get general project overview",
+    ],
     inputSchema: {
       type: "object",
       properties: {
         query: {
           type: "string",
-          description: "Search query to find relevant context",
+          description: "Optional search query to filter results",
+        },
+        taskType: {
+          type: "string",
+          description: "Type of task for context prioritization",
+          enum: ["code", "spec", "content", "strategy", "general"],
         },
         limit: {
           type: "number",
-          description: "Maximum number of results to return (default: 10)",
+          description: "Maximum number of results to return (default: 30)",
         },
       },
-      required: ["query"],
     },
     async handler(input) {
-      const { query, limit } = input as { query: string; limit?: number }
-      const result = await fetchContext(query, limit ?? 10)
+      const { query, limit, taskType } = input as { query?: string; limit?: number; taskType?: string }
+
+      // If asking for general context with no query, use the prompt endpoint
+      if (!query && taskType) {
+        const prompt = await fetchPrompt(taskType)
+        return prompt || "No context available."
+      }
+
+      // Otherwise use the search endpoint
+      const result = await fetchContext(query, limit ?? 30)
       return result || "No relevant context found."
     },
     renderCall: contextRenderCall,
@@ -137,15 +160,25 @@ export async function injectContext(
   _ctx: PiContext,
   _event: AgentStartEvent
 ): Promise<{ systemPromptAddition?: string } | void> {
-  const context = await fetchContext(undefined, 10)
-  if (!context) return
-
-  return {
-    systemPromptAddition: [
-      "## JFL Project Context",
-      "(Recent journal entries and project knowledge — use this to maintain continuity across sessions)",
-      "",
-      context,
-    ].join("\n"),
+  // Use cached prompt from setup, or fetch fresh
+  const prompt = cachedPrompt || await fetchPrompt("general")
+
+  // Clear cache after first use — subsequent turns get fresh context
+  cachedPrompt = null
+
+  if (!prompt) {
+    // Fallback: just inject recent context
+    const context = await fetchContext(undefined, 10)
+    if (!context) return
+    return {
+      systemPromptAddition: [
+        "## JFL Project Context",
+        "(Recent journal entries and project knowledge)",
+        "",
+        context,
+      ].join("\n"),
+    }
   }
+
+  return { systemPromptAddition: prompt }
 }

package/packages/pi/extensions/hub-resolver.ts

@@ -0,0 +1,63 @@
+/**
+ * Hub Resolver
+ *
+ * Resolves the active Context Hub URL for a project using runtime artifacts,
+ * persisted config, MCP config, and deterministic per-project fallback.
+ *
+ * @purpose Shared Context Hub URL/token resolution for Pi extensions
+ */
+
+import { existsSync, readFileSync } from "fs"
+import { join, resolve } from "path"
+
+const PORT_MIN = 4200
+const PORT_MAX = 4999
+const PORT_RANGE = PORT_MAX - PORT_MIN + 1
+
+function computePortFromPath(projectPath: string): number {
+  const normalized = resolve(projectPath)
+  let hash = 5381
+  for (let i = 0; i < normalized.length; i++) {
+    hash = ((hash << 5) + hash + normalized.charCodeAt(i)) >>> 0
+  }
+  return PORT_MIN + (hash % PORT_RANGE)
+}
+
+function readJson(filePath: string): any | null {
+  if (!existsSync(filePath)) return null
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"))
+  } catch {
+    return null
+  }
+}
+
+export function readToken(root: string): string | null {
+  const tokenPath = join(root, ".jfl", "context-hub.token")
+  if (existsSync(tokenPath)) {
+    return readFileSync(tokenPath, "utf-8").trim() || null
+  }
+  return null
+}
+
+export function readHubUrl(root: string): string {
+  const portFile = join(root, ".jfl", "context-hub.port")
+  if (existsSync(portFile)) {
+    const port = readFileSync(portFile, "utf-8").trim()
+    if (port) return `http://localhost:${port}`
+  }
+
+  const projectConfig = readJson(join(root, ".jfl", "config.json"))
+  const configuredPort = projectConfig?.contextHub?.port
+  if (configuredPort) {
+    return `http://localhost:${configuredPort}`
+  }
+
+  const mcpConfig = readJson(join(root, ".mcp.json"))
+  const mcpUrl = mcpConfig?.mcpServers?.["jfl-context"]?.env?.CONTEXT_HUB_URL
+  if (typeof mcpUrl === "string" && mcpUrl.trim()) {
+    return mcpUrl.trim()
+  }
+
+  return `http://localhost:${computePortFromPath(root)}`
+}

package/packages/pi/extensions/index.ts

@@ -319,9 +319,22 @@ export default async function jflExtension(pi: any): Promise<void> {
 
     if (config.pi?.auto_start !== false && pi.sendUserMessage) {
       setTimeout(() => {
-        pi.sendUserMessage(
-          `JFL session started in "${projectName}". Use the jfl_context tool to read recent project context, then show a brief status update with current focus and any blocking issues.`
-        )
+        pi.sendUserMessage([
+          `JFL session started in "${projectName}" on branch ${ctx.session.branch}.`,
+          "",
+          "Complete these steps before responding to the user:",
+          "1. Use jfl_context to get recent project context (journal, knowledge, decisions)",
+          "2. Use jfl_memory_search to check for any recent decisions or blockers",
+          "3. Use jfl_hud to get the project dashboard (timeline, phase, pipeline)",
+          "4. Show a brief status update with:",
+          "   - What was worked on recently (from journal)",
+          "   - Current phase and focus",
+          "   - Any blocking issues or warnings",
+          "   - Suggested next action",
+          "",
+          "Follow the CLAUDE.md instructions injected in your system prompt.",
+          "Write journal entries as you work. Capture decisions immediately.",
+        ].join("\n"))
       }, 500)
     }
   })

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

@@ -40,11 +40,16 @@ export function setupMemoryTool(ctx: PiContext): void {
       const { query, limit, type } = input as { query: string; limit?: number; type?: string }
 
       try {
-        const params = new URLSearchParams({ query, limit: String(limit ?? 10) })
-        if (type && type !== "all") params.set("type", type)
+        const body: Record<string, unknown> = { query, maxItems: limit ?? 10 }
+        if (type && type !== "all") body.type = type
 
-        const resp = await fetch(`${hubUrl}/api/memory/search?${params}`, {
-          headers: authToken ? { Authorization: `Bearer ${authToken}` } : {},
+        const resp = await fetch(`${hubUrl}/api/memory/search`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+          },
+          body: JSON.stringify(body),
         })
 
         if (!resp.ok) return "Memory search unavailable."

package/packages/pi/extensions/session.ts

@@ -1,20 +1,22 @@
 /**
  * JFL Session Extension
  *
- * Handles auto-commit and session cleanup within a Pi session.
- * Does NOT run session-init.sh — that script is a Claude Code pre-hook that
- * launches the AI CLI, which would cause a double-launch inside Pi.
- * Pi IS the AI runtime; we only handle the persistent background tasks here.
+ * Pi-native session lifecycle via Context Hub API.
+ * Calls POST /api/session/init on start and POST /api/session/end on shutdown.
+ * Hub handles sync, branch creation, doctor — single source of truth.
+ * Pi only manages the auto-commit daemon locally (needs a detached process).
  *
- * @purpose Pi session lifecycle — auto-commit daemon + cleanup script delegation
+ * @purpose Pi session lifecycle — Hub API for init/end, local auto-commit daemon
  */
 
 import { execSync, spawn } from "child_process"
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig } from "./types.js"
+import { hubUrl, authToken } from "./map-bridge.js"
 
 let autoCommitProcess: ReturnType<typeof spawn> | null = null
+let sessionBranch = ""
 
 function findScript(root: string, scriptName: string): string | null {
   const candidates = [
@@ -30,7 +32,39 @@ function findScript(root: string, scriptName: string): string | null {
 export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<void> {
   const root = ctx.session.projectRoot
 
-  // Start auto-commit daemon — detached so it outlives this call
+  // Call Hub session init — handles sync, doctor, branch creation
+  try {
+    const resp = await fetch(`${hubUrl}/api/session/init`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+      },
+      body: JSON.stringify({ runtime: "pi" }),
+      signal: AbortSignal.timeout(90000),
+    })
+
+    if (resp.ok) {
+      const data = await resp.json() as { branch?: string; syncOk?: boolean; warnings?: string[]; doctor?: { errors: number; warnings: number } }
+      sessionBranch = data.branch ?? ctx.session.branch
+      if (data.warnings?.length) {
+        for (const w of data.warnings) ctx.log(w, "warn")
+      }
+      if (data.doctor?.errors) {
+        ctx.ui.notify(`Doctor: ${data.doctor.errors} errors`, { level: "warn" })
+      }
+      ctx.log(`Session init via Hub: branch=${sessionBranch}, sync=${data.syncOk}`, "debug")
+    } else {
+      ctx.log("Hub session init failed, falling back to local", "warn")
+      sessionBranch = ctx.session.branch
+    }
+  } catch {
+    // Hub not available — fall back to local branch detection
+    ctx.log("Hub unavailable for session init, using local branch", "debug")
+    sessionBranch = ctx.session.branch
+  }
+
+  // Start auto-commit daemon — must be local (detached process)
   const autoCommitScript = findScript(root, "auto-commit.sh")
   if (autoCommitScript) {
     autoCommitProcess = spawn("bash", [autoCommitScript, "start", "120"], {
@@ -44,28 +78,46 @@ export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<
 
   ctx.emit("hook:session-start", {
     session: ctx.session.id,
-    branch: ctx.session.branch,
+    branch: sessionBranch,
     projectRoot: root,
     ts: new Date().toISOString(),
   })
 }
 
+export function getSessionBranch(): string {
+  return sessionBranch
+}
+
 export async function onShutdown(ctx: PiContext): Promise<void> {
   const root = ctx.session.projectRoot
 
+  // Kill auto-commit daemon
   if (autoCommitProcess) {
-    try {
-      autoCommitProcess.kill()
-    } catch {}
+    try { autoCommitProcess.kill() } catch {}
     autoCommitProcess = null
   }
 
-  const cleanupScript = findScript(root, "session-cleanup.sh")
-  if (cleanupScript) {
-    try {
-      execSync(`bash "${cleanupScript}"`, { cwd: root, stdio: "inherit" })
-    } catch (err) {
-      ctx.log(`session-cleanup.sh failed: ${err}`, "warn")
+  // Call Hub session end — handles journal check + cleanup
+  try {
+    await fetch(`${hubUrl}/api/session/end`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+      },
+      body: JSON.stringify({ runtime: "pi" }),
+      signal: AbortSignal.timeout(90000),
+    })
+    ctx.log("Session ended via Hub", "debug")
+  } catch {
+    // Fallback: run cleanup script directly
+    const cleanupScript = findScript(root, "session-cleanup.sh")
+    if (cleanupScript) {
+      try {
+        execSync(`bash "${cleanupScript}"`, { cwd: root, stdio: "inherit" })
+      } catch (err) {
+        ctx.log(`session-cleanup.sh failed: ${err}`, "warn")
+      }
     }
   }
 

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

@@ -12,10 +12,24 @@ import type { PiTheme } from "./types.js"
 
 // ─── Shared helpers ──────────────────────────────────────────────────────────
 
+function visibleLen(text: string): number {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").length
+}
+
 function truncLine(text: string, maxW: number): string {
-  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "")
-  if (stripped.length <= maxW) return text
-  return text.slice(0, maxW - 1) + "…"
+  if (visibleLen(text) <= maxW) return text
+  // Walk char-by-char, skipping ANSI sequences, until we hit maxW visible chars
+  let visible = 0
+  let i = 0
+  while (i < text.length && visible < maxW - 1) {
+    if (text[i] === "\x1b" && text[i + 1] === "[") {
+      const end = text.indexOf("m", i)
+      if (end !== -1) { i = end + 1; continue }
+    }
+    visible++
+    i++
+  }
+  return text.slice(0, i) + "\x1b[0m…"
 }
 
 function wrapText(text: string, width: number): string[] {
@@ -73,8 +87,9 @@ export function contextRenderCall(args: Record<string, any>, theme: PiTheme): an
 }
 
 export function contextRenderResult(result: any, opts: { expanded: boolean }, theme: PiTheme): any {
+  const MAX_W = 140
   const raw = extractText(result)
-  if (raw === "No relevant context found.") {
+  if (raw === "No relevant context found." || raw === "No context available.") {
     return { render: () => [theme.fg("dim", "No relevant context found")], invalidate() {} }
   }
 
@@ -90,17 +105,17 @@ export function contextRenderResult(result: any, opts: { expanded: boolean }, th
       const typeMatch = firstLine.match(/^\[(\w+)\]\s*(.*)/)
       if (typeMatch) {
         const typeColor = typeMatch[1] === "decision" ? "warning" : typeMatch[1] === "feature" ? "success" : "muted"
-        lines.push(`${theme.fg(typeColor, `[${typeMatch[1]}]`)} ${theme.fg("text", typeMatch[2])}`)
+        lines.push(truncLine(`${theme.fg(typeColor, `[${typeMatch[1]}]`)} ${theme.fg("text", typeMatch[2])}`, MAX_W))
       } else {
-        lines.push(theme.fg("text", firstLine))
+        lines.push(truncLine(theme.fg("text", firstLine), MAX_W))
       }
     } else {
-      lines.push(theme.fg("text", firstLine))
+      lines.push(truncLine(theme.fg("text", firstLine), MAX_W))
     }
 
     if (opts.expanded) {
       const rest = section.split("\n").slice(1)
-      for (const l of rest) lines.push(theme.fg("muted", l))
+      for (const l of rest) lines.push(truncLine(theme.fg("muted", l), MAX_W))
       lines.push("")
     }
   }

package/scripts/train/requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.0
+numpy>=1.24
+requests>=2.28
+scikit-learn>=1.3
+tqdm>=4.65