@puzzmo/cli 1.0.37 → 1.0.39

package/src/commands/game/create.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs"
 import path from "node:path"
+import { fileURLToPath } from "node:url"
 import { createRequire } from "node:module"
 import * as p from "@clack/prompts"
 
@@ -7,17 +8,21 @@ 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"
-import { runSkillsPipelineTUI } from "../../skills/runner.js"
+import { runSkillsPipelineTUI, runAgentWithBuildLoop } from "../../skills/runner.js"
 import { login } from "../login.js"
 import { getToken } from "../../util/config.js"
 import { detectRepoContext, type RepoType } from "./detectRepo.js"
 
+type Strategy = "import" | "blank" | "prompt"
+
 type CreateOptions = {
   name?: string
   url?: string
   agent?: string
   accessToken?: string
   pm?: string
+  strategy?: Strategy
+  prompt?: string
 }
 
 /** Parses CLI args into CreateOptions */
@@ -27,16 +32,15 @@ const parseArgs = (args: string[]): CreateOptions => {
 
   while (i < args.length) {
     const arg = args[i]
-    if (arg === "--name" && args[i + 1]) {
-      opts.name = args[++i]
-    } else if (arg === "--url" && args[i + 1]) {
-      opts.url = args[++i]
-    } else if (arg === "--agent" && args[i + 1]) {
-      opts.agent = args[++i]
-    } else if (arg === "--token" && args[i + 1]) {
-      opts.accessToken = args[++i]
-    } else if (arg === "--pm" && args[i + 1]) {
-      opts.pm = args[++i]
+    if (arg === "--name" && args[i + 1]) opts.name = args[++i]
+    else if (arg === "--url" && args[i + 1]) opts.url = args[++i]
+    else if (arg === "--agent" && args[i + 1]) opts.agent = args[++i]
+    else if (arg === "--token" && args[i + 1]) opts.accessToken = args[++i]
+    else if (arg === "--pm" && args[i + 1]) opts.pm = args[++i]
+    else if (arg === "--prompt" && args[i + 1]) opts.prompt = args[++i]
+    else if (arg === "--strategy" && args[i + 1]) {
+      const v = args[++i]
+      if (v === "import" || v === "blank" || v === "prompt") opts.strategy = v
     }
     i++
   }
@@ -49,7 +53,7 @@ const slugify = (text: string) =>
   text
     .toString()
     .normalize("NFD")
-    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[̀-ͯ]/g, "")
     .toLowerCase()
     .trim()
     .replace(/\s+/g, "-")
@@ -157,6 +161,71 @@ const convertToMultiGame = (repoRoot: string): string => {
   return existingName
 }
 
+/** Resolves the bundled template directory by name. Templates ship at packages/cli/templates/<name>/ */
+const resolveTemplateDir = (name: string): string => {
+  const here = fileURLToPath(import.meta.url)
+  // here = .../packages/cli/lib/commands/game/create.js → ../../../templates/<name>
+  return path.resolve(here, "..", "..", "..", "..", "templates", name)
+}
+
+/** File extensions where we apply template variable substitution */
+const textExtension = new Set([".md", ".json", ".html", ".css", ".ts", ".tsx", ".js", ".jsx", ".mjs"])
+
+/** Recursively copies a template directory, substituting placeholders in text files. */
+const copyTemplate = (sourceDir: string, targetDir: string, replacements: Record<string, string>) => {
+  fs.mkdirSync(targetDir, { recursive: true })
+  for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+    const src = path.join(sourceDir, entry.name)
+    const dst = path.join(targetDir, entry.name)
+    if (entry.isDirectory()) {
+      copyTemplate(src, dst, replacements)
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name)
+      if (textExtension.has(ext) || entry.name === ".gitignore") {
+        let content = fs.readFileSync(src, "utf-8")
+        for (const [key, value] of Object.entries(replacements)) content = content.replaceAll(key, value)
+        fs.writeFileSync(dst, content)
+      } else {
+        fs.copyFileSync(src, dst)
+      }
+    }
+  }
+}
+
+/** Picks an agent interactively, returning the agent id or "none" */
+const pickAgent = async (preselected?: string): Promise<string> => {
+  const supported = new Set(agentNames())
+  const agents = detectAgent().filter((a) => supported.has(a.id))
+  if (preselected) return preselected
+  if (agents.length === 0) {
+    p.log.info(`No supported LLM agents detected (checked: ${agentNames().join(", ")})`)
+    return "none"
+  }
+  const choices = [
+    ...agents.map((a) => ({ value: a.id, label: `${a.displayName} (${a.path})` })),
+    { value: "none", label: "None - I'll run the steps manually" },
+  ]
+  const result = (await p.select({ message: "Which LLM agent do you use?", options: choices })) as string
+  if (p.isCancel(result)) process.exit(0)
+  return result
+}
+
+/** Composes the prompt sent to the agent for the "from prompt" strategy */
+const buildPromptStrategyMessage = (userPrompt: string, displayName: string): string =>
+  [
+    `You are scaffolding a Puzzmo game called "${displayName}" in the current directory.`,
+    `The starter is a working Vite + Puzzmo SDK Minesweeper. Replace the gameplay with the game described below.`,
+    ``,
+    `Game description:`,
+    userPrompt,
+    ``,
+    `Constraints:`,
+    `- Keep puzzmo.json valid (do not remove the slug or displayName fields).`,
+    `- Use the Puzzmo SDK lifecycle: gameReady → gameLoaded → on("start"|"retry") → updateGameState → gameCompleted.`,
+    `- Replace fixtures in fixtures/puzzles/ with puzzles for the new game.`,
+    `- Keep the build green (\`npx vite build\` should succeed).`,
+  ].join("\n")
+
 /** Main game create wizard */
 export const gameCreate = async (args: string[]) => {
   const opts = parseArgs(args)
@@ -165,56 +234,105 @@ export const gameCreate = async (args: string[]) => {
   const { version } = require("../../../package.json")
   p.intro(`Puzzmo Game Creator v${version}`)
 
-  // Step 1: Detect repo context and choose mode
+  // Step 1: Pick strategy
+  let strategy: Strategy
+  if (opts.strategy) {
+    strategy = opts.strategy
+  } else {
+    const choice = await p.select({
+      message: "How would you like to create your game?",
+      options: [
+        { value: "blank" as const, label: "Blank game (Minesweeper template)" },
+        { value: "import" as const, label: "Import from an existing URL (uses an LLM to migrate)" },
+        { value: "prompt" as const, label: "From a prompt (Builds on template + LLM customizations)" },
+      ],
+    })
+    if (p.isCancel(choice)) process.exit(0)
+    strategy = choice as Strategy
+  }
+
+  // Step 2: Detect repo and pick placement
   const repo = detectRepoContext()
   const canAddToRepo = repo.repoType === "multi-game" || repo.repoType === "workspace-monorepo" || repo.repoType === "standalone"
 
-  const modeOptions = [
+  const placementOptions = [
     { value: "new-repo" as const, label: "Create game in a new repo" },
     ...(canAddToRepo ? [{ value: "add-to-repo" as const, label: "Add a game to this repo" }] : []),
   ]
-  if (canAddToRepo && repo.repoType !== "none") modeOptions.reverse()
+  if (canAddToRepo && repo.repoType !== "none") placementOptions.reverse()
 
-  const mode = await p.select({
-    message: "How would you like to create your game?",
-    options: modeOptions,
-  })
-
-  if (p.isCancel(mode)) process.exit(0)
-
-  // Step 2: Source URL
-  let url = opts.url
-  if (!url) {
-    url = (await p.text({ message: "Source URL to import", validate: (v) => (!v ? "URL is required" : undefined) })) as string
-    if (p.isCancel(url)) process.exit(0)
+  let mode: "new-repo" | "add-to-repo"
+  if (placementOptions.length === 1) {
+    mode = placementOptions[0].value
+  } else {
+    const selected = await p.select({ message: "Where should the game live?", options: placementOptions })
+    if (p.isCancel(selected)) process.exit(0)
+    mode = selected as "new-repo" | "add-to-repo"
   }
 
-  // Step 3: Download page to a temp dir, extract title
+  // Step 3: Acquire source content into tmpDir
   const tmpDir = path.resolve(".puzzmo-import-tmp")
   if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true })
-  const s = p.spinner()
-  s.start(`Downloading ${url}`)
-  const { title } = await downloadPage(url, tmpDir)
-  s.stop("Download complete.")
+
+  let importedTitle: string | undefined
+  let userPrompt: string | undefined
+
+  if (strategy === "import") {
+    let url = opts.url
+    if (!url) {
+      url = (await p.text({ message: "Source URL to import", validate: (v) => (!v ? "URL is required" : undefined) })) as string
+      if (p.isCancel(url)) process.exit(0)
+    }
+    const s = p.spinner()
+    s.start(`Downloading ${url}`)
+    const { title } = await downloadPage(url, tmpDir)
+    s.stop("Download complete.")
+    importedTitle = title
+  } else if (strategy === "prompt") {
+    userPrompt = opts.prompt
+    if (!userPrompt) {
+      userPrompt = (await p.text({
+        message: "Describe the game you want to build",
+        placeholder: "A word search where letters appear in waves...",
+        validate: (v) => (!v ? "Prompt is required" : undefined),
+      })) as string
+      if (p.isCancel(userPrompt)) process.exit(0)
+    }
+  }
 
   // Step 4: Game name
-  const defaultName = opts.name || title
-  const name = (await p.text({
-    message: "Game name",
-    initialValue: defaultName,
-    validate: (v) => (!v ? "Game name is required" : undefined),
-  })) as string
-  if (p.isCancel(name)) process.exit(0)
+  let name: string
+  if (opts.name) {
+    name = opts.name
+  } else {
+    const result = (await p.text({
+      message: "Game name",
+      initialValue: importedTitle || "My Game",
+      validate: (v) => (!v ? "Game name is required" : undefined),
+    })) as string
+    if (p.isCancel(result)) process.exit(0)
+    name = result
+  }
 
   const slug = slugify(name)
 
+  // Materialize template content for blank/prompt strategies (after we know the slug/name)
+  if (strategy !== "import") {
+    const templateDir = resolveTemplateDir("minesweeper")
+    if (!fs.existsSync(templateDir)) {
+      p.log.error(`Bundled template not found at ${templateDir}`)
+      process.exit(1)
+    }
+    copyTemplate(templateDir, tmpDir, { __SLUG__: slug, __DISPLAY_NAME__: name })
+  }
+
   // Step 5: Login if token provided
   if (opts.accessToken) {
     p.log.step("Logging in...")
     login(opts.accessToken)
   }
 
-  // Step 6: Diamond — set up repo or add to existing
+  // Step 6: Place files
   let gameDir: string
   let repoType: RepoType = repo.repoType
 
@@ -230,14 +348,12 @@ export const gameCreate = async (args: string[]) => {
       process.exit(1)
     }
 
-    // Standalone repo → convert to multi-game first
     if (repo.repoType === "standalone") {
       const existingGame = convertToMultiGame(repo.repoRoot)
       p.log.step(`Moved existing game to games/${existingGame}/`)
       repoType = "multi-game"
     }
 
-    // Determine which folder to place the game in
     let parentFolder: string
     if (repoType === "multi-game") {
       parentFolder = "games"
@@ -261,38 +377,34 @@ export const gameCreate = async (args: string[]) => {
     gameDir = setupRepoGame(tmpDir, slug, repo.repoRoot, parentFolder)
   }
 
-  // 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.id, label: `${a.displayName} (${a.path})` })),
-    { value: "none", label: "None - I'll run the steps manually" },
-  ]
-
-  let selectedAgent: string
-  if (opts.agent) {
-    selectedAgent = opts.agent
-  } else if (agents.length > 0) {
-    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 supported LLM agents detected (checked: ${agentNames().join(", ")})`)
-    selectedAgent = "none"
-  }
-
-  if (selectedAgent !== "none") {
-    const repoContextLines = [
-      `Repo type: ${repoType}`,
-      `Package manager: ${repo.packageManager} (use this instead of npm/npx when running commands or adding dependencies)`,
-    ]
-    if (repoType === "multi-game")
-      repoContextLines.push(
-        "This is a multi-game repo with a shared root package.json. Do not create a per-game package.json or vite config.",
-      )
-    if (repoType === "workspace-monorepo") repoContextLines.push("This is a workspace monorepo. The game has its own package.json.")
-
-    p.log.step("Running Puzzmo migration pipeline...")
-    await runSkillsPipelineTUI(selectedAgent, gameDir, repoContextLines.join("\n"))
+  // Step 7: Strategy-specific agent work
+  if (strategy === "import") {
+    const selectedAgent = await pickAgent(opts.agent)
+    if (selectedAgent !== "none") {
+      const repoContextLines = [
+        `Repo type: ${repoType}`,
+        `Package manager: ${repo.packageManager} (use this instead of npm/npx when running commands or adding dependencies)`,
+      ]
+      if (repoType === "multi-game")
+        repoContextLines.push(
+          "This is a multi-game repo with a shared root package.json. Do not create a per-game package.json or vite config.",
+        )
+      if (repoType === "workspace-monorepo") repoContextLines.push("This is a workspace monorepo. The game has its own package.json.")
+
+      p.log.step("Running Puzzmo migration pipeline...")
+      await runSkillsPipelineTUI(selectedAgent, gameDir, repoContextLines.join("\n"))
+    }
+  } else if (strategy === "prompt") {
+    const selectedAgent = await pickAgent(opts.agent)
+    const message = buildPromptStrategyMessage(userPrompt!, name)
+    if (selectedAgent === "none") {
+      p.log.warn("No agent selected; skipping LLM customization.")
+      p.note(message, "Paste this prompt into your LLM agent:")
+    } else {
+      p.log.step("Running agent with your prompt...")
+      const ok = runAgentWithBuildLoop(selectedAgent, message, gameDir, "from-prompt")
+      if (!ok) p.log.warn("Agent step did not complete cleanly. The Minesweeper starter is still in place.")
+    }
   }
 
   // Done

package/src/commands/upload.ts

@@ -2,16 +2,35 @@ import { execSync } from "node:child_process"
 import crypto from "node:crypto"
 import fs from "node:fs"
 import path from "node:path"
+import * as p from "@clack/prompts"
 
-import { uploadFiles } from "../util/api.js"
+import { GameNotFoundError, uploadFiles } from "../util/api.js"
 import { getAPIURL, getToken } from "../util/config.js"
-import { validatePuzzmoJson } from "../util/validatePuzzmoFile.js"
+import { createUserGame } from "../util/createGame.js"
+import { discoverGames, type DiscoveredGame } from "../util/discoverGames.js"
 
 type UploadOptions = {
   verbose?: boolean
 }
 
-/** Uploads game build artifacts to Puzzmo */
+type GameSuccess = {
+  ok: true
+  slug: string
+  fileCount: number
+  totalBytes: number
+  versionID: string
+  assetsBase: string
+}
+
+type GameFailure = {
+  ok: false
+  slug: string
+  error: string
+}
+
+type GameResult = GameSuccess | GameFailure
+
+/** Uploads game build artifacts to Puzzmo by discovering puzzmo.json files in `dir` */
 export const upload = async (dir: string, options: UploadOptions = {}) => {
   const { verbose = false } = options
   const token = getToken()
@@ -20,68 +39,95 @@ export const upload = async (dir: string, options: UploadOptions = {}) => {
     process.exit(1)
   }
 
-  const distDir = path.resolve(dir)
-  if (!fs.existsSync(distDir)) {
+  const rootDir = path.resolve(dir)
+  if (!fs.existsSync(rootDir)) {
     console.error(`Directory not found: ${dir}`)
     process.exit(1)
   }
 
-  const files = collectFiles(distDir)
-  if (!files.length) {
-    console.error(`Directory is empty: ${dir}`)
+  const { games, errors: discoveryErrors } = await discoverGames(rootDir)
+
+  if (!games.length && !discoveryErrors.length) {
+    console.error(`No puzzmo.json files found under ${rootDir}`)
     process.exit(1)
   }
 
-  // Require and validate puzzmo.json
-  const puzzmoJsonPath = path.join(distDir, "puzzmo.json")
-  if (!fs.existsSync(puzzmoJsonPath)) {
-    console.error(`Missing puzzmo.json in ${dir}`)
-    console.error("Every game upload must include a puzzmo.json file.")
-    process.exit(1)
+  console.log(`Found ${games.length} game(s) under ${rootDir}`)
+  for (const game of games) {
+    console.log(`  - ${game.puzzmoFile.game.slug} (${path.relative(rootDir, game.distDir) || "."})`)
+  }
+  if (discoveryErrors.length) {
+    console.log(`\n${discoveryErrors.length} puzzmo.json file(s) could not be loaded:`)
+    for (const err of discoveryErrors) {
+      console.log(`  - ${err.slug ?? path.relative(rootDir, err.puzzmoJsonPath)}`)
+      for (const e of err.errors) console.log(`      ${e}`)
+    }
   }
 
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(fs.readFileSync(puzzmoJsonPath, "utf-8"))
-  } catch (e) {
-    console.error(`Invalid puzzmo.json: ${e instanceof Error ? e.message : e}`)
-    process.exit(1)
+  const sha = getGitSHA(rootDir) || hashGames(games)
+  const description = getGitMessage(rootDir)
+  const repoURL = getGitRepoURL(rootDir)
+  if (description) console.log(`\nMessage: ${description}`)
+  if (repoURL) console.log(`Repo: ${repoURL}`)
+
+  const apiURL = getAPIURL()
+  const defaultURL = "https://api.puzzmo.com"
+  if (apiURL !== defaultURL) console.log(`API: ${apiURL}`)
+
+  const results: GameResult[] = []
+  for (const err of discoveryErrors) {
+    results.push({ ok: false, slug: err.slug ?? path.relative(rootDir, err.puzzmoJsonPath), error: err.errors.join("; ") })
   }
 
-  const validation = await validatePuzzmoJson(parsed)
-  if (!validation.valid) {
-    console.error(`Invalid puzzmo.json:\n`)
-    for (const err of validation.errors) console.error(`  ${err}`)
-    process.exit(1)
+  for (let i = 0; i < games.length; i++) {
+    const game = games[i]
+    console.log(`\n[${i + 1}/${games.length}] Uploading ${game.puzzmoFile.game.slug}`)
+    try {
+      let result: GameSuccess
+      try {
+        result = await uploadOneGame(game, { token, sha, description, repoURL, verbose, rootDir })
+      } catch (e) {
+        if (!(e instanceof GameNotFoundError)) throw e
+        const created = await maybeCreateMissingGame(e, game, { teamAccessToken: token })
+        if (!created) throw e
+        result = await uploadOneGame(game, { token, sha, description, repoURL, verbose, rootDir })
+      }
+      results.push(result)
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e)
+      console.error(`  Failed: ${message}`)
+      results.push({ ok: false, slug: game.puzzmoFile.game.slug, error: message })
+    }
   }
-  const puzzmoFile = validation.data
-  const gameSlug = puzzmoFile.game.slug
 
-  // Determine SHA
-  const sha = getGitSHA() || hashFiles(files)
-  const description = getGitMessage()
-  const repoURL = getGitRepoURL()
+  printReport(results)
 
-  console.log(`\nUploading ${gameSlug} (${sha.slice(0, 8)})`)
-  console.log(`Directory: ${distDir}`)
-  if (description) console.log(`Message: ${description}`)
-  if (repoURL) console.log(`Repo: ${repoURL}`)
-  console.log("")
+  const anyFailed = results.some((r) => !r.ok)
+  if (anyFailed) process.exit(1)
+}
 
-  let totalBytes = 0
-  for (const file of files) {
-    const size = fs.statSync(file).size
-    totalBytes += size
-    const rel = path.relative(distDir, file)
-    console.log(`  ${rel} (${formatBytes(size)})`)
-  }
+type UploadOneOptions = {
+  token: string
+  sha: string
+  description: string | null
+  repoURL: string | null
+  verbose: boolean
+  rootDir: string
+}
 
-  const apiURL = getAPIURL()
-  const defaultURL = "https://api.puzzmo.com"
+/** Uploads a single discovered game; throws on failure */
+const uploadOneGame = async (game: DiscoveredGame, opts: UploadOneOptions): Promise<GameSuccess> => {
+  const { token, sha, description, repoURL, verbose, rootDir } = opts
+  const { puzzmoFile, distDir } = game
+  const gameSlug = puzzmoFile.game.slug
 
-  console.log(`\n${files.length} file(s), ${formatBytes(totalBytes)} total`)
-  if (apiURL !== defaultURL) console.log(`Uploading to ${apiURL}...`)
-  else console.log("Uploading...")
+  const files = collectFiles(distDir)
+  if (!files.length) throw new Error(`Dist folder is empty: ${distDir}`)
+
+  console.log(`  Directory: ${path.relative(rootDir, distDir) || distDir}`)
+  let totalBytes = 0
+  for (const file of files) totalBytes += fs.statSync(file).size
+  console.log(`  ${files.length} file(s), ${formatBytes(totalBytes)} total (sha ${sha.slice(0, 8)})`)
 
   const result = await uploadFiles(
     token,
@@ -91,13 +137,34 @@ export const upload = async (dir: string, options: UploadOptions = {}) => {
     distDir,
     puzzmoFile,
     (batch, totalBatches, uploaded) => {
-      console.log(`  Batch ${batch}/${totalBatches} done (${uploaded} file(s) uploaded)`)
+      console.log(`    Batch ${batch}/${totalBatches} done (${uploaded} file(s) uploaded)`)
     },
     { verbose, description, repoURL },
   )
 
-  console.log(`\nDone - ${result.versionID}`)
-  console.log(`Assets: ${result.assetsBase}`)
+  console.log(`  Done - ${result.versionID}`)
+  return {
+    ok: true,
+    slug: gameSlug,
+    fileCount: files.length,
+    totalBytes,
+    versionID: result.versionID,
+    assetsBase: result.assetsBase,
+  }
+}
+
+/** Prints a final summary of every game's outcome */
+const printReport = (results: GameResult[]) => {
+  console.log(`\nUpload report (${results.length} game${results.length === 1 ? "" : "s"})`)
+  const successes = results.filter((r): r is GameSuccess => r.ok)
+  const failures = results.filter((r): r is GameFailure => !r.ok)
+  for (const r of successes) {
+    console.log(`  OK   ${r.slug.padEnd(24)} ${formatBytes(r.totalBytes).padStart(8)}  ${r.versionID}`)
+  }
+  for (const r of failures) {
+    console.log(`  FAIL ${r.slug.padEnd(24)} ${r.error}`)
+  }
+  console.log(`\n${successes.length} succeeded, ${failures.length} failed`)
 }
 
 /** Collects all files in a directory recursively */
@@ -113,27 +180,27 @@ const collectFiles = (dir: string): string[] => {
 }
 
 /** Tries to get the shortest unique git SHA, returns null if not in a git repo */
-const getGitSHA = (): string | null => {
+const getGitSHA = (cwd: string): string | null => {
   try {
-    return execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim()
+    return execSync("git rev-parse --short HEAD", { encoding: "utf-8", cwd }).trim()
   } catch {
     return null
   }
 }
 
 /** Gets the subject line of the latest commit, or null if not in a git repo */
-const getGitMessage = (): string | null => {
+const getGitMessage = (cwd: string): string | null => {
   try {
-    return execSync("git log -1 --pretty=%s", { encoding: "utf-8" }).trim() || null
+    return execSync("git log -1 --pretty=%s", { encoding: "utf-8", cwd }).trim() || null
   } catch {
     return null
   }
 }
 
 /** Gets the origin remote URL normalized to https, or null if unavailable */
-const getGitRepoURL = (): string | null => {
+const getGitRepoURL = (cwd: string): string | null => {
   try {
-    const raw = execSync("git config --get remote.origin.url", { encoding: "utf-8" }).trim()
+    const raw = execSync("git config --get remote.origin.url", { encoding: "utf-8", cwd }).trim()
     return raw ? normalizeRepoURL(raw) : null
   } catch {
     return null
@@ -153,15 +220,58 @@ const normalizeRepoURL = (url: string): string => {
   return normalized.replace(/\.git$/, "")
 }
 
-/** Hashes all file contents to produce a deterministic SHA */
-const hashFiles = (filePaths: string[]): string => {
+/** Hashes the dist contents of every game to produce a deterministic SHA across all uploads */
+const hashGames = (games: DiscoveredGame[]): string => {
   const hash = crypto.createHash("sha256")
-  for (const fp of filePaths.sort()) {
-    hash.update(fs.readFileSync(fp))
+  for (const game of games) {
+    for (const file of collectFiles(game.distDir).sort()) {
+      hash.update(file)
+      hash.update(fs.readFileSync(file))
+    }
   }
   return hash.digest("hex").slice(0, 12)
 }
 
+/**
+ * When a game can't be uploaded because it doesn't exist on the user's account,
+ * offer to create it interactively. Returns true if the game was created and the
+ * caller can retry the upload. Returns false otherwise (non-interactive shell or
+ * user declined).
+ */
+const maybeCreateMissingGame = async (
+  err: GameNotFoundError,
+  game: DiscoveredGame,
+  opts: { teamAccessToken: string },
+): Promise<boolean> => {
+  const slug = err.slug
+  const displayName = game.puzzmoFile.game.displayName
+
+  if (!process.stdin.isTTY) {
+    console.error(`  Game "${slug}" not found on your account. Re-run interactively to create it.`)
+    return false
+  }
+
+  const consent = await p.confirm({
+    message: `Game "${slug}" doesn't exist on your account. Create it now (displayName: "${displayName}")?`,
+    initialValue: true,
+  })
+  if (p.isCancel(consent) || !consent) return false
+
+  try {
+    const created = await createUserGame({ displayName, teamAccessToken: opts.teamAccessToken })
+    console.log(`  Created game ${created.slug} (${created.id})`)
+    if (created.slug !== slug) {
+      console.warn(`  Server picked slug "${created.slug}" but your puzzmo.json uses "${slug}". Update puzzmo.json before re-uploading.`)
+      return false
+    }
+    return true
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e)
+    console.error(`  Could not create game: ${message}`)
+    return false
+  }
+}
+
 /** Formats a byte count as a human-readable string */
 const formatBytes = (bytes: number): string => {
   if (bytes < 1024) return `${bytes} B`