@waica/cli 0.6.1 → 0.7.0

package/dist/mcp/project-component-loader.js

@@ -7,6 +7,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
+import { KNOWN_ARCHETYPES } from './known-archetypes.js';
 import { directFiles } from './project-path.js';
 export const PROJECT_COMPONENT_PROTOCOL_VERSION = 1;
 export const PROJECT_COMPONENT_DEADLINE_MS = 5_000;
@@ -16,7 +17,7 @@ const REF_KINDS = new Set(['prefab', 'clip', 'action', 'stat']);
 const FALLBACK_PACKAGE_DIRECTORIES = [
     ['@waica/engine', 'engine'],
     ['@waica/behaviors', 'behaviors'],
-    ['@waica/archetype-platformer', 'archetype-platformer'],
+    ...KNOWN_ARCHETYPES.map(({ packageName, directory }) => [packageName, directory]),
 ];
 const execFileAsync = promisify(execFile);
 let sourceFallbackEntries;

package/dist/mcp/project-component-runner.js

@@ -5,10 +5,14 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 const PROTOCOL_VERSION = 1;
 const { createRequire } = nodeModule;
 const hostRequire = createRequire(import.meta.url);
+// This file runs as a standalone forked child (see runnerFromModule in the
+// loader) and cannot import siblings, so it mirrors known-archetypes.ts by
+// hand: one entry per KNOWN_ARCHETYPES row, plus engine and behaviors.
 const FALLBACK_PACKAGES = new Set([
     '@waica/engine',
     '@waica/behaviors',
     '@waica/archetype-platformer',
+    '@waica/archetype-topdown',
 ]);
 const FALLBACK_SPECIFIERS = new Set([...FALLBACK_PACKAGES, 'three']);
 const REF_KINDS = new Set(['prefab', 'clip', 'action', 'stat']);

package/dist/mcp/server.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { createProject } from './create-project.js';
+import { DEFAULT_ARCHETYPE_ID, knownArchetype, knownArchetypeIds, } from './known-archetypes.js';
 import { describeArchetype, listComponents, projectSummary, } from './introspection.js';
 import { ABSOLUTE_PATH_MESSAGE, WaicaToolError, assertAbsoluteProjectPath, requireWaicaProject, } from './project-path.js';
 import { scaffoldComponent, scaffoldPrefab, scaffoldRole, scaffoldState, scaffoldUi, } from './scaffolds.js';
@@ -34,6 +35,12 @@ export const TOOLS = [
                 default: 'demo',
                 description: 'demo includes archetype content; blank creates only the chassis.',
             },
+            archetype: {
+                type: 'string',
+                enum: knownArchetypeIds(),
+                default: DEFAULT_ARCHETYPE_ID,
+                description: 'Archetype the project is created for.',
+            },
         }),
         annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: false },
     },
@@ -352,7 +359,17 @@ async function execute(name, args, runtime, signal, componentLoader) {
                     projectPath,
                 });
             }
-            return { ...(await createProject(projectPath, start)) };
+            const archetype = args.archetype === undefined
+                ? DEFAULT_ARCHETYPE_ID
+                : requiredString(args, 'archetype', projectPath);
+            if (!knownArchetype(archetype)) {
+                throw new WaicaToolError({
+                    code: 'unknown-archetype',
+                    message: `Unknown archetype "${archetype}"; available: ${knownArchetypeIds().join(', ')}.`,
+                    projectPath,
+                });
+            }
+            return { ...(await createProject(projectPath, start, archetype)) };
         }
         case 'list_components':
             return listComponents(projectPath);

package/dist/mcp/template/package.json.tpl

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@waica/archetype-platformer": "^__WAICA_VERSION__",
+    "__ARCHETYPE_PACKAGE__": "^__WAICA_VERSION__",
     "@waica/behaviors": "^__WAICA_VERSION__",
     "@waica/engine": "^__WAICA_VERSION__"
   },

package/dist/mcp/template/src/main.ts

@@ -2,11 +2,12 @@ import {
   collectModuleComponents,
   Game,
   installArchetype,
+  installDirectionalAnimation,
   loadScene,
   mergeRegistryComponents,
   type PrefabJson,
 } from '@waica/engine'
-import { PLATFORMER_BUNDLE, PLATFORMER_REGISTRY } from '@waica/archetype-platformer'
+import { ARCHETYPE } from '__ARCHETYPE_PACKAGE__'
 import scene from './scenes/main.scene.json'
 import controls from './controls.json'
 import stats from './stats.json'
@@ -60,14 +61,14 @@ for (const [path, url] of Object.entries(artFiles)) {
 }
 
 const registryBase = {
-  ...PLATFORMER_REGISTRY,
+  ...ARCHETYPE.registry,
   // Keep these two: the spread above carries the archetype's own catalogs,
   // and these replace them with yours. Drop one and the game starts
   // resolving pieces that are nowhere in src/.
   prefabs,
   ui,
   resolveAsset: (uri: string) =>
-    artUrls[uri] ?? PLATFORMER_REGISTRY.resolveAsset?.(uri) ?? uri,
+    artUrls[uri] ?? ARCHETYPE.registry.resolveAsset?.(uri) ?? uri,
 }
 
 const canvas = document.querySelector<HTMLCanvasElement>('#game')
@@ -82,7 +83,10 @@ if (canvas.dataset.waica) {
 }
 
 async function main(canvas: HTMLCanvasElement): Promise<void> {
-  installArchetype(PLATFORMER_BUNDLE)
+  installArchetype(ARCHETYPE.bundle)
+  // installArchetype resets the directional registry, so the contract goes
+  // right after it (archetypes without one install null — a no-op).
+  installDirectionalAnimation(ARCHETYPE.animation ?? null)
   const projectModules = await Promise.all(Object.values(projectCode).map((load) => load()))
   const registry = mergeRegistryComponents(
     registryBase,

package/dist/mcp/workspace-runtime.js

@@ -1,11 +1,12 @@
 import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { KNOWN_ARCHETYPES } from './known-archetypes.js';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const WORKSPACE_DIRECTORIES = {
     '@waica/engine': 'engine',
     '@waica/behaviors': 'behaviors',
-    '@waica/archetype-platformer': 'archetype-platformer',
+    ...Object.fromEntries(KNOWN_ARCHETYPES.map(({ packageName, directory }) => [packageName, directory])),
 };
 let workspaceHooks;
 let workspacePackages;
@@ -68,6 +69,40 @@ export async function workspacePackageRoot(packageName) {
     workspacePackages ??= loadWorkspacePackages();
     return (await workspacePackages).get(packageName);
 }
+/**
+ * Which workspace mappings the runtime hook should install. Engine and
+ * behaviors gate the whole plan — nothing loads without them — but each
+ * archetype only gates itself: a missing archetype dist drops that
+ * archetype's mappings with a warning instead of disabling every mapping.
+ */
+export async function planWorkspaceRuntime(repositoryRoot, fileExists = exists) {
+    const core = {
+        '@waica/engine': path.join(repositoryRoot, 'packages/engine/dist/index.js'),
+        '@waica/behaviors': path.join(repositoryRoot, 'packages/behaviors/dist/index.js'),
+    };
+    if (!(await Promise.all(Object.values(core).map(fileExists))).every(Boolean))
+        return undefined;
+    const files = { ...core };
+    const directories = ['engine', 'behaviors'];
+    const warnings = [];
+    for (const { packageName, directory } of KNOWN_ARCHETYPES) {
+        const index = path.join(repositoryRoot, 'packages', directory, 'dist/index.js');
+        const manifest = path.join(repositoryRoot, 'packages', directory, 'dist/manifest.js');
+        if ((await fileExists(index)) && (await fileExists(manifest))) {
+            files[packageName] = index;
+            files[`${packageName}/manifest`] = manifest;
+            directories.push(directory);
+        }
+        else {
+            warnings.push(`waica-mcp: workspace archetype ${packageName} has no built dist; its workspace mappings were skipped.`);
+        }
+    }
+    return {
+        mappings: Object.fromEntries(Object.entries(files).map(([specifier, file]) => [specifier, pathToFileURL(file).href])),
+        parentPrefixes: directories.map((directory) => `${pathToFileURL(path.join(repositoryRoot, 'packages', directory, 'dist')).href}/`),
+        warnings,
+    };
+}
 /**
  * Built workspace packages still import one another by bare package name while
  * checkout exports point at source TypeScript. Map only imports whose parent is
@@ -78,16 +113,12 @@ export async function prepareWorkspaceRuntime() {
     const repositoryRoot = await findWorkspaceRoot();
     if (repositoryRoot === undefined)
         return;
-    const files = {
-        '@waica/engine': path.join(repositoryRoot, 'packages/engine/dist/index.js'),
-        '@waica/behaviors': path.join(repositoryRoot, 'packages/behaviors/dist/index.js'),
-        '@waica/archetype-platformer': path.join(repositoryRoot, 'packages/archetype-platformer/dist/index.js'),
-        '@waica/archetype-platformer/manifest': path.join(repositoryRoot, 'packages/archetype-platformer/dist/manifest.js'),
-    };
-    if (!(await Promise.all(Object.values(files).map(exists))).every(Boolean))
+    const plan = await planWorkspaceRuntime(repositoryRoot);
+    if (plan === undefined)
         return;
-    const mappings = Object.fromEntries(Object.entries(files).map(([specifier, file]) => [specifier, pathToFileURL(file).href]));
-    const parentPrefixes = ['engine', 'behaviors', 'archetype-platformer'].map((directory) => `${pathToFileURL(path.join(repositoryRoot, 'packages', directory, 'dist')).href}/`);
+    for (const warning of plan.warnings)
+        console.warn(warning);
+    const { mappings, parentPrefixes } = plan;
     const moduleApi = await import('node:module');
     if (typeof moduleApi.registerHooks === 'function') {
         workspaceHooks = moduleApi.registerHooks({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waica/cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Waica in one command — `npx @waica/cli` opens the editor, `waica mcp` serves the MCP server",
   "license": "MIT",
   "type": "module",