@10et/cli 1.0.0

package/packages/pi/extensions/header.ts

@@ -0,0 +1,171 @@
+/**
+ * TENET Header
+ *
+ * Replaces Pi's default startup header (logo + keybinding hints) with a
+ * branded TENET identity line. Shows project name, branch, and key system
+ * indicators in a single compact row. This owns "above the fold" —
+ * everything the user sees before any messages.
+ *
+ * @purpose Branded header replacing Pi's default — owns above-the-fold identity
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import type { PiContext, PiTheme, JflConfig } from "./types.js"
+
+// ─── Cached state ────────────────────────────────────────────────────────────
+
+let projectRoot = ""
+let projectName = ""
+let branch = ""
+let journalCount = 0
+let tupleCount = 0
+let sessionCount = 0
+let hubOnline = false
+let autoCommitRunning = false
+let evalScore: string | null = null
+
+// ─── Data helpers ────────────────────────────────────────────────────────────
+
+function countJournals(root: string): { entries: number; sessions: number } {
+  const dir = join(root, ".jfl", "journal")
+  if (!existsSync(dir)) return { entries: 0, sessions: 0 }
+  try {
+    const files = readdirSync(dir).filter(f => f.endsWith(".jsonl"))
+    let entries = 0
+    for (const f of files) {
+      entries += readFileSync(join(dir, f), "utf-8").trim().split("\n").filter(Boolean).length
+    }
+    return { entries, sessions: files.length }
+  } catch {
+    return { entries: 0, sessions: 0 }
+  }
+}
+
+function countTuples(root: string): number {
+  const p = join(root, ".jfl", "training-buffer.jsonl")
+  if (!existsSync(p)) return 0
+  try {
+    return readFileSync(p, "utf-8").trim().split("\n").filter(Boolean).length
+  } catch {
+    return 0
+  }
+}
+
+function getLatestEval(root: string): string | null {
+  try {
+    const p = join(root, ".jfl", "eval.jsonl")
+    if (!existsSync(p)) return null
+    const lines = readFileSync(p, "utf-8").trim().split("\n").filter(Boolean)
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - 20); i--) {
+      try {
+        const e = JSON.parse(lines[i])
+        const s = e.composite ?? e.score
+        if (s != null) return Number(s).toFixed(2)
+      } catch {}
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// ─── Refresh on-demand (called from onboarding probes or session_start) ──────
+
+export function refreshHeaderData(root: string, config: JflConfig): void {
+  projectRoot = root
+  projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  const { entries, sessions } = countJournals(root)
+  journalCount = entries
+  sessionCount = sessions
+  tupleCount = countTuples(root)
+  evalScore = getLatestEval(root)
+}
+
+export function setHeaderHubStatus(online: boolean): void {
+  hubOnline = online
+}
+
+export function setHeaderAutoCommit(running: boolean): void {
+  autoCommitRunning = running
+}
+
+export function setHeaderBranch(b: string): void {
+  branch = b
+}
+
+// ─── ANSI helpers ────────────────────────────────────────────────────────────
+
+function visLen(s: string): number {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length
+}
+
+function truncAnsi(s: string, max: number): string {
+  let vis = 0
+  let i = 0
+  while (i < s.length && vis < max) {
+    if (s[i] === "\x1b") {
+      const end = s.indexOf("m", i)
+      if (end !== -1) { i = end + 1; continue }
+    }
+    vis++
+    i++
+  }
+  return vis >= max ? s.slice(0, i) : s
+}
+
+// ─── Render ──────────────────────────────────────────────────────────────────
+
+function renderHeader(width: number, theme: PiTheme): string[] {
+  // Line 1: ◆ TENET · project-name · branch
+  const diamond = theme.fg("warning", "◆")
+  const brand = theme.bold(theme.fg("accent", "TENET"))
+  const name = theme.fg("text", projectName)
+  const branchStr = theme.fg("muted", branch || "main")
+
+  // Line 2: compact system indicators
+  const hubIcon = hubOnline
+    ? theme.fg("success", "✓") + theme.fg("dim", " Hub")
+    : theme.fg("error", "✗") + theme.fg("dim", " Hub")
+
+  const acIcon = autoCommitRunning
+    ? theme.fg("success", "✓") + theme.fg("dim", " Auto-commit")
+    : theme.fg("dim", "– Auto-commit")
+
+  const parts: string[] = [hubIcon, acIcon]
+
+  if (journalCount > 0) {
+    parts.push(theme.fg("dim", `${journalCount} entries · ${sessionCount} sessions`))
+  }
+  if (tupleCount > 0) {
+    parts.push(theme.fg("dim", `${tupleCount} tuples`))
+  }
+  if (evalScore) {
+    parts.push(theme.fg("warning", evalScore) + theme.fg("dim", " eval"))
+  }
+
+  const sep = theme.fg("dim", " · ")
+  const line1 = truncAnsi(` ${diamond} ${brand}${sep}${name}${sep}${branchStr}`, width)
+  const line2 = truncAnsi(`   ${parts.join(theme.fg("dim", "  │  "))}`, width)
+
+  return [line1, line2]
+}
+
+// ─── Setup ───────────────────────────────────────────────────────────────────
+
+export function setupHeader(ctx: PiContext, config: JflConfig): void {
+  if (!ctx.ui.hasUI) return
+
+  projectRoot = ctx.session.projectRoot
+  branch = ctx.session.branch
+  refreshHeaderData(projectRoot, config)
+
+  // Use the raw Pi setHeader API (available on latestPiCtx.ui)
+  // We access it through the shim's setHeader if available
+  ctx.ui.setHeader?.((tui: any, theme: PiTheme) => ({
+    render(width: number): string[] {
+      return renderHeader(width, theme)
+    },
+    invalidate() {},
+  }))
+}

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/hub-tools.ts

@@ -0,0 +1,267 @@
+/**
+ * Hub Tools Extension
+ *
+ * Registers tools for direct Context Hub interaction that were previously
+ * only available via MCP: events_publish, events_recent, context_status,
+ * context_sessions, query_experiment_history.
+ *
+ * Closes the parity gap between Claude Code (MCP) and Pi (extensions).
+ *
+ * @purpose Hub API tools — events, status, sessions, experiments (MCP parity)
+ */
+
+import type { PiContext, JflConfig } from "./types.js"
+import { hubUrl, authToken } from "./map-bridge.js"
+import { readHubUrl, readToken } from "./hub-resolver.js"
+
+let projectRoot = ""
+
+async function hubFetch(path: string, method: "GET" | "POST" = "GET", body?: unknown): Promise<any> {
+  // Try current hubUrl, then fall back to fresh port file read
+  const urls = [hubUrl]
+  if (projectRoot) {
+    const fresh = readHubUrl(projectRoot)
+    if (fresh && fresh !== hubUrl) urls.push(fresh)
+  }
+
+  let lastErr: Error | null = null
+  for (const url of urls) {
+    const token = url === hubUrl ? authToken : (projectRoot ? readToken(projectRoot) : authToken)
+    try {
+      const resp = await fetch(`${url}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+        signal: AbortSignal.timeout(5000),
+      })
+      if (!resp.ok) throw new Error(`Hub ${path}: ${resp.status}`)
+      return await resp.json()
+    } catch (err) {
+      lastErr = err as Error
+    }
+  }
+  throw lastErr ?? new Error(`Hub ${path}: unreachable`)
+}
+
+export async function setupHubTools(ctx: PiContext, _config: JflConfig): Promise<void> {
+  projectRoot = ctx.session.projectRoot
+
+  // ─── tenet_events_publish ──────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "tenet_events_publish",
+    description: "Publish an event to the MAP event bus. Use to signal state changes, completions, or trigger flows.",
+    promptSnippet: "Publish event to MAP bus",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Event type (e.g. 'task:completed', 'eval:scored', 'custom:my-event')",
+        },
+        data: {
+          type: "string",
+          description: "Event data as JSON string",
+        },
+      },
+      required: ["type"],
+    },
+    async handler(input) {
+      const { type, data } = input as { type: string; data?: string }
+      try {
+        let eventData: unknown = {}
+        if (data) {
+          try { eventData = JSON.parse(data) } catch { eventData = { message: data } }
+        }
+
+        await hubFetch("/api/events", "POST", {
+          type,
+          source: `pi:${ctx.session.id}`,
+          data: eventData,
+          ts: new Date().toISOString(),
+        })
+        return `Event published: ${type}`
+      } catch {
+        return "Event publish failed — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── tenet_events_recent ──────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "tenet_events_recent",
+    description: "Get recent events from the MAP event bus. Check what happened in the system — agent actions, eval results, flow triggers.",
+    promptSnippet: "View recent MAP events",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of events to return (default: 20)",
+        },
+        type: {
+          type: "string",
+          description: "Filter by event type prefix (e.g. 'eval:', 'hook:', 'task:')",
+        },
+      },
+    },
+    async handler(input) {
+      const { limit, type } = input as { limit?: number; type?: string }
+      try {
+        const params = new URLSearchParams()
+        if (limit) params.set("limit", String(limit))
+        if (type) params.set("type", type)
+
+        const data = await hubFetch(`/api/events?${params}`)
+        const events = data.events ?? data ?? []
+
+        if (!Array.isArray(events) || events.length === 0) return "No recent events."
+
+        return events
+          .slice(0, limit ?? 20)
+          .map((e: any) => {
+            const ts = e.ts ? new Date(e.ts).toLocaleTimeString() : "?"
+            const src = e.source ?? "?"
+            return `[${ts}] ${e.type} (${src})${e.data ? " — " + JSON.stringify(e.data).slice(0, 100) : ""}`
+          })
+          .join("\n")
+      } catch {
+        return "Events unavailable — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── tenet_context_status ─────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "tenet_context_status",
+    description: "Check Context Hub status — available sources, memory index health, connected services.",
+    promptSnippet: "Check Context Hub health",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    async handler() {
+      try {
+        const data = await hubFetch("/api/context/status")
+
+        const lines: string[] = ["Context Hub Status:"]
+        for (const [k, v] of Object.entries(data)) {
+          if (typeof v === "object" && v !== null) {
+            lines.push(`  ${k}: ${JSON.stringify(v)}`)
+          } else {
+            lines.push(`  ${k}: ${v}`)
+          }
+        }
+        return lines.join("\n")
+      } catch {
+        return "Context Hub status unavailable."
+      }
+    },
+  })
+
+  // ─── tenet_context_sessions ────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "tenet_context_sessions",
+    description: "See activity from other sessions — what other agents/users are working on. Informational only.",
+    promptSnippet: "View other session activity",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of sessions to return (default: 5)",
+        },
+      },
+    },
+    async handler(input) {
+      const { limit } = input as { limit?: number }
+      try {
+        // Try the sessions endpoint
+        const data = await hubFetch(`/api/context/sessions?limit=${limit ?? 5}`)
+        const sessions = data.sessions ?? data ?? []
+
+        if (!Array.isArray(sessions) || sessions.length === 0) return "No other sessions found."
+
+        return sessions
+          .map((s: any) => {
+            const age = s.lastSeen ? `(${new Date(s.lastSeen).toLocaleString()})` : ""
+            return `${s.branch ?? s.id ?? "?"} ${age} — ${s.summary ?? s.status ?? "active"}`
+          })
+          .join("\n")
+      } catch {
+        // Fallback: read journal files to find other sessions
+        try {
+          const { execSync } = await import("child_process")
+          const journalDir = `${ctx.session.projectRoot}/.jfl/journal`
+          const files = execSync(`ls -t ${journalDir}/*.jsonl 2>/dev/null | head -5`, {
+            encoding: "utf-8",
+          }).trim()
+
+          if (!files) return "No other sessions found."
+
+          return files.split("\n")
+            .map(f => {
+              const branch = f.split("/").pop()?.replace(".jsonl", "") ?? "?"
+              return `Session: ${branch}`
+            })
+            .join("\n")
+        } catch {
+          return "Sessions unavailable."
+        }
+      }
+    },
+  })
+
+  // ─── tenet_experiment_history ─────────────────────────────────────────────
+  ctx.registerTool({
+    name: "tenet_experiment_history",
+    description: "Search past experiments, their outcomes, and what was learned. Useful for avoiding repeat experiments.",
+    promptSnippet: "Search experiment history",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query for experiment history",
+        },
+        limit: {
+          type: "number",
+          description: "Max results (default: 10)",
+        },
+      },
+      required: ["query"],
+    },
+    async handler(input) {
+      const { query, limit } = input as { query: string; limit?: number }
+      try {
+        const data = await hubFetch("/api/eval/trajectory", "GET")
+        const entries = data.entries ?? data ?? []
+
+        if (!Array.isArray(entries) || entries.length === 0) return "No experiment history found."
+
+        // Filter by query (simple text match)
+        const queryLower = query.toLowerCase()
+        const filtered = entries
+          .filter((e: any) => {
+            const text = JSON.stringify(e).toLowerCase()
+            return text.includes(queryLower)
+          })
+          .slice(0, limit ?? 10)
+
+        if (filtered.length === 0) return `No experiments matching "${query}".`
+
+        return filtered
+          .map((e: any) => {
+            const ts = e.ts ? new Date(e.ts).toLocaleDateString() : "?"
+            const score = e.composite != null ? ` (score: ${e.composite})` : ""
+            return `[${ts}]${score} ${e.label ?? e.summary ?? JSON.stringify(e).slice(0, 100)}`
+          })
+          .join("\n")
+      } catch {
+        return "Experiment history unavailable — Context Hub may not be running."
+      }
+    },
+  })
+}