jfl 0.4.3 → 0.5.0

package/packages/pi/extensions/journal.ts

@@ -0,0 +1,224 @@
+/**
+ * Journal Extension
+ *
+ * Detects git commits via tool_execution_end, prompts for journal entries,
+ * registers the /journal command with interactive type selection,
+ * shows themed journal stream in below-editor widget.
+ *
+ * @purpose Auto-journal detection + interactive /journal command + themed widget
+ */
+
+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 { emitCustomEvent } from "./map-bridge.js"
+
+let projectRoot = ""
+
+interface JournalEntry {
+  v: number
+  ts: string
+  session: string
+  type: string
+  status: string
+  title: string
+  summary: string
+  detail?: string
+  files?: string[]
+  incomplete?: string[]
+  next?: string
+  learned?: string[]
+}
+
+function getJournalPath(root: string): string {
+  const branch = getCurrentBranch(root)
+  return join(root, ".jfl", "journal", `${branch}.jsonl`)
+}
+
+function appendJournalEntry(root: string, entry: JournalEntry): void {
+  const journalPath = getJournalPath(root)
+  mkdirSync(join(root, ".jfl", "journal"), { recursive: true })
+  appendFileSync(journalPath, JSON.stringify(entry) + "\n")
+}
+
+function readRecentEntries(root: string, count = 5): JournalEntry[] {
+  const journalPath = getJournalPath(root)
+  if (!existsSync(journalPath)) return []
+  try {
+    const lines = readFileSync(journalPath, "utf-8")
+      .split("\n")
+      .filter(Boolean)
+      .slice(-count)
+    return lines.map(l => JSON.parse(l) as JournalEntry)
+  } catch {
+    return []
+  }
+}
+
+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()
+  return content.length > 0
+}
+
+const TYPE_ICONS: Record<string, string> = {
+  feature: "✦",
+  fix: "✧",
+  decision: "◆",
+  discovery: "◇",
+  milestone: "★",
+  "session-end": "●",
+  spec: "□",
+}
+
+const TYPE_COLORS: Record<string, string> = {
+  feature: "success",
+  fix: "error",
+  decision: "warning",
+  discovery: "accent",
+  milestone: "warning",
+  "session-end": "dim",
+  spec: "muted",
+}
+
+function showRecentJournal(_ctx: PiContext): void {
+  // Widget removed — journal entries visible via /journal or Ctrl+Shift+J
+}
+
+export async function setupJournal(ctx: PiContext, _config: JflConfig): Promise<void> {
+  projectRoot = ctx.session.projectRoot
+
+  showRecentJournal(ctx)
+
+  ctx.registerCommand({
+    name: "journal",
+    description: "Write a journal entry for the current session",
+    async handler(_args, ctx) {
+      if (ctx.ui.hasUI) {
+        const types = [
+          { value: "feature" as const, label: "✦ Feature", description: "Something built or completed" },
+          { value: "fix" as const, label: "✧ Fix", description: "Bug found and fixed" },
+          { value: "decision" as const, label: "◆ Decision", description: "Choice made between options" },
+          { value: "discovery" as const, label: "◇ Discovery", description: "Insight or learning" },
+          { value: "milestone" as const, label: "★ Milestone", description: "Major goal reached" },
+        ]
+
+        const type = await ctx.ui.select("Journal Entry Type", types)
+        if (!type) return
+
+        const title = await ctx.ui.input("Title", "What happened?")
+        if (!title?.trim()) return
+
+        const summary = await ctx.ui.input("Summary (2-3 sentences)", "Brief description")
+
+        const entry: JournalEntry = {
+          v: 1,
+          ts: new Date().toISOString(),
+          session: getCurrentBranch(projectRoot),
+          type,
+          status: "complete",
+          title: title.trim(),
+          summary: summary?.trim() ?? title.trim(),
+        }
+
+        appendJournalEntry(projectRoot, entry)
+        await emitCustomEvent(ctx, "journal:entry", entry)
+        ctx.emit("journal:written", entry)
+        showRecentJournal(ctx)
+        ctx.ui.notify(`${TYPE_ICONS[type] ?? "·"} Journal: ${title.trim()}`, { level: "success" })
+        ctx.ui.setStatus("journal", undefined)
+        return
+      }
+
+      // Fallback: raw JSON input for non-interactive mode
+      const branch = getCurrentBranch(projectRoot)
+      const template = JSON.stringify({
+        v: 1,
+        ts: new Date().toISOString(),
+        session: branch,
+        type: "feature",
+        status: "complete",
+        title: "",
+        summary: "",
+        detail: "",
+        files: [],
+      }, null, 2)
+
+      const content = await ctx.ui.input("Journal Entry (paste JSON)", template)
+      if (!content?.trim()) return
+
+      try {
+        const entry = JSON.parse(content) as JournalEntry
+        appendJournalEntry(projectRoot, entry)
+        await emitCustomEvent(ctx, "journal:entry", entry)
+        ctx.emit("journal:written", entry)
+        showRecentJournal(ctx)
+        ctx.ui.notify("Journal entry saved", { level: "success" })
+      } catch {
+        ctx.ui.notify("Invalid JSON — entry not saved. Use /journal and paste valid JSON.", { level: "warn" })
+      }
+    },
+  })
+
+  ctx.on("map:journal:entry", () => showRecentJournal(ctx))
+  ctx.on("journal:written", () => showRecentJournal(ctx))
+}
+
+export async function onToolExecutionEnd(
+  ctx: PiContext,
+  event: ToolExecutionEvent
+): Promise<void> {
+  const toolName = event.toolName ?? event.tool ?? ""
+  if (toolName.toLowerCase() !== "bash") return
+
+  const result = String(event.result ?? "")
+  const isGitCommit = /\[[\w/.-]+\s+[0-9a-f]{7,}\]/.test(result)
+  if (!isGitCommit) return
+
+  let commitMsg = ""
+  let commitFiles = ""
+  try {
+    commitMsg = execSync("git log -1 --pretty=%B", { cwd: projectRoot }).toString().trim()
+    commitFiles = execSync("git diff-tree --no-commit-id --name-only -r HEAD", { cwd: projectRoot })
+      .toString().trim()
+  } catch {}
+
+  ctx.emit("pi:git-commit-detected", { message: commitMsg, files: commitFiles })
+
+  ctx.ui.notify([
+    "Git commit detected — Ctrl+Shift+J for quick journal or /journal",
+    commitMsg ? `Commit: ${commitMsg.split("\n")[0]}` : "",
+    commitFiles ? `Files: ${commitFiles.split("\n").slice(0, 3).join(", ")}` : "",
+  ].filter(Boolean).join("\n"), { level: "info" })
+}
+
+export async function onJournalAgentEnd(
+  _ctx: PiContext,
+  _event: AgentEndEvent
+): Promise<void> {
+  // Removed: "Journal entry recommended" nudge (noisy)
+}
+
+export async function checkJournalBeforeCompact(
+  ctx: PiContext
+): Promise<{ cancel: true } | void> {
+  const branch = getCurrentBranch(projectRoot)
+  if (!hasJournalEntryForSession(projectRoot, branch)) {
+    if (ctx.ui.hasUI) {
+      const ok = await ctx.ui.confirm(
+        "No Journal Entry",
+        "No journal entry for this session. Compacting without one loses context.\n\nContinue anyway?"
+      )
+      if (!ok) return ctx.cancel()
+    } else {
+      ctx.ui.notify(
+        "No journal entry for this session. Write one with /journal before compacting.",
+        { level: "warn" }
+      )
+      return ctx.cancel()
+    }
+  }
+}

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

@@ -0,0 +1,178 @@
+/**
+ * MAP Event Bridge Extension
+ *
+ * Translates Pi lifecycle events → MAP event bus (Context Hub HTTP).
+ * Also subscribes to hub SSE stream and re-emits as Pi custom events.
+ * Enforces scope filtering from .jfl/config.json context_scope.
+ *
+ * @purpose Pi lifecycle → MAP bus bridge with scope enforcement
+ */
+
+import { readFileSync, existsSync } from "fs"
+import { join } from "path"
+import type { PiContext, JflConfig, AgentEndEvent, ToolExecutionEvent } from "./types.js"
+
+interface MAPEvent {
+  type: string
+  source: string
+  data?: unknown
+  ts?: string
+}
+
+interface ContextScope {
+  produces?: string[]
+  consumes?: string[]
+  denied?: string[]
+}
+
+let hubUrl = "http://localhost:4242"
+let authToken: string | null = null
+let scope: ContextScope = {}
+let sseAbort: AbortController | null = null
+
+const PI_TO_MAP: Record<string, string> = {
+  "hook:session-start": "hook:session-start",
+  "hook:session-end": "hook:session-end",
+  "task:started": "task:started",
+  "task:completed": "task:completed",
+  "hook:tool-use": "hook:tool-use",
+  "hook:tool-result": "hook:tool-result",
+}
+
+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 matchPattern(pattern: string, value: string): boolean {
+  if (pattern === "*") return true
+  if (pattern === value) return true
+  if (pattern.includes("*")) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$")
+    return regex.test(value)
+  }
+  return false
+}
+
+function isEventAllowedToEmit(eventType: string, src: ContextScope): boolean {
+  if (!src.produces || src.produces.length === 0) return true
+  return src.produces.some(p => matchPattern(p, eventType))
+}
+
+function isEventDenied(eventType: string, src: ContextScope): boolean {
+  if (!src.denied || src.denied.length === 0) return false
+  return src.denied.some(d => matchPattern(d, eventType))
+}
+
+async function postToHub(event: MAPEvent): Promise<void> {
+  if (isEventDenied(event.type, scope)) return
+  if (!isEventAllowedToEmit(event.type, scope)) return
+
+  try {
+    const response = await fetch(`${hubUrl}/api/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+      },
+      body: JSON.stringify(event),
+    })
+    if (!response.ok) {
+      // Silently ignore hub connectivity issues — it may not be running
+    }
+  } catch {
+    // Hub not available — non-fatal
+  }
+}
+
+async function subscribeToHubSSE(ctx: PiContext): Promise<void> {
+  sseAbort = new AbortController()
+
+  const consumesPatterns = scope.consumes ?? ["*"]
+
+  try {
+    const patternsParam = consumesPatterns.join(",")
+    const url = `${hubUrl}/api/events/stream?pattern=${encodeURIComponent(patternsParam)}`
+
+    const resp = await fetch(url, {
+      headers: authToken ? { Authorization: `Bearer ${authToken}` } : {},
+      signal: sseAbort.signal,
+    })
+
+    if (!resp.ok || !resp.body) return
+
+    const reader = resp.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ""
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split("\n")
+      buffer = lines.pop() ?? ""
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue
+        try {
+          const event = JSON.parse(line.slice(6)) as MAPEvent
+          if (isEventDenied(event.type, scope)) continue
+          ctx.emit(`map:${event.type}`, event)
+        } catch {}
+      }
+    }
+  } catch (err: unknown) {
+    if ((err as { name?: string }).name === "AbortError") return
+    // Silently ignore — Context Hub may not be running
+  }
+}
+
+export async function setupMapBridge(ctx: PiContext, config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+
+  authToken = readToken(root)
+  scope = config.context_scope ?? {}
+
+  const portFile = join(root, ".jfl", "context-hub.port")
+  if (existsSync(portFile)) {
+    const port = readFileSync(portFile, "utf-8").trim()
+    if (port) hubUrl = `http://localhost:${port}`
+  }
+
+  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() }))
+
+  subscribeToHubSSE(ctx).catch(() => {})
+}
+
+export async function onMapBridgeShutdown(_ctx: PiContext): Promise<void> {
+  sseAbort?.abort()
+  sseAbort = null
+}
+
+export async function emitAgentStart(ctx: PiContext, event: unknown): Promise<void> {
+  await postToHub({ type: "task:started", source: `pi-agent:${ctx.session.id}`, data: event, ts: new Date().toISOString() })
+}
+
+export async function emitAgentEnd(ctx: PiContext, event: AgentEndEvent): Promise<void> {
+  await postToHub({ type: "task:completed", source: `pi-agent:${ctx.session.id}`, data: event, ts: new Date().toISOString() })
+}
+
+export async function onMapToolEnd(ctx: PiContext, event: ToolExecutionEvent): Promise<void> {
+  await postToHub({
+    type: "hook:tool-result",
+    source: `pi-agent:${ctx.session.id}`,
+    data: { tool: event.toolName ?? event.tool, duration: event.duration },
+    ts: new Date().toISOString(),
+  })
+}
+
+export async function emitCustomEvent(ctx: PiContext, type: string, data: unknown): Promise<void> {
+  await postToHub({ type, source: `pi:${ctx.session.id}`, data, ts: new Date().toISOString() })
+}
+
+export { hubUrl, authToken }

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

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ *
+ * @purpose jfl_memory_search tool — themed semantic memory search results
+ */
+
+import type { PiContext } from "./types.js"
+import { hubUrl, authToken } from "./map-bridge.js"
+import { memoryRenderCall, memoryRenderResult } from "./tool-renderers.js"
+
+export function setupMemoryTool(ctx: PiContext): void {
+  ctx.registerTool({
+    name: "jfl_memory_search",
+    description: "Search JFL project memory — find past decisions, learnings, and patterns across all sessions",
+    promptSnippet: "Search project memory for decisions, learnings, and session history",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query to find relevant memories",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 10)",
+        },
+        type: {
+          type: "string",
+          description: "Filter by entry type: feature, fix, decision, discovery, milestone, all",
+          enum: ["feature", "fix", "decision", "discovery", "milestone", "all"],
+        },
+      },
+      required: ["query"],
+    },
+    async handler(input) {
+      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 resp = await fetch(`${hubUrl}/api/memory/search?${params}`, {
+          headers: authToken ? { Authorization: `Bearer ${authToken}` } : {},
+        })
+
+        if (!resp.ok) return "Memory search unavailable."
+        const data = await resp.json() as { results?: Array<{ content: string; title?: string; ts?: string; type?: string }> }
+
+        if (!data.results?.length) return "No memories found."
+
+        return data.results
+          .map(r => {
+            const header = [r.type && `[${r.type}]`, r.title].filter(Boolean).join(" ")
+            return [header, r.content].filter(Boolean).join("\n")
+          })
+          .join("\n\n---\n\n")
+      } catch {
+        return "Memory search unavailable — Context Hub may not be running."
+      }
+    },
+    renderCall: memoryRenderCall,
+    renderResult: memoryRenderResult,
+  })
+}

package/packages/pi/extensions/notifications.ts

@@ -0,0 +1,73 @@
+/**
+ * Native Notifications Extension
+ *
+ * Sends terminal notifications (OSC 777/99) when:
+ * - Agent finishes a long task (>10s)
+ * - Journal entry is recommended
+ * - Eval score changes significantly
+ *
+ * Supports Ghostty, iTerm2, WezTerm, Kitty, Windows Terminal.
+ *
+ * @purpose Terminal-native notifications for key JFL events
+ */
+
+import type { PiContext, JflConfig } from "./types.js"
+
+let enabled = true
+let agentStartTime = 0
+const LONG_TASK_THRESHOLD_MS = 10000
+
+function notifyOSC777(title: string, body: string): void {
+  process.stdout.write(`\x1b]777;notify;${title};${body}\x07`)
+}
+
+function notifyOSC99(title: string, body: string): void {
+  process.stdout.write(`\x1b]99;i=1:d=0;${title}\x1b\\`)
+  process.stdout.write(`\x1b]99;i=1:p=body;${body}\x1b\\`)
+}
+
+function notify(title: string, body: string): void {
+  if (!enabled) return
+
+  try {
+    if (process.env.KITTY_WINDOW_ID) {
+      notifyOSC99(title, body)
+    } else {
+      notifyOSC777(title, body)
+    }
+  } catch {}
+}
+
+export function setupNotifications(ctx: PiContext, config: JflConfig): void {
+  if (config.pi?.disable_notifications) {
+    enabled = false
+    return
+  }
+
+  ctx.on("agent:start", () => {
+    agentStartTime = Date.now()
+  })
+
+  ctx.on("agent:end", (data: any) => {
+    const elapsed = Date.now() - agentStartTime
+    if (elapsed > LONG_TASK_THRESHOLD_MS) {
+      const seconds = Math.floor(elapsed / 1000)
+      const reason = data?.exitReason ?? "done"
+      notify("JFL", `Agent finished (${seconds}s) — ${reason}`)
+    }
+  })
+
+  ctx.on("journal:written", (data: any) => {
+    const title = data?.title ?? "entry"
+    notify("JFL Journal", title)
+  })
+
+  ctx.registerCommand({
+    name: "notify",
+    description: "Toggle native terminal notifications",
+    async handler(_args, ctx) {
+      enabled = !enabled
+      ctx.ui.notify(`Notifications ${enabled ? "enabled" : "disabled"}`, { level: "info" })
+    },
+  })
+}