@10et/cli 1.0.0

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

@@ -0,0 +1,219 @@
+/**
+ * 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: "tenet_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., /subclaw status, /subway-fe logs)
+  // Skip "subway" — /subway is owned by the mesh command (subway-mesh.ts or standalone ext).
+  // The tenet_service tool still covers all services including subway.
+  const reservedNames = new Set(["subway"])
+
+  for (const svc of services) {
+    if (reservedNames.has(svc.name)) continue
+    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" })
+      },
+    })
+  }
+}