Sync packages from monorepo (945232a)

Author: github-actions[bot]

packages/cli/src/commands/game/create.ts

@@ -110,7 +110,10 @@ export const gameCreate = async (args: string[]) => {
     login(opts.accessToken)
   }
 
-  // Step 7: Write .mcp.json with dev server config
+  // Step 7: Write .gitignore
+  fs.writeFileSync(path.join(gameDir, ".gitignore"), ["node_modules", "dist", ".DS_Store", ".yarn", ".pnp.*", ".puzzmo", ""].join("\n"))
+
+  // Step 8: Write .mcp.json with dev server config
   const token = getToken()
   const mcpConfig = {
     mcpServers: {

packages/cli/src/skills/mcp-client.ts

@@ -0,0 +1,73 @@
+import fs from "node:fs"
+import path from "node:path"
+
+type McpConfig = {
+  mcpServers: Record<string, { url: string; headers?: Record<string, string> }>
+}
+
+/** Reads the .mcp.json config from the game directory */
+const readMcpConfig = (gameDir: string): McpConfig | null => {
+  const mcpPath = path.join(gameDir, ".mcp.json")
+  if (!fs.existsSync(mcpPath)) return null
+  try {
+    return JSON.parse(fs.readFileSync(mcpPath, "utf-8"))
+  } catch {
+    return null
+  }
+}
+
+/** Sends a JSON-RPC request to the MCP server and parses the SSE response */
+const mcpRequest = async (url: string, headers: Record<string, string>, method: string, params: any = {}): Promise<any> => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      ...headers,
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+  })
+
+  const text = await response.text()
+  // Parse SSE format: lines starting with "data: " contain the JSON payload
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("data: ")) continue
+    try {
+      const parsed = JSON.parse(line.slice(6))
+      if (parsed.result) return parsed.result
+    } catch {}
+  }
+  return null
+}
+
+/** Returns the MCP server URL from .mcp.json, or null if not configured */
+export const getMcpUrl = (gameDir: string): string | null => {
+  const config = readMcpConfig(gameDir)
+  if (!config) return null
+  const server = Object.values(config.mcpServers)[0]
+  return server?.url ?? null
+}
+
+/** Fetches a skill prompt's content from the MCP server configured in .mcp.json */
+export const fetchSkillPrompt = async (skillName: string, gameDir: string): Promise<string | null> => {
+  const config = readMcpConfig(gameDir)
+  if (!config) return null
+
+  const server = Object.values(config.mcpServers)[0]
+  if (!server) return null
+
+  try {
+    const result = await mcpRequest(server.url, server.headers ?? {}, "prompts/get", { name: skillName })
+    if (!result?.messages?.length) return null
+
+    return result.messages
+      .map((m: any) => {
+        if (typeof m.content === "string") return m.content
+        if (m.content?.text) return m.content.text
+        return ""
+      })
+      .join("\n")
+  } catch {
+    return null
+  }
+}

packages/cli/src/skills/runner.ts

@@ -2,10 +2,24 @@ import { spawnSync } from "node:child_process"
 
 import { skillsPipeline } from "./registry.js"
 import { verifyBuild, runCommand, gitCommit } from "../util/exec.js"
+import { getMcpUrl } from "./mcp-client.js"
 
-/** Builds the agent prompt for a given skill, referencing the MCP prompt */
-const buildPrompt = (skillName: string): string => {
-  return `Use the MCP prompt "${skillName}" from the dev.puzzmo.com server and follow its instructions. The game source is in the current directory.`
+const buildPrompt = (skillName: string, mcpUrl: string | null): string => {
+  if (!mcpUrl) return `Run the skill "${skillName}". The game source is in the current directory.`
+
+  return `First, fetch the skill instructions by using WebFetch to make a POST request to:
+${mcpUrl}
+
+With headers:
+- Content-Type: application/json
+- Accept: application/json, text/event-stream
+
+And body:
+{"jsonrpc":"2.0","id":1,"method":"prompts/get","params":{"name":"${skillName}"}}
+
+The response will be in SSE format. Parse the "data:" line to get the JSON result, which contains the skill instructions in result.messages[0].content.text.
+
+Then follow those instructions. The game source is in the current directory.`
 }
 
 /** Invokes an LLM agent with a prompt (plain mode, stdio inherited) */
@@ -36,7 +50,8 @@ export const runSkillsPipeline = async (agent: string, gameDir: string) => {
     const step = i + 1
     console.log(`[${step}/${total}] Running skill: ${skill.name}${skill.optional ? " (optional)" : ""}`)
 
-    const prompt = buildPrompt(skill.name)
+    const mcpUrl = getMcpUrl(gameDir)
+    const prompt = buildPrompt(skill.name, mcpUrl)
     let result = invokeAgent(agent, prompt, gameDir)
 
     if (!result.success) {

packages/cli/src/tui/pipeline.ts

@@ -5,6 +5,7 @@ import path from "node:path"
 import { execSync } from "node:child_process"
 
 import { skillsPipeline } from "../skills/registry.js"
+import { getMcpUrl } from "../skills/mcp-client.js"
 
 type StepState = "pending" | "running" | "success" | "failed" | "skipped"
 type Phase = "agent" | "build" | "commit" | "idle"
@@ -57,24 +58,42 @@ const buildAgentCmd = (agent: string, prompt: string): { cmd: string; args: stri
   return { cmd: agent, args: [prompt] }
 }
 
-const buildPrompt = (skillName: string): string => {
-  return `Use the MCP prompt "${skillName}" from the dev.puzzmo.com server and follow its instructions. The game source is in the current directory.`
+const buildPrompt = (skillName: string, mcpUrl: string | null): string => {
+  if (!mcpUrl) return `Run the skill "${skillName}". The game source is in the current directory.`
+
+  return `First, fetch the skill instructions by using WebFetch to make a POST request to:
+${mcpUrl}
+
+With headers:
+- Content-Type: application/json
+- Accept: application/json, text/event-stream
+
+And body:
+{"jsonrpc":"2.0","id":1,"method":"prompts/get","params":{"name":"${skillName}"}}
+
+The response will be in SSE format. Parse the "data:" line to get the JSON result, which contains the skill instructions in result.messages[0].content.text.
+
+Then follow those instructions. The game source is in the current directory.`
 }
 
 class PipelineTUI {
   private states: StepState[]
   private currentStep = 0
   private outputLines: string[] = []
+  private chatLines: string[] = []
   private phase: Phase = "idle"
   private done = false
   private activeProc: ChildProcess | null = null
   private sidebarWidth = 30
+  private logsDir: string
 
   constructor(
     private agent: string,
     private gameDir: string,
   ) {
     this.states = skillsPipeline.map(() => "pending")
+    this.logsDir = path.join(gameDir, ".puzzmo", "logs")
+    fs.mkdirSync(this.logsDir, { recursive: true })
   }
 
   private get rows(): number {
@@ -205,13 +224,13 @@ class PipelineTUI {
     for (const line of rawLines) {
       const parsed = this.parseStreamLine(line)
       if (parsed) {
-        // Split multi-line parsed output into separate display lines
         for (const displayLine of parsed.split("\n")) {
           this.outputLines.push(displayLine)
+          this.chatLines.push(this.stripAnsi(displayLine))
         }
       }
     }
-    // Keep buffer bounded
+    // Keep display buffer bounded, but chatLines grows unbounded per skill
     if (this.outputLines.length > 500) {
       this.outputLines = this.outputLines.slice(-this.maxOutputLines)
     }
@@ -389,21 +408,25 @@ class PipelineTUI {
     this.states[stepIndex] = "running"
     this.currentStep = stepIndex
     this.outputLines = []
+    this.chatLines = []
     this.phase = "agent"
     this.render()
 
-    const prompt = buildPrompt(skill.name)
+    const mcpUrl = getMcpUrl(this.gameDir)
+    const prompt = buildPrompt(skill.name, mcpUrl)
     let success = await this.runAgent(prompt)
 
     if (!success) {
       if (skill.optional) {
+        this.writeSkillLog(skill.name)
         this.states[stepIndex] = "skipped"
         this.render()
         return true
       }
       this.appendOutput("\n--- Retrying ---\n")
       success = await this.runAgent(prompt)
       if (!success) {
+        this.writeSkillLog(skill.name)
         this.states[stepIndex] = "failed"
         this.render()
         return false
@@ -423,10 +446,12 @@ class PipelineTUI {
       const retry = this.runCmd("npx vite build")
       if (!retry.success) {
         if (skill.optional) {
+          this.writeSkillLog(skill.name)
           this.states[stepIndex] = "skipped"
           this.render()
           return true
         }
+        this.writeSkillLog(skill.name)
         this.states[stepIndex] = "failed"
         this.render()
         return false
@@ -441,11 +466,20 @@ class PipelineTUI {
     if (commitResult.success) this.appendOutput("Committed.")
     else this.appendOutput("No changes to commit.")
 
+    // Write chat log for this skill
+    this.writeSkillLog(skill.name)
+
     this.states[stepIndex] = "success"
     this.render()
     return true
   }
 
+  /** Writes the collected chat lines for a skill to a log file */
+  private writeSkillLog(skillName: string) {
+    const logPath = path.join(this.logsDir, `${skillName}.txt`)
+    fs.writeFileSync(logPath, this.chatLines.join("\n") + "\n")
+  }
+
   /** Set up keyboard handling (Ctrl+C to quit) */
   private setupInput() {
     if (process.stdin.isTTY) {

skills/introduce-puzzmo-sdk/SKILL.md

@@ -43,26 +43,31 @@ Add the `@puzzmo/sdk` package and wire up the game lifecycle.
    sdk.gameLoaded()
    ```
 
-4. Wire up lifecycle events:
+4. Handle the `start` event to trigger the game start:
 
    ```ts
    sdk.on("start", () => {
-     /* start game logic, timer auto-starts */
+     startGame()
    })
+   ```
+
+5. Wire up other lifecycle events if there is relevant game logic for pause/resume/retry:
+
+   ```ts
    sdk.on("pause", () => {
-     /* pause game was triggered, timer auto-pauses */
+     /* pause game was triggered, system timer auto-pauses */
    })
    sdk.on("resume", () => {
-     /* resume game was triggered, timer auto-resumes */
+     /* resume game was triggered, system timer auto-resumes */
    })
    sdk.on("retry", () => {
-     /* retry game was triggered, timer auto-resets, */
+     /* retry game was triggered, system timer auto-resets, */
    })
    ```
 
-5. Wire up state saving - call `sdk.updateGameState(stateString)` whenever the game state changes so the host can save progress.
+6. Wire up state saving - call `sdk.updateGameState(stateString)` whenever the game state changes so the host can save progress.
 
-6. Create puzzle fixture files for local testing. Make a `fixtures/puzzles/` directory and add a few different puzzle JSON files that exercise different aspects of the game:
+7. Create puzzle fixture files for local testing. Make a `fixtures/puzzles/` directory and add a few different puzzle JSON files that exercise different aspects of the game:
 
    ```
    fixtures/puzzles/
@@ -78,7 +83,7 @@ Add the `@puzzmo/sdk` package and wire up the game lifecycle.
 
    If the original game already has a few puzzles hardcoded, use those as a starting point for creating the fixture files. Then delete the buttons which may have been used to load them, since the simulator will handle loading puzzles from the fixtures.
 
-7. Set up the dev simulator for local testing. Add the Vite plugin to `vite.config.ts`:
+8. Set up the dev simulator for local testing. Add the Vite plugin to `vite.config.ts`:
 
    ```ts
    import { defineConfig } from "vite"