jgengine 0.8.0 → 0.8.1

package/dist/cli/index.js

@@ -7,23 +7,30 @@ import { createRequire } from "node:module";
 import { runCreate } from "../create.js";
 import { runDoctor } from "../doctor.js";
 import { cliVersion, findUp, readPackageJson } from "../pkg.js";
+import { runSkills } from "../skills.js";
 const ENGINE_PACKAGES = ["core", "react", "shell", "ws", "sql", "convex", "node", "assets"];
 const HELP = `jgengine ${cliVersion()} — the JGengine command line
 Pure-TypeScript, genre-agnostic game engine SDK. Packages: ${ENGINE_PACKAGES.map((name) => `@jgengine/${name}`).join(", ")}.
 
 usage: jgengine <command> [...args]
 
-  create <dir>     scaffold a playable game — flat world, spawned player, HUD, verify test.
-                   [--name <display name>] [--in-repo|--standalone] [--no-install] [--pm bun|npm|pnpm]
-  doctor [dir]     diagnose a game project: version skew, missing peers, unstyled-UI @source gaps, shape drift
-  skills           install the JGengine agent skills (API reference, game-build workflow, verify gate) into .claude/skills
-  llms [package]   print packaged API docs (llms.txt) for an installed @jgengine/* package — agent-ready context
-  assets [...]     delegate to the @jgengine/assets CLI: list, search, pull CC0 3D model packs
-  versions         show CLI + installed @jgengine/* versions
-  help             this map
+  create "<Game Name>"  scaffold a playable base — flat world, spawned player, HUD, verify test.
+                        folder becomes My-Game-Name; name lands in game.config / HUD / title.
+                        [--in-repo|--standalone] [--no-install] [--pm bun|npm|pnpm]
+  skills -p | -g        install agent skills (api, newgame, verify). -p this project (default), -g global
+  doctor [dir]          diagnose a game project: version skew, missing peers, unstyled-UI @source gaps, shape drift
+  llms [package]        print packaged API docs (llms.txt) for an installed @jgengine/* package — agent-ready context
+  assets [...]          delegate to the @jgengine/assets CLI: list, search, pull CC0 3D model packs
+  versions              show CLI + installed @jgengine/* versions
+  help                  this map
 
 docs: https://jgengine.com · source: https://github.com/Noisemaker111/jgengine
-new here (human or agent)? run: npx jgengine create my-game && cd my-game && npx jgengine skills
+
+entry (any directory, no monorepo needed):
+  npx jgengine create "Solitaire"
+  cd Solitaire
+  npx jgengine skills -p          # or: npx jgengine skills -g  (once, for every project)
+  # then: make Solitaire with jgengine
 `;
 function runVersions() {
     console.log(`jgengine ${cliVersion()}`);
@@ -61,14 +68,6 @@ function runLlms(argv) {
     process.stdout.write(readFileSync(join(found, "node_modules", packageName, "llms.txt"), "utf8"));
     return 0;
 }
-function runSkills() {
-    console.log("installing JGengine agent skills (jgengine-api, jgengine-newgame, jgengine-verify)…");
-    const result = spawnSync("npx", ["--yes", "skills", "add", "Noisemaker111/jgengine"], {
-        stdio: "inherit",
-        shell: process.platform === "win32",
-    });
-    return result.status ?? 1;
-}
 function runAssets(argv) {
     const require = createRequire(import.meta.url);
     let cliPath;
@@ -91,7 +90,7 @@ switch (command) {
         process.exit(runDoctor(rest));
         break;
     case "skills":
-        process.exit(runSkills());
+        process.exit(runSkills(rest));
         break;
     case "llms":
         process.exit(runLlms(rest));

package/dist/create.d.ts

@@ -1,4 +1,4 @@
 import { type TemplateVariant } from "./templates.js";
 export declare function writeGame(targetDir: string, id: string, name: string, variant: TemplateVariant): void;
-export declare function registerRootGameScript(rootDir: string, id: string): boolean;
+export declare function registerRootGameScript(rootDir: string, id: string, folderName?: string): boolean;
 export declare function runCreate(argv: string[]): number;

package/dist/create.js

@@ -1,8 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { cliVersion, findWorkspaceRoot, flag, hasFlag, isEngineMonorepo } from "./pkg.js";
-import { displayNameFromId, GAME_ID_PATTERN, gameTemplate } from "./templates.js";
+import { gameTemplate, parseCreateName } from "./templates.js";
 export function writeGame(targetDir, id, name, variant) {
     for (const file of gameTemplate({ id, name, variant, engineVersion: cliVersion() })) {
         const dest = join(targetDir, file.path);
@@ -10,7 +10,7 @@ export function writeGame(targetDir, id, name, variant) {
         writeFileSync(dest, file.contents);
     }
 }
-export function registerRootGameScript(rootDir, id) {
+export function registerRootGameScript(rootDir, id, folderName = id) {
     const rootPackagePath = join(rootDir, "package.json");
     const root = JSON.parse(readFileSync(rootPackagePath, "utf8"));
     const scripts = root.scripts ?? {};
@@ -20,7 +20,7 @@ export function registerRootGameScript(rootDir, id) {
     const entries = Object.entries(scripts);
     const games = entries.filter(([k]) => k.startsWith("games:"));
     const rest = entries.filter(([k]) => !k.startsWith("games:"));
-    games.push([key, `bun run --cwd Games/${id} dev`]);
+    games.push([key, `bun run --cwd Games/${folderName} dev`]);
     games.sort(([a], [b]) => a.localeCompare(b));
     root.scripts = Object.fromEntries([...rest, ...games]);
     writeFileSync(rootPackagePath, `${JSON.stringify(root, null, 2)}\n`);
@@ -32,7 +32,7 @@ function pickPackageManager(preferred) {
     const probe = spawnSync("bun", ["--version"], { stdio: "ignore", shell: process.platform === "win32" });
     return probe.status === 0 ? "bun" : "npm";
 }
-const VALUE_FLAGS = new Set(["--name", "--pm"]);
+const VALUE_FLAGS = new Set(["--pm"]);
 function positionalArg(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
@@ -45,67 +45,98 @@ function positionalArg(argv) {
     }
     return undefined;
 }
+function splitCreateArg(arg) {
+    const normalized = arg.replace(/\\/g, "/").replace(/\/+/g, "/");
+    const trimmed = normalized.replace(/\/$/, "");
+    const slash = trimmed.lastIndexOf("/");
+    if (slash < 0)
+        return { parentHint: null, titlePart: trimmed };
+    return {
+        parentHint: trimmed.slice(0, slash) || ".",
+        titlePart: trimmed.slice(slash + 1),
+    };
+}
+function isInsideDir(child, parent) {
+    const resolvedChild = resolve(child);
+    const resolvedParent = resolve(parent);
+    return resolvedChild === resolvedParent || resolvedChild.startsWith(resolvedParent + sep);
+}
 export function runCreate(argv) {
-    const dirArg = positionalArg(argv);
-    if (dirArg === undefined) {
-        console.error("usage: jgengine create <dir> [--name <display name>] [--in-repo|--standalone] [--no-install] [--pm bun|npm|pnpm]");
-        return 1;
-    }
-    const targetDir = resolve(dirArg);
-    const id = basename(targetDir);
-    if (!GAME_ID_PATTERN.test(id)) {
-        console.error(`error: directory name "${id}" must be kebab-case (lowercase letters, digits, dashes, starting with a letter)`);
-        return 1;
-    }
-    if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
-        console.error(`error: ${targetDir} already exists and is not empty`);
-        return 1;
-    }
-    const workspaceRoot = findWorkspaceRoot(dirname(targetDir));
-    const insideEngineRepo = workspaceRoot !== null && isEngineMonorepo(workspaceRoot);
-    const variant = hasFlag(argv, "standalone")
-        ? "standalone"
-        : hasFlag(argv, "in-repo") || insideEngineRepo
-            ? "in-repo"
-            : "standalone";
-    if (variant === "in-repo" && !insideEngineRepo) {
-        console.error("error: --in-repo requires the target to live under Games/ inside the jgengine engine monorepo");
+    const nameArg = positionalArg(argv);
+    if (nameArg === undefined) {
+        console.error('usage: jgengine create "<Game Name>" [--in-repo|--standalone] [--no-install] [--pm bun|npm|pnpm]');
         return 1;
     }
-    const name = flag(argv, "name") ?? displayNameFromId(id);
-    writeGame(targetDir, id, name, variant);
-    console.log(`created ${name} (${variant}) with ${gameTemplateFileCount()} files in ${targetDir}`);
-    if (variant === "in-repo" && workspaceRoot !== null) {
-        if (registerRootGameScript(workspaceRoot, id)) {
-            console.log(`registered root script "games:${id}" in ${join(workspaceRoot, "package.json")}`);
+    let displayName;
+    let folderName;
+    let id;
+    try {
+        const { parentHint, titlePart } = splitCreateArg(nameArg);
+        ({ displayName, folderName, id } = parseCreateName(titlePart));
+        let parentDir = parentHint !== null ? resolve(parentHint) : process.cwd();
+        let targetDir = join(parentDir, folderName);
+        const workspaceRoot = findWorkspaceRoot(dirname(targetDir)) ?? findWorkspaceRoot(parentDir) ?? findWorkspaceRoot(process.cwd());
+        const insideEngineRepo = workspaceRoot !== null && isEngineMonorepo(workspaceRoot);
+        const variant = hasFlag(argv, "standalone")
+            ? "standalone"
+            : hasFlag(argv, "in-repo") || insideEngineRepo
+                ? "in-repo"
+                : "standalone";
+        if (variant === "in-repo") {
+            if (!insideEngineRepo || workspaceRoot === null) {
+                console.error("error: --in-repo requires the jgengine engine monorepo (packages/core + Games/)");
+                return 1;
+            }
+            if (parentHint === null) {
+                parentDir = join(workspaceRoot, "Games");
+                targetDir = join(parentDir, folderName);
+            }
+            const gamesDir = join(workspaceRoot, "Games");
+            if (!isInsideDir(targetDir, gamesDir)) {
+                console.error(`error: in-repo games must live under Games/ (got ${targetDir}; expected under ${gamesDir})`);
+                return 1;
+            }
         }
+        if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+            console.error(`error: ${targetDir} already exists and is not empty`);
+            return 1;
+        }
+        writeGame(targetDir, id, displayName, variant);
+        console.log(`created ${displayName} (${variant}) → ${targetDir}`);
+        console.log(`  folder ${folderName}  package ${id}  name "${displayName}"`);
+        if (variant === "in-repo" && workspaceRoot !== null) {
+            if (registerRootGameScript(workspaceRoot, id, folderName)) {
+                console.log(`registered root script "games:${id}" in ${join(workspaceRoot, "package.json")}`);
+            }
+            console.log("\nnext steps:");
+            console.log(`  bun install                     # from ${workspaceRoot}`);
+            console.log(`  bun run games:${id}             # play it standalone`);
+            return 0;
+        }
+        let installed = false;
+        if (!hasFlag(argv, "no-install")) {
+            const pm = pickPackageManager(flag(argv, "pm"));
+            console.log(`installing dependencies with ${pm}…`);
+            const install = spawnSync(pm, ["install"], {
+                cwd: targetDir,
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
+            installed = install.status === 0;
+            if (!installed)
+                console.error(`warning: ${pm} install failed — run it manually in ${targetDir}`);
+        }
+        const cdHint = relative(process.cwd(), targetDir) || ".";
         console.log("\nnext steps:");
-        console.log(`  bun install                     # from ${workspaceRoot}`);
-        console.log(`  bun run games:${id}             # play it standalone`);
+        console.log(`  cd ${cdHint}`);
+        if (!installed)
+            console.log("  bun install   # or npm install");
+        console.log("  bun dev                 # or npm run dev — flat world, spawned player, working HUD");
+        console.log("  npx jgengine skills -p  # agent skills in this project (-g for global)");
         return 0;
     }
-    let installed = false;
-    if (!hasFlag(argv, "no-install")) {
-        const pm = pickPackageManager(flag(argv, "pm"));
-        console.log(`installing dependencies with ${pm}…`);
-        const install = spawnSync(pm, ["install"], {
-            cwd: targetDir,
-            stdio: "inherit",
-            shell: process.platform === "win32",
-        });
-        installed = install.status === 0;
-        if (!installed)
-            console.error(`warning: ${pm} install failed — run it manually in ${targetDir}`);
+    catch (error) {
+        console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
     }
-    const cdHint = relative(process.cwd(), targetDir) || ".";
-    console.log("\nnext steps:");
-    console.log(`  cd ${cdHint}`);
-    if (!installed)
-        console.log("  bun install   # or npm install");
-    console.log("  bun dev       # or npm run dev — flat world, spawned player, working HUD");
-    console.log("  npx jgengine skills   # install the JGengine agent skills for AI-assisted building");
-    return 0;
-}
-function gameTemplateFileCount() {
-    return gameTemplate({ id: "probe", name: "Probe", variant: "standalone", engineVersion: "0.0.0" }).length;
 }

package/dist/skills.d.ts

@@ -0,0 +1,9 @@
+export declare const SKILLS_SOURCE = "Noisemaker111/jgengine";
+export type SkillsScope = "global" | "project";
+export declare function parseSkillsArgs(argv: string[]): {
+    scope: SkillsScope;
+} | {
+    error: string;
+};
+export declare function skillsInstallArgs(scope: SkillsScope): string[];
+export declare function runSkills(argv: string[]): number;

package/dist/skills.js

@@ -0,0 +1,65 @@
+import { spawnSync } from "node:child_process";
+export const SKILLS_SOURCE = "Noisemaker111/jgengine";
+export function parseSkillsArgs(argv) {
+    let scope = null;
+    for (const arg of argv) {
+        if (arg === "-g" || arg === "--global") {
+            if (scope === "project")
+                return { error: "use either -g/--global or -p/--project, not both" };
+            scope = "global";
+            continue;
+        }
+        if (arg === "-p" || arg === "--project") {
+            if (scope === "global")
+                return { error: "use either -g/--global or -p/--project, not both" };
+            scope = "project";
+            continue;
+        }
+        if (arg === "-y" || arg === "--yes")
+            continue;
+        if (arg === "-h" || arg === "--help")
+            return { error: "help" };
+        return { error: `unknown skills option: ${arg}` };
+    }
+    return { scope: scope ?? "project" };
+}
+export function skillsInstallArgs(scope) {
+    const args = ["--yes", "skills", "add", SKILLS_SOURCE, "-y", "--all"];
+    if (scope === "global")
+        args.push("-g");
+    return args;
+}
+export function runSkills(argv) {
+    const parsed = parseSkillsArgs(argv);
+    if ("error" in parsed) {
+        if (parsed.error === "help") {
+            console.log(`usage: jgengine skills (-g|--global | -p|--project)
+
+  -p, --project   install into this project (.claude/skills) — default
+  -g, --global    install for your user (every project / agent session)
+
+Installs jgengine-api, jgengine-newgame, and jgengine-verify from ${SKILLS_SOURCE}.
+
+entry:
+  npx jgengine create "Solitaire"
+  cd Solitaire
+  npx jgengine skills -p
+  # tell your agent: make Solitaire with jgengine
+
+  # or once for all projects:
+  npx jgengine skills -g
+`);
+            return 0;
+        }
+        console.error(`error: ${parsed.error}`);
+        console.error('usage: jgengine skills (-g|--global | -p|--project)');
+        return 1;
+    }
+    const where = parsed.scope === "global" ? "globally" : "in this project";
+    console.log(`installing JGengine agent skills ${where} (jgengine-api, jgengine-newgame, jgengine-verify)…`);
+    const result = spawnSync("npx", skillsInstallArgs(parsed.scope), {
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+    return result.status ?? 1;
+}

package/dist/templates.d.ts

@@ -10,6 +10,15 @@ export interface TemplateFile {
     contents: string;
 }
 export declare const GAME_ID_PATTERN: RegExp;
+export declare const FOLDER_NAME_PATTERN: RegExp;
 export declare function displayNameFromId(id: string): string;
+export declare function displayNameFromInput(input: string): string;
+export declare function folderNameFromTitle(input: string): string;
+export declare function packageIdFromFolder(folder: string): string;
+export declare function parseCreateName(input: string): {
+    displayName: string;
+    folderName: string;
+    id: string;
+};
 export declare const IN_REPO_TSCONFIG_PATHS: Record<string, string[]>;
 export declare function gameTemplate(options: TemplateOptions): TemplateFile[];

package/dist/templates.js

@@ -1,10 +1,58 @@
 export const GAME_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+export const FOLDER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]*$/;
 export function displayNameFromId(id) {
     return id
         .split("-")
+        .filter((word) => word.length > 0)
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join(" ");
 }
+export function displayNameFromInput(input) {
+    const trimmed = input.trim().replace(/\s+/g, " ");
+    if (trimmed.length === 0) {
+        throw new Error("game name must not be empty");
+    }
+    if (/\s/.test(trimmed))
+        return trimmed;
+    if (trimmed.includes("-"))
+        return displayNameFromId(trimmed.toLowerCase());
+    return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+export function folderNameFromTitle(input) {
+    const cleaned = input
+        .trim()
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "")
+        .replace(/\s+/g, " ");
+    if (cleaned.length === 0) {
+        throw new Error("game name must not be empty");
+    }
+    const folder = cleaned
+        .split(" ")
+        .filter((part) => part.length > 0)
+        .join("-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!FOLDER_NAME_PATTERN.test(folder)) {
+        throw new Error(`folder name "${folder}" must start with a letter and contain only letters, digits, and dashes`);
+    }
+    return folder;
+}
+export function packageIdFromFolder(folder) {
+    const id = folder
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!GAME_ID_PATTERN.test(id)) {
+        throw new Error(`package id "${id}" must be kebab-case: lowercase letters, digits, dashes, starting with a letter`);
+    }
+    return id;
+}
+export function parseCreateName(input) {
+    const displayName = displayNameFromInput(input);
+    const folderName = folderNameFromTitle(input);
+    const id = packageIdFromFolder(folderName);
+    return { displayName, folderName, id };
+}
 const indexHtml = (name) => `<!doctype html>
 <html lang="en">
   <head>
@@ -301,7 +349,7 @@ const agentsMd = (name, variant) => `# ${name} — agent notes
 This is a JGengine game (pure-TypeScript engine SDK, \`@jgengine/*\` on npm). Load context before writing code:
 
 - Engine API surface: \`npx jgengine llms core\` (any package name works) prints the packaged API docs.
-- Agent skills — API reference, phased game-build workflow, browserless verify gate: \`npx jgengine skills\` installs them into \`.claude/skills\`.
+- Agent skills — API reference, phased game-build workflow, browserless verify gate: \`npx jgengine skills -p\` (this project) or \`-g\` (global).
 - Setup broken or UI unstyled: \`npx jgengine doctor\`.
 
 Rules this project follows:

package/llms.txt

@@ -1,7 +1,7 @@
 # @jgengine/jgengine
-> The JGengine command line — scaffold a playable game, diagnose a broken setup, and load engine docs and agent skills into any project. Start with `npx jgengine create <dir>`.
+> The JGengine command line — scaffold a playable game, diagnose a broken setup, and load engine docs and agent skills into any project. Start with `npx jgengine create "My Game Name"`.
 
-Version: 0.8.0
+Version: 0.8.1
 License: AGPL-3.0-only
 Repository: https://github.com/Noisemaker111/jgengine
 Docs: https://jgengine.com
@@ -12,7 +12,7 @@ Imports use deep paths: `@jgengine/jgengine/<path>`.
 ### @jgengine/jgengine/create
 
 - writeGame (function): function writeGame(targetDir: string, id: string, name: string, variant: TemplateVariant): void
-- registerRootGameScript (function): function registerRootGameScript(rootDir: string, id: string): boolean
+- registerRootGameScript (function): function registerRootGameScript(rootDir: string, id: string, folderName: string = id): boolean
 - runCreate (function): function runCreate(argv: string[]): number
 
 ### @jgengine/jgengine/doctor
@@ -32,7 +32,7 @@ Imports use deep paths: `@jgengine/jgengine/<path>`.
 - TemplateVariant (type): type TemplateVariant = "standalone" | "in-repo"
 - runCreate (function): function runCreate(argv: string[]): number
 - writeGame (function): function writeGame(targetDir: string, id: string, name: string, variant: TemplateVariant): void
-- registerRootGameScript (function): function registerRootGameScript(rootDir: string, id: string): boolean
+- registerRootGameScript (function): function registerRootGameScript(rootDir: string, id: string, folderName: string = id): boolean
 - diagnose (function): function diagnose(dir: string): Finding[]
 - runDoctor (function): function runDoctor(argv: string[]): number
 - Finding (interface): interface Finding
@@ -49,14 +49,27 @@ Imports use deep paths: `@jgengine/jgengine/<path>`.
 - hasFlag (function): function hasFlag(argv: string[], name: string): boolean
 - PackageJson (interface): interface PackageJson
 
+### @jgengine/jgengine/skills
+
+- parseSkillsArgs (function): function parseSkillsArgs(argv: string[]): { scope: SkillsScope } | { error: string }
+- skillsInstallArgs (function): function skillsInstallArgs(scope: SkillsScope): string[]
+- runSkills (function): function runSkills(argv: string[]): number
+- SKILLS_SOURCE (const): const SKILLS_SOURCE: "Noisemaker111/jgengine"
+- SkillsScope (type): type SkillsScope = "global" | "project"
+
 ### @jgengine/jgengine/templates
 
 - displayNameFromId (function): function displayNameFromId(id: string): string
+- displayNameFromInput (function): function displayNameFromInput(input: string): string
+- folderNameFromTitle (function): function folderNameFromTitle(input: string): string
+- packageIdFromFolder (function): function packageIdFromFolder(folder: string): string
+- parseCreateName (function): function parseCreateName(input: string): { displayName: string; folderName: string; id: string }
 - gameTemplate (function): function gameTemplate(options: TemplateOptions): TemplateFile[]
 - TemplateVariant (type): type TemplateVariant = "standalone" | "in-repo"
 - TemplateOptions (interface): interface TemplateOptions
 - TemplateFile (interface): interface TemplateFile
 - GAME_ID_PATTERN (const): const GAME_ID_PATTERN: RegExp
+- FOLDER_NAME_PATTERN (const): const FOLDER_NAME_PATTERN: RegExp
 - IN_REPO_TSCONFIG_PATHS (const): const IN_REPO_TSCONFIG_PATHS: Record<string, string[]>
 
 ## Guides
@@ -292,8 +305,11 @@ Exact import paths and export names — **do not invent paths**; every row below
 Fastest path — the `jgengine` CLI scaffolds the entire canonical shape below (harness, skeleton, stub game, verify test, AGENTS.md) as a booting game:
 
 ```sh
-npx jgengine create my-game   # then: cd my-game && bun dev
-npx jgengine doctor           # later, if the setup drifts (version skew, unstyled HUD, shape strays)
+npx jgengine create "My Game Name"   # folder → My-Game-Name; name lands in game.config / HUD / title
+cd My-Game-Name
+npx jgengine skills -p               # agent skills here; use -g once for global
+bun dev
+npx jgengine doctor                  # later, if the setup drifts (version skew, unstyled HUD, shape strays)
 ```
 
 Manual equivalent:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jgengine",
-  "version": "0.8.0",
-  "description": "The JGengine command line — scaffold a playable game, diagnose a broken setup, and load engine docs and agent skills into any project. Start with `npx jgengine create <dir>`.",
+  "version": "0.8.1",
+  "description": "The JGengine command line — scaffold a playable game, diagnose a broken setup, and load engine docs and agent skills into any project. Start with `npx jgengine create \"My Game Name\"`.",
   "license": "AGPL-3.0-only",
   "type": "module",
   "sideEffects": false,