jfl 0.4.4 → 0.5.0

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

@@ -0,0 +1,61 @@
+/**
+ * CRM Tool Extension
+ *
+ * Registers jfl_crm tool with custom TUI rendering.
+ * Delegates to ./crm CLI (Google Sheets backed).
+ * Renders pipeline data with color-coded deal stages.
+ *
+ * @purpose jfl_crm tool — themed CRM display with deal status colors
+ */
+
+import { execSync } from "child_process"
+import type { PiContext } from "./types.js"
+import { crmRenderCall, crmRenderResult } from "./tool-renderers.js"
+
+let projectRoot = ""
+
+export function setupCrmTool(ctx: PiContext): void {
+  projectRoot = ctx.session.projectRoot
+
+  ctx.registerTool({
+    name: "jfl_crm",
+    description: "Query or update the JFL CRM (contacts, deals, pipeline). Delegates to ./crm CLI backed by Google Sheets.",
+    promptSnippet: "Query CRM pipeline, contacts, and deals via Google Sheets",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "CRM subcommand: list, prep, stale, priority, touch, update, add",
+        },
+        args: {
+          type: "string",
+          description: "Arguments for the subcommand (e.g., contact name, field, value)",
+        },
+      },
+      required: ["command"],
+    },
+    async handler(input) {
+      const { command, args } = input as { command: string; args?: string }
+      const fullCmd = args ? `./crm ${command} ${args}` : `./crm ${command}`
+
+      try {
+        const output = execSync(fullCmd, {
+          cwd: projectRoot,
+          timeout: 15000,
+          encoding: "utf-8",
+        })
+        return output.trim()
+      } catch (err: unknown) {
+        const error = err as { message?: string; stderr?: Buffer }
+        if (error.stderr) {
+          const stderr = error.stderr.toString().trim()
+          if (stderr) return `Error: ${stderr}`
+        }
+        return `Error running crm: ${error.message ?? String(err)}`
+      }
+    },
+    renderCall: crmRenderCall,
+    renderResult: crmRenderResult,
+  })
+}

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

@@ -0,0 +1,224 @@
+/**
+ * Eval Tool
+ *
+ * Exposes eval scoring and history to the agent. The agent can check
+ * project quality, view eval trends, and trigger eval runs.
+ *
+ * @purpose Pi tool for eval system — check scores, view trends, trigger evals
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import type { PiContext, JflConfig } from "./types.js"
+import { emitCustomEvent } from "./map-bridge.js"
+
+let projectRoot = ""
+
+interface EvalEntry {
+  v: number
+  ts: string
+  agent: string
+  run_id: string
+  composite: number
+  metrics: Record<string, any>
+  model_version?: string
+  branch?: string
+  pr_number?: number
+  delta?: number
+  improved?: boolean
+}
+
+function readEvals(): EvalEntry[] {
+  const evalPath = join(projectRoot, ".jfl", "eval", "eval.jsonl")
+  if (!existsSync(evalPath)) return []
+  const entries: EvalEntry[] = []
+  for (const line of readFileSync(evalPath, "utf-8").split("\n")) {
+    if (!line.trim()) continue
+    try { entries.push(JSON.parse(line)) } catch {}
+  }
+  return entries.sort((a, b) => (a.ts || "").localeCompare(b.ts || ""))
+}
+
+function readServiceEvents(): Array<Record<string, any>> {
+  const eventsPath = join(projectRoot, ".jfl", "service-events.jsonl")
+  if (!existsSync(eventsPath)) return []
+  const entries: any[] = []
+  for (const line of readFileSync(eventsPath, "utf-8").split("\n")) {
+    if (!line.trim()) continue
+    try { entries.push(JSON.parse(line)) } catch {}
+  }
+  return entries
+}
+
+export async function setupEvalTool(ctx: PiContext, _config: JflConfig): Promise<void> {
+  projectRoot = ctx.session.projectRoot
+
+  ctx.registerTool({
+    name: "jfl_eval_status",
+    description: "Get current eval status — latest scores, trends, and quality metrics. Use to understand project health before making changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "string",
+          description: "Number of recent eval entries to show (default: 5)",
+        },
+      },
+    },
+    async handler(input) {
+      const { limit: limitStr } = input as { limit?: string }
+      const limit = parseInt(limitStr || "5", 10)
+
+      const evals = readEvals()
+      if (evals.length === 0) {
+        return "No eval history found. Run `jfl eval` or push a PR to trigger CI eval."
+      }
+
+      const recent = evals.slice(-limit)
+      const latest = recent[recent.length - 1]
+
+      const lines = [
+        `Eval History: ${evals.length} total entries`,
+        "",
+        `Latest composite: ${latest.composite.toFixed(4)}`,
+        `Latest agent: ${latest.agent}`,
+        `Latest time: ${latest.ts}`,
+      ]
+
+      if (latest.metrics) {
+        lines.push("", "Dimensions:")
+        for (const [key, val] of Object.entries(latest.metrics)) {
+          if (typeof val === "number") {
+            lines.push(`  ${key}: ${val.toFixed(4)}`)
+          }
+        }
+      }
+
+      if (recent.length > 1) {
+        lines.push("", "Trend (recent):")
+        for (const e of recent) {
+          const delta = e.delta ?? 0
+          const sign = delta >= 0 ? "+" : ""
+          const improved = e.improved ? "✓" : "✗"
+          lines.push(`  ${e.ts.slice(0, 16)} ${e.composite.toFixed(4)} (${sign}${delta.toFixed(4)}) ${improved} [${e.agent}]`)
+        }
+      }
+
+      const deltas = evals.slice(-10).map(e => e.delta ?? 0)
+      const avgDelta = deltas.length > 0 ? deltas.reduce((a, b) => a + b, 0) / deltas.length : 0
+      const improving = deltas.filter(d => d > 0).length
+      lines.push(
+        "",
+        `10-run trend: avg delta ${avgDelta >= 0 ? "+" : ""}${avgDelta.toFixed(4)}, ${improving}/${deltas.length} improved`,
+      )
+
+      return lines.join("\n")
+    },
+  })
+
+  ctx.registerTool({
+    name: "jfl_eval_compare",
+    description: "Compare two eval snapshots by index (0 = oldest, -1 = latest). Useful for understanding what changed between versions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: {
+          type: "string",
+          description: "Index of first snapshot (default: -2, second-to-last)",
+        },
+        b: {
+          type: "string",
+          description: "Index of second snapshot (default: -1, latest)",
+        },
+      },
+    },
+    async handler(input) {
+      const { a: aStr, b: bStr } = input as { a?: string; b?: string }
+
+      const evals = readEvals()
+      if (evals.length < 2) {
+        return "Need at least 2 eval entries to compare."
+      }
+
+      const idxA = parseInt(aStr || "-2", 10)
+      const idxB = parseInt(bStr || "-1", 10)
+
+      const resolveIdx = (idx: number) => idx < 0 ? evals.length + idx : idx
+      const evalA = evals[resolveIdx(idxA)]
+      const evalB = evals[resolveIdx(idxB)]
+
+      if (!evalA || !evalB) {
+        return `Invalid indices. Have ${evals.length} entries (0 to ${evals.length - 1}).`
+      }
+
+      const lines = [
+        "Eval Comparison",
+        "",
+        `A: ${evalA.ts.slice(0, 16)} (composite: ${evalA.composite.toFixed(4)}) [${evalA.agent}]`,
+        `B: ${evalB.ts.slice(0, 16)} (composite: ${evalB.composite.toFixed(4)}) [${evalB.agent}]`,
+        "",
+        `Composite delta: ${(evalB.composite - evalA.composite) >= 0 ? "+" : ""}${(evalB.composite - evalA.composite).toFixed(4)}`,
+        "",
+        "Dimension changes:",
+      ]
+
+      const allKeys = new Set([
+        ...Object.keys(evalA.metrics || {}),
+        ...Object.keys(evalB.metrics || {}),
+      ])
+
+      for (const key of allKeys) {
+        const valA = (evalA.metrics?.[key] as number) ?? 0
+        const valB = (evalB.metrics?.[key] as number) ?? 0
+        if (typeof valA !== "number" || typeof valB !== "number") continue
+        const diff = valB - valA
+        const sign = diff >= 0 ? "+" : ""
+        const arrow = diff > 0.001 ? "↑" : diff < -0.001 ? "↓" : "="
+        lines.push(`  ${arrow} ${key}: ${valA.toFixed(4)} → ${valB.toFixed(4)} (${sign}${diff.toFixed(4)})`)
+      }
+
+      return lines.join("\n")
+    },
+  })
+
+  ctx.registerCommand({
+    name: "eval",
+    description: "Show eval status and recent scores",
+    async handler(_args, ctx) {
+      const evals = readEvals()
+      if (evals.length === 0) {
+        ctx.ui.notify("No eval history. Push a PR or run jfl eval.", { level: "info" })
+        return
+      }
+
+      const latest = evals[evals.length - 1]
+      const recent = evals.slice(-5)
+
+      const lines = [
+        `Eval: ${evals.length} entries | Latest: ${latest.composite.toFixed(4)}`,
+        "",
+      ]
+
+      for (const e of recent) {
+        const delta = e.delta ?? 0
+        const sign = delta >= 0 ? "+" : ""
+        lines.push(`  ${e.ts.slice(0, 10)} ${e.composite.toFixed(4)} (${sign}${delta.toFixed(4)}) [${e.agent}]`)
+      }
+
+      const serviceEvents = readServiceEvents()
+      const recentPRs = serviceEvents
+        .filter(e => e.type === "eval:scored")
+        .slice(-3)
+
+      if (recentPRs.length > 0) {
+        lines.push("", "Recent PR evals:")
+        for (const e of recentPRs) {
+          const d = e.data || {}
+          lines.push(`  PR #${d.pr_number || "?"}: ${d.composite?.toFixed(4) || "?"} (delta: ${d.delta?.toFixed(4) || "?"})`)
+        }
+      }
+
+      ctx.ui.notify(lines.join("\n"), { level: "info" })
+    },
+  })
+}

package/packages/pi/extensions/eval.ts

@@ -0,0 +1,60 @@
+/**
+ * Eval Extension
+ *
+ * Captures agent turn metrics and writes eval entries via eval-store.ts.
+ * Emits eval:submitted to MAP bus after each captured turn.
+ *
+ * @purpose Capture per-turn eval data and emit to MAP bus
+ */
+
+import { randomUUID } from "crypto"
+import type { PiContext, JflConfig, AgentEndEvent } from "./types.js"
+import { emitCustomEvent } from "./map-bridge.js"
+
+interface EvalEntry {
+  id: string
+  session_id: string
+  ts: string
+  model?: string
+  turn_count: number
+  tools_used?: string[]
+  files_changed?: string[]
+  duration_ms?: number
+  exit_reason?: string
+  project_root: string
+}
+
+let projectRoot = ""
+
+export async function setupEval(ctx: PiContext, _config: JflConfig): Promise<void> {
+  projectRoot = ctx.session.projectRoot
+}
+
+export async function onAgentEnd(ctx: PiContext, event: AgentEndEvent): Promise<void> {
+  // Pi's AgentEndEvent has messages array; use length as turn count
+  const turnCount = event.messages?.length ?? event.turnCount ?? 0
+  if (turnCount < 1) return
+
+  const entry: EvalEntry = {
+    id: randomUUID(),
+    session_id: ctx.session.id,
+    ts: new Date().toISOString(),
+    model: event.model,
+    turn_count: turnCount,
+    tools_used: event.toolsUsed,
+    files_changed: event.filesChanged,
+    duration_ms: event.duration,
+    exit_reason: event.exitReason,
+    project_root: projectRoot,
+  }
+
+  try {
+    // @ts-ignore — resolved from jfl package at runtime
+    const { appendEval } = await import("../../src/lib/eval-store.js")
+    appendEval(entry as Parameters<typeof appendEval>[0], projectRoot)
+  } catch {
+    // eval-store may not be available in all contexts — non-fatal
+  }
+
+  await emitCustomEvent(ctx, "eval:submitted", entry)
+}

package/packages/pi/extensions/footer.ts

@@ -0,0 +1,239 @@
+/**
+ * Custom Footer Extension
+ *
+ * Rich status footer showing project name, branch, turn count, session
+ * duration, model, pipeline deals, active agents, and eval score.
+ * Reactive to branch changes and turn updates.
+ *
+ * Layout: ◆ project [branch] │ T3 2m │ model │ 3 deals │ ✓ 0.89
+ *
+ * @purpose Custom footer with live project telemetry
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, PiTheme, JflConfig } from "./types.js"
+
+interface FooterState {
+  turnCount: () => number
+  sessionStart: () => number
+  model: () => string
+}
+
+let projectRoot = ""
+let projectName = ""
+let projectType = ""
+let state: FooterState
+let cachedPipelineCount: number | null = null
+let pipelineCacheTime = 0
+let cachedEvalScore: string | null = null
+let evalCacheTime = 0
+
+function formatDuration(ms: number): string {
+  const s = Math.floor(ms / 1000)
+  if (s < 60) return `${s}s`
+  const m = Math.floor(s / 60)
+  if (m < 60) return `${m}m`
+  const h = Math.floor(m / 60)
+  const rm = m % 60
+  return `${h}h${rm > 0 ? `${rm}m` : ""}`
+}
+
+function getPipelineCount(): number | null {
+  const now = Date.now()
+  if (cachedPipelineCount !== null && now - pipelineCacheTime < 60000) return cachedPipelineCount
+
+  try {
+    const output = execSync("./crm list --compact 2>/dev/null | wc -l", {
+      cwd: projectRoot,
+      timeout: 3000,
+      encoding: "utf-8",
+    }).trim()
+    cachedPipelineCount = parseInt(output, 10) || 0
+    pipelineCacheTime = now
+    return cachedPipelineCount
+  } catch {
+    return cachedPipelineCount
+  }
+}
+
+function getActiveAgentCount(): number {
+  try {
+    const journalDir = join(projectRoot, ".jfl", "journal")
+    if (!existsSync(journalDir)) return 0
+    const files = readdirSync(journalDir).filter(f => f.startsWith("session-") && f.endsWith(".jsonl"))
+    const now = Date.now()
+    let active = 0
+    for (const f of files) {
+      try {
+        const stat = require("fs").statSync(join(journalDir, f))
+        if (now - stat.mtimeMs < 300000) active++
+      } catch {}
+    }
+    return active
+  } catch {
+    return 0
+  }
+}
+
+function getEvalScore(): string | null {
+  const now = Date.now()
+  if (cachedEvalScore !== null && now - evalCacheTime < 30000) return cachedEvalScore
+
+  try {
+    const evalPath = join(projectRoot, ".jfl", "eval-store.jsonl")
+    if (!existsSync(evalPath)) return null
+    const lines = readFileSync(evalPath, "utf-8").trim().split("\n").filter(Boolean)
+    if (lines.length === 0) return null
+    const last = JSON.parse(lines[lines.length - 1])
+    if (last.composite !== undefined) {
+      cachedEvalScore = last.composite.toFixed(2)
+      evalCacheTime = now
+      return cachedEvalScore
+    }
+    return null
+  } catch {
+    return cachedEvalScore
+  }
+}
+
+function getJournalCount(): number {
+  try {
+    const journalDir = join(projectRoot, ".jfl", "journal")
+    if (!existsSync(journalDir)) return 0
+    let count = 0
+    for (const f of readdirSync(journalDir).filter(f => f.endsWith(".jsonl"))) {
+      const content = readFileSync(join(journalDir, f), "utf-8").trim()
+      count += content.split("\n").filter(Boolean).length
+    }
+    return count
+  } catch {
+    return 0
+  }
+}
+
+export function setupFooter(
+  ctx: PiContext,
+  config: JflConfig,
+  footerState: FooterState
+): void {
+  projectRoot = ctx.session.projectRoot
+  state = footerState
+
+  const configPath = join(projectRoot, ".jfl", "config.json")
+  if (existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(configPath, "utf-8"))
+      projectName = cfg.name ?? projectRoot.split("/").pop() ?? "JFL"
+      projectType = cfg.type ?? "gtm"
+    } catch {
+      projectName = projectRoot.split("/").pop() ?? "JFL"
+      projectType = "gtm"
+    }
+  } else {
+    projectName = projectRoot.split("/").pop() ?? "JFL"
+    projectType = "gtm"
+  }
+
+  if (config.pi?.disable_footer) return
+
+  ctx.ui.setFooter((tui: any, theme: PiTheme, footerData: any) => {
+    let disposed = false
+    const unsub = footerData?.onBranchChange?.(() => {
+      if (!disposed) tui.requestRender()
+    })
+
+    return {
+      dispose: () => {
+        disposed = true
+        if (typeof unsub === "function") unsub()
+      },
+
+      invalidate() {},
+
+      render(width: number): string[] {
+        const turns = state.turnCount()
+        const elapsed = formatDuration(Date.now() - state.sessionStart())
+        const model = state.model()
+        const branch = footerData?.getGitBranch?.() ?? ctx.session.branch
+
+        // ─── Left side: project identity + session info ───────────────
+        const bullet = theme.fg("accent", "◆")
+        const name = theme.fg("text", projectName)
+        const branchStr = theme.fg("muted", `[${branch}]`)
+        const turnStr = theme.fg("dim", `T${turns}`)
+        const timeStr = theme.fg("dim", elapsed)
+        const modelStr = model ? theme.fg("muted", model.split("/").pop() ?? model) : ""
+
+        const leftParts = [
+          `${bullet} ${name} ${branchStr}`,
+          `${turnStr} ${timeStr}`,
+          modelStr,
+        ].filter(Boolean)
+
+        const left = leftParts.join(theme.fg("dim", " │ "))
+
+        // ─── Right side: pipeline + agents + eval ─────────────────────
+        const rightParts: string[] = []
+
+        const pipeline = getPipelineCount()
+        if (pipeline !== null && pipeline > 0) {
+          rightParts.push(theme.fg("accent", `${pipeline} deal${pipeline !== 1 ? "s" : ""}`))
+        }
+
+        const agents = getActiveAgentCount()
+        if (agents > 0) {
+          rightParts.push(theme.fg("warning", `${agents} agent${agents !== 1 ? "s" : ""}`))
+        }
+
+        const journals = getJournalCount()
+        if (journals > 0) {
+          rightParts.push(theme.fg("dim", `${journals}j`))
+        }
+
+        const evalScore = getEvalScore()
+        if (evalScore) {
+          const score = parseFloat(evalScore)
+          const color = score >= 0.8 ? "success" : score >= 0.5 ? "warning" : "error"
+          rightParts.push(theme.fg(color, `✓${evalScore}`))
+        }
+
+        const right = rightParts.join(theme.fg("dim", " │ "))
+
+        // ─── Compose line ─────────────────────────────────────────────
+        const leftLen = stripAnsi(left).length
+        const rightLen = stripAnsi(right).length
+        const gap = Math.max(1, width - leftLen - rightLen)
+
+        const line = left + " ".repeat(gap) + right
+        return [truncateVisible(line, width)]
+      },
+    }
+  })
+
+  ctx.on("turn:start", () => {
+    // Footer auto-rerenders via requestRender when data changes
+  })
+}
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "")
+}
+
+function truncateVisible(str: string, maxWidth: number): string {
+  const visible = stripAnsi(str)
+  if (visible.length <= maxWidth) return str
+  // Rough truncation — find where visible chars exceed width
+  let visCount = 0
+  let i = 0
+  while (i < str.length && visCount < maxWidth - 1) {
+    if (str[i] === "\x1b") {
+      const end = str.indexOf("m", i)
+      if (end !== -1) { i = end + 1; continue }
+    }
+    visCount++
+    i++
+  }
+  return str.slice(0, i) + "…"
+}