@puzzmo/cli 1.0.33 → 1.0.34

package/src/agents/stream-json-cli.ts

@@ -0,0 +1,86 @@
+import { spawn, type ChildProcess } from "node:child_process"
+
+import type { AgentEvent, RunInput } from "./types.js"
+
+/** Shared driver for any CLI that emits NDJSON over stdout when given a prompt
+ *  in print/headless mode. Used by both the claude and gemini adapters. */
+export type StreamJsonCliConfig = {
+  cmd: string
+  buildArgs: (prompt: string) => string[]
+  /** Map one parsed JSON line to an AgentEvent (or null to drop). */
+  parseLine: (line: string) => AgentEvent | null
+  /** Optional env mutator. Receives a copy of process.env. */
+  env?: (base: NodeJS.ProcessEnv) => NodeJS.ProcessEnv
+}
+
+export const runStreamJsonCli = async function* (config: StreamJsonCliConfig, input: RunInput): AsyncIterable<AgentEvent> {
+  const args = config.buildArgs(input.prompt)
+  const env = config.env ? config.env({ ...process.env }) : { ...process.env }
+
+  let proc: ChildProcess
+  try {
+    proc = spawn(config.cmd, args, {
+      cwd: input.cwd ?? process.cwd(),
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+  } catch (e: any) {
+    yield { type: "error", message: `Failed to spawn ${config.cmd}: ${e.message}` }
+    return
+  }
+
+  if (input.signal) input.signal.addEventListener("abort", () => proc.kill())
+
+  // Bridge node streams + child events into an async generator.
+  const queue: AgentEvent[] = []
+  let done = false
+  let resolveWaiting: (() => void) | null = null
+  let buf = ""
+  let sawResult = false
+
+  const push = (e: AgentEvent) => {
+    if (e.type === "result") sawResult = true
+    queue.push(e)
+    resolveWaiting?.()
+    resolveWaiting = null
+  }
+
+  const flushLine = (line: string) => {
+    if (!line.trim()) return
+    const event = config.parseLine(line)
+    if (event) push(event)
+  }
+
+  proc.stdout?.on("data", (chunk: Buffer) => {
+    buf += chunk.toString("utf8")
+    const lines = buf.split("\n")
+    buf = lines.pop() ?? ""
+    for (const line of lines) flushLine(line)
+  })
+
+  proc.stderr?.on("data", (chunk: Buffer) => {
+    const text = chunk.toString("utf8").trim()
+    if (text) push({ type: "error", message: text })
+  })
+
+  proc.on("close", (code) => {
+    if (buf.trim()) flushLine(buf)
+    if (code !== 0 && !sawResult) push({ type: "result", ok: false })
+    done = true
+    resolveWaiting?.()
+    resolveWaiting = null
+  })
+
+  proc.on("error", (err) => {
+    push({ type: "error", message: err.message })
+    done = true
+    resolveWaiting?.()
+    resolveWaiting = null
+  })
+
+  while (true) {
+    if (queue.length > 0) yield queue.shift()!
+    else if (done) return
+    else await new Promise<void>((r) => (resolveWaiting = r))
+  }
+}

package/src/agents/types.ts

@@ -0,0 +1,22 @@
+/** Normalized event union emitted by every agent adapter. Keep this small —
+ *  adapters fold their richer native event shapes into one of these. */
+export type AgentEvent =
+  | { type: "text"; text: string } // assistant text (delta or full chunk)
+  | { type: "tool_use"; name: string; summary: string } // tool starting
+  | { type: "tool_result"; ok: boolean; summary: string } // tool finished
+  | { type: "thinking"; text: string }
+  | { type: "system"; text: string }
+  | { type: "result"; ok: boolean; costUSD?: number }
+  | { type: "error"; message: string }
+
+export type RunInput = {
+  prompt: string
+  cwd?: string
+  signal?: AbortSignal
+}
+
+export interface Agent {
+  readonly name: string
+  /** Yield events as the agent runs. Should complete (or throw) when the run finishes. */
+  run(input: RunInput): AsyncIterable<AgentEvent>
+}

package/src/commands/agent-test.ts

@@ -0,0 +1,81 @@
+import fs from "node:fs"
+
+import * as p from "@clack/prompts"
+
+import { agentNames, getAgent } from "../agents/index.js"
+
+const dim = (s: string) => `\x1b[2m${s}\x1b[0m`
+const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`
+const red = (s: string) => `\x1b[31m${s}\x1b[0m`
+const green = (s: string) => `\x1b[32m${s}\x1b[0m`
+
+/** Undocumented: send "say hello world" to a chosen agent through the meta-library
+ *  and stream events to stdout. Use this to verify each adapter end-to-end. */
+export const agentTest = async () => {
+  p.intro("Agent SDK Test")
+
+  const choice = await p.select({
+    message: "Which agent?",
+    options: agentNames().map((name) => ({ value: name, label: name })),
+    initialValue: "claude",
+  })
+  if (p.isCancel(choice)) process.exit(0)
+  const agent = getAgent(String(choice))
+  if (!agent) {
+    p.log.error(`Unknown agent: ${choice}`)
+    process.exit(1)
+  }
+
+  const prompt = "say hello world"
+  const cwd = process.cwd()
+  const debugPath = "/tmp/puzzmo-agent-test.log"
+  fs.writeFileSync(debugPath, "")
+  const log = (msg: string) => fs.appendFileSync(debugPath, `[${new Date().toISOString()}] ${msg}\n`)
+
+  log(`agent=${agent.name} cwd=${cwd}`)
+  log(`prompt=${JSON.stringify(prompt)}`)
+
+  process.stderr.write(`\n${dim("[agent]")} ${agent.name}\n`)
+  process.stderr.write(`${dim("[cwd]")}   ${cwd}\n`)
+  process.stderr.write(`${dim("[log]")}   ${debugPath}\n`)
+  process.stderr.write(`${dim("---- events below (Ctrl+C to abort) ----")}\n\n`)
+
+  const controller = new AbortController()
+  const onSig = () => {
+    process.stderr.write(`\n${dim("[interrupt]")}\n`)
+    controller.abort()
+  }
+  process.on("SIGINT", onSig)
+
+  const start = Date.now()
+  let count = 0
+  try {
+    for await (const event of agent.run({ prompt, cwd, signal: controller.signal })) {
+      count++
+      const elapsed = ((Date.now() - start) / 1000).toFixed(3)
+      log(`+${elapsed}s ${event.type} ${JSON.stringify(event).slice(0, 400)}`)
+      printEvent(event)
+    }
+  } catch (e: any) {
+    process.stderr.write(`\n${red("[run threw]")} ${e.message ?? e}\n`)
+    log(`THROW ${e.message ?? e}`)
+    process.exit(1)
+  } finally {
+    process.off("SIGINT", onSig)
+  }
+
+  const elapsed = ((Date.now() - start) / 1000).toFixed(3)
+  process.stderr.write(`\n${dim(`[+${elapsed}s done]`)} events=${count}\n`)
+  log(`done events=${count} elapsed=${elapsed}s`)
+}
+
+const printEvent = (e: { type: string } & Record<string, any>) => {
+  if (e.type === "text") process.stdout.write(e.text)
+  else if (e.type === "thinking") process.stdout.write(dim(e.text))
+  else if (e.type === "tool_use") process.stdout.write(`\n${yellow(`[${e.name}]`)} ${dim(e.summary ?? "")}\n`)
+  else if (e.type === "tool_result") process.stdout.write(`${e.ok ? green("  ✓") : red("  ✗")} ${dim(e.summary ?? "")}\n`)
+  else if (e.type === "system") process.stdout.write(dim(`\n[${e.text}]\n`))
+  else if (e.type === "result")
+    process.stdout.write(`\n${e.ok ? green("== Done") : red("== Failed")}${e.costUSD ? ` ($${e.costUSD.toFixed(4)})` : ""}\n`)
+  else if (e.type === "error") process.stdout.write(red(`\n[error] ${e.message}\n`))
+}

package/src/commands/game/create.ts

@@ -3,6 +3,7 @@ import path from "node:path"
 import { createRequire } from "node:module"
 import * as p from "@clack/prompts"
 
+import { agentNames } from "../../agents/index.js"
 import { detectAgent } from "../../wizard/agent-detect.js"
 import { downloadPage } from "../../download/page-downloader.js"
 import { runCommand, gitCommit } from "../../util/exec.js"
@@ -260,10 +261,11 @@ export const gameCreate = async (args: string[]) => {
     gameDir = setupRepoGame(tmpDir, slug, repo.repoRoot, parentFolder)
   }
 
-  // Step 7: Detect agent and run skills pipeline
-  const agents = detectAgent()
+  // Step 7: Detect agent and run skills pipeline. Only offer CLIs we have an adapter for.
+  const supported = new Set(agentNames())
+  const agents = detectAgent().filter((a) => supported.has(a.id))
   const agentChoices = [
-    ...agents.map((a) => ({ value: a.binary, label: `${a.displayName} (${a.path})` })),
+    ...agents.map((a) => ({ value: a.id, label: `${a.displayName} (${a.path})` })),
     { value: "none", label: "None - I'll run the steps manually" },
   ]
 
@@ -274,7 +276,7 @@ export const gameCreate = async (args: string[]) => {
     selectedAgent = (await p.select({ message: "Which LLM agent do you use?", options: agentChoices })) as string
     if (p.isCancel(selectedAgent)) process.exit(0)
   } else {
-    p.log.info("No LLM agents detected (checked: claude, codex)")
+    p.log.info(`No supported LLM agents detected (checked: ${agentNames().join(", ")})`)
     selectedAgent = "none"
   }
 

package/src/index.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { agentTest } from "./commands/agent-test.js"
 import { login } from "./commands/login.js"
 import { upload } from "./commands/upload.js"
 import { validate } from "./commands/validate.js"
@@ -57,6 +58,10 @@ const run = async () => {
       await migrate()
       break
     }
+    case "agent-test": {
+      await agentTest()
+      break
+    }
     default:
       printUsage()
       break