jfl 0.9.0 → 0.9.1

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."
+      }
+    },
+  })
 }

package/packages/pi/extensions/service-skills.ts

@@ -0,0 +1,214 @@
+/**
+ * Service Skills Bridge
+ *
+ * Scans .claude/skills/ for service-type skills (generated during jfl init
+ * service onboarding) and registers them as Pi commands + tools.
+ * This gives Pi parity with Claude Code's service agent access.
+ *
+ * Service skills in .claude/skills/ have frontmatter `type: service` and
+ * include commands like status, logs, start, stop, restart, health.
+ *
+ * @purpose Bridge .claude/skills/ service agents into Pi sessions
+ */
+
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, JflConfig } from "./types.js"
+
+interface ServiceSkill {
+  name: string
+  description: string
+  servicePath: string
+  commands: string[]
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!match) return {}
+  const fm: Record<string, string> = {}
+  for (const line of match[1].split("\n")) {
+    const [key, ...rest] = line.split(":")
+    if (key && rest.length) {
+      fm[key.trim()] = rest.join(":").trim()
+    }
+  }
+  return fm
+}
+
+function discoverServiceSkills(projectRoot: string): ServiceSkill[] {
+  const claudeSkillsDir = join(projectRoot, ".claude", "skills")
+  if (!existsSync(claudeSkillsDir)) return []
+
+  const skills: ServiceSkill[] = []
+
+  try {
+    const entries = readdirSync(claudeSkillsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const skillPath = join(claudeSkillsDir, entry.name, "SKILL.md")
+      if (!existsSync(skillPath)) continue
+
+      try {
+        const content = readFileSync(skillPath, "utf-8")
+        const fm = parseFrontmatter(content)
+
+        if (fm.type !== "service") continue
+
+        // Extract available commands from the markdown table
+        const commands: string[] = []
+        const cmdMatch = content.match(/\| `(\w+)` \|/g)
+        if (cmdMatch) {
+          for (const m of cmdMatch) {
+            const cmd = m.match(/`(\w+)`/)
+            if (cmd) commands.push(cmd[1])
+          }
+        }
+        // Fallback defaults
+        if (commands.length === 0) {
+          commands.push("status", "logs", "start", "stop", "restart", "health", "recent")
+        }
+
+        skills.push({
+          name: entry.name,
+          description: fm.description || `${entry.name} service agent`,
+          servicePath: fm.service_path || "",
+          commands,
+        })
+      } catch {
+        // Skip unparseable skills
+      }
+    }
+  } catch {
+    // .claude/skills not readable
+  }
+
+  return skills
+}
+
+function runServiceCommand(serviceName: string, command: string, servicePath: string, projectRoot: string): string {
+  // Try jfl service-agent first
+  try {
+    const result = execSync(
+      `jfl service-agent run ${serviceName} ${command}`,
+      { cwd: projectRoot, encoding: "utf-8", timeout: 15000, stdio: ["pipe", "pipe", "pipe"] }
+    )
+    return result.trim()
+  } catch {
+    // Fallback: direct execution based on command type
+  }
+
+  if (!servicePath || !existsSync(servicePath)) {
+    return `Service path not found: ${servicePath}`
+  }
+
+  try {
+    switch (command) {
+      case "status": {
+        const branch = execSync("git branch --show-current", { cwd: servicePath, encoding: "utf-8" }).trim()
+        const lastCommit = execSync("git log -1 --pretty='%h %s (%cr)'", { cwd: servicePath, encoding: "utf-8" }).trim()
+        const dirty = execSync("git status --porcelain", { cwd: servicePath, encoding: "utf-8" }).trim()
+        return [
+          `Service: ${serviceName}`,
+          `Path: ${servicePath}`,
+          `Branch: ${branch}`,
+          `Last commit: ${lastCommit}`,
+          `Working tree: ${dirty ? `${dirty.split("\n").length} changes` : "clean"}`,
+        ].join("\n")
+      }
+
+      case "logs": {
+        return execSync("git log --oneline -10", { cwd: servicePath, encoding: "utf-8" }).trim()
+      }
+
+      case "recent": {
+        const since = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
+        try {
+          return execSync(`git log --oneline --since="${since}"`, { cwd: servicePath, encoding: "utf-8" }).trim() || "No changes in last 24h"
+        } catch {
+          return "No changes in last 24h"
+        }
+      }
+
+      case "health": {
+        // Check if package.json exists and has a test script
+        const pkgPath = join(servicePath, "package.json")
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+          const hasTests = !!pkg.scripts?.test
+          const hasBuild = !!pkg.scripts?.build
+          return [
+            `Service: ${serviceName}`,
+            `Has tests: ${hasTests ? "yes" : "no"}`,
+            `Has build: ${hasBuild ? "yes" : "no"}`,
+            `Dependencies: ${Object.keys(pkg.dependencies || {}).length}`,
+            `Dev dependencies: ${Object.keys(pkg.devDependencies || {}).length}`,
+          ].join("\n")
+        }
+        return `No package.json found at ${servicePath}`
+      }
+
+      default:
+        return `Unknown command: ${command}. Available: status, logs, recent, health`
+    }
+  } catch (err) {
+    return `Error running ${command} on ${serviceName}: ${err}`
+  }
+}
+
+export async function setupServiceSkills(ctx: PiContext, _config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+  const services = discoverServiceSkills(root)
+
+  if (services.length === 0) return
+
+  ctx.log(`Discovered ${services.length} service skill(s): ${services.map(s => s.name).join(", ")}`, "debug")
+
+  // Register a unified service tool
+  ctx.registerTool({
+    name: "jfl_service",
+    description: `Query registered service agents. Available services: ${services.map(s => s.name).join(", ")}. Commands: status, logs, recent, health, start, stop, restart.`,
+    promptSnippet: `Service agents: ${services.map(s => s.name).join(", ")}`,
+    promptGuidelines: [
+      `Use this tool to interact with registered services: ${services.map(s => s.name).join(", ")}`,
+      "Common commands: status (git info), logs (recent commits), recent (24h changes), health (package info)",
+    ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        service: {
+          type: "string",
+          description: `Service name: ${services.map(s => s.name).join(", ")}`,
+          enum: services.map(s => s.name),
+        },
+        command: {
+          type: "string",
+          description: "Command to run on the service",
+          enum: ["status", "logs", "recent", "health", "start", "stop", "restart"],
+        },
+      },
+      required: ["service", "command"],
+    },
+    async handler(input) {
+      const { service, command } = input as { service: string; command: string }
+      const svc = services.find(s => s.name === service)
+      if (!svc) return `Unknown service: ${service}. Available: ${services.map(s => s.name).join(", ")}`
+      return runServiceCommand(service, command, svc.servicePath, root)
+    },
+  })
+
+  // Register per-service commands (e.g., /jfl-cli status, /jfl-platform logs)
+  for (const svc of services) {
+    ctx.registerCommand({
+      name: svc.name,
+      description: `${svc.description} — commands: ${svc.commands.join(", ")}`,
+      async handler(args: string, _ctx: PiContext) {
+        const command = args.trim().split(/\s+/)[0] || "status"
+        const result = runServiceCommand(svc.name, command, svc.servicePath, root)
+        ctx.ui.notify(result, { level: "info" })
+      },
+    })
+  }
+}