@vylos/cli 0.5.4 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vylos/cli",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/DevOpsBenjamin/Vylos"
@@ -17,7 +17,7 @@
     "tailwindcss": "^4.0.0",
     "@tailwindcss/vite": "^4.0.0",
     "tsx": "^4.19.2",
-    "@vylos/core": "0.5.4"
+    "@vylos/core": "0.6.1"
   },
   "devDependencies": {
     "typescript": "^5.7.2"

package/src/vite/projectPlugin.ts

@@ -1,15 +1,150 @@
-import type { Plugin } from 'vite';
+import type { Plugin, ViteDevServer } from 'vite';
 import { resolve } from 'path';
-import { existsSync, cpSync } from 'fs';
+import { existsSync, cpSync, readdirSync } from 'fs';
+
+/** Normalize a path to forward slashes (Windows compatibility). */
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, '/');
+}
+
+/** Escape a string for safe inclusion in a single-quoted JavaScript string literal. */
+function escapeForStringLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
 
 /**
- * Vite plugin that resolves virtual module `vylos:project` to the project's config.
+ * Recursively collect all `.ts` files under `dir`.
+ * Returns absolute paths with forward slashes.
+ */
+function collectTsFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const results: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectTsFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      results.push(normalizePath(full));
+    }
+  }
+  return results;
+}
+
+/** An import alias and its normalized absolute path. */
+interface ImportEntry {
+  alias: string;
+  path: string;
+}
+
+/** List subdirectories under `dir` (returns empty array if dir doesn't exist). */
+function listSubdirs(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => resolve(dir, e.name));
+}
+
+/**
+ * Collect imports from per-location subdirectories and a global directory.
+ * For each location subdirectory, scans `<locationDir>/<subdir>` for .ts files.
+ * Then scans `<globalDir>/<subdir>` for additional .ts files.
+ */
+function collectImports(
+  locationsDir: string,
+  globalDir: string,
+  subdir: string,
+  prefix: string,
+): ImportEntry[] {
+  const imports: ImportEntry[] = [];
+  for (const locDir of listSubdirs(locationsDir)) {
+    for (const file of collectTsFiles(resolve(locDir, subdir))) {
+      imports.push({ alias: `${prefix}${imports.length}`, path: file });
+    }
+  }
+  for (const file of collectTsFiles(resolve(globalDir, subdir))) {
+    imports.push({ alias: `${prefix}${imports.length}`, path: file });
+  }
+  return imports;
+}
+
+/**
+ * Scan the project root and generate the code for the `virtual:vylos-project`
+ * module. Returns eagerly-imported locations, events, actions, and optionally
+ * initLinks.
+ */
+function generateAutoDiscoveryCode(projectRoot: string): string {
+  const locationsDir = resolve(projectRoot, 'locations');
+  const globalDir = resolve(projectRoot, 'global');
+
+  // Discover location definition files
+  const locationImports: ImportEntry[] = [];
+  for (const locDir of listSubdirs(locationsDir)) {
+    const locationFile = resolve(locDir, 'location.ts');
+    if (existsSync(locationFile)) {
+      locationImports.push({
+        alias: `_loc${locationImports.length}`,
+        path: normalizePath(locationFile),
+      });
+    }
+  }
+
+  // Discover event and action files (per-location + global)
+  const eventImports = collectImports(locationsDir, globalDir, 'events', '_evt');
+  const actionImports = collectImports(locationsDir, globalDir, 'actions', '_act');
+
+  // Optional links file
+  const linksPath = resolve(projectRoot, 'links.ts');
+  const hasLinks = existsSync(linksPath);
+
+  // --- Generate code ---
+  const allImports = [...locationImports, ...eventImports, ...actionImports];
+  const lines: string[] = allImports.map(
+    (imp) => `import * as ${imp.alias}_mod from '${escapeForStringLiteral(imp.path)}';`,
+  );
+  if (hasLinks) {
+    lines.push(`import * as _links_mod from '${escapeForStringLiteral(normalizePath(linksPath))}';`);
+  }
+
+  lines.push('');
+  lines.push(`function _unwrap(mod, path) {`);
+  lines.push(`  if (mod.default === undefined || mod.default === null) {`);
+  lines.push(`    console.error('[vylos] File "' + path + '" does not have a default export. Add "export default { ... }" to include it in auto-discovery. Skipping this file.');`);
+  lines.push(`  }`);
+  lines.push(`  return mod.default;`);
+  lines.push(`}`);
+  lines.push('');
+
+  function toUnwrapList(imports: ImportEntry[]): string {
+    return imports.map((imp) => `_unwrap(${imp.alias}_mod, '${escapeForStringLiteral(imp.path)}')`).join(', ');
+  }
+
+  lines.push(`export const locations = [${toUnwrapList(locationImports)}].filter(Boolean);`);
+  lines.push(`export const events = [${toUnwrapList(eventImports)}].filter(Boolean);`);
+  lines.push(`export const actions = [${toUnwrapList(actionImports)}].filter(Boolean);`);
+
+  if (hasLinks) {
+    lines.push(
+      `export const initLinks = _unwrap(_links_mod, '${escapeForStringLiteral(normalizePath(linksPath))}');`,
+    );
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Vite plugin that resolves virtual module `vylos:project` to the project's config,
+ * and `virtual:vylos-project` to auto-discovered locations/events/actions.
  * Also serves project assets in dev and copies them in build.
  */
 export function vylosProjectPlugin(projectRoot: string): Plugin {
   const virtualModuleId = 'vylos:project';
   const resolvedVirtualModuleId = '\0' + virtualModuleId;
 
+  const autoDiscoveryId = 'virtual:vylos-project';
+  const resolvedAutoDiscoveryId = '\0' + autoDiscoveryId;
+
+  let server: ViteDevServer | undefined;
+
   return {
     name: 'vylos-project',
 
@@ -17,26 +152,34 @@ export function vylosProjectPlugin(projectRoot: string): Plugin {
       if (id === virtualModuleId) {
         return resolvedVirtualModuleId;
       }
+      if (id === autoDiscoveryId) {
+        return resolvedAutoDiscoveryId;
+      }
     },
 
     load(id) {
       if (id === resolvedVirtualModuleId) {
-        const configPath = resolve(projectRoot, 'vylos.config.ts');
+        const configPath = normalizePath(resolve(projectRoot, 'vylos.config.ts'));
         const setupPath = resolve(projectRoot, 'setup.ts');
 
-        let code = `export { default as config } from '${configPath.replace(/\\/g, '/')}';\n`;
+        let code = `export { default as config } from '${configPath}';\n`;
 
         if (existsSync(setupPath)) {
-          code += `export { default as plugin } from '${setupPath.replace(/\\/g, '/')}';\n`;
+          code += `export { default as plugin } from '${normalizePath(setupPath)}';\n`;
         } else {
           code += `export const plugin = undefined;\n`;
         }
 
         return code;
       }
+
+      if (id === resolvedAutoDiscoveryId) {
+        return generateAutoDiscoveryCode(projectRoot);
+      }
     },
 
-    configureServer(server) {
+    configureServer(devServer) {
+      server = devServer;
       const assetsDir = resolve(projectRoot, 'assets');
 
       server.middlewares.use((req, _res, next) => {
@@ -45,13 +188,58 @@ export function vylosProjectPlugin(projectRoot: string): Plugin {
         // Rewrite /assets/... to project assets dir
         if (req.url.startsWith('/assets/')) {
           const assetPath = resolve(assetsDir, req.url.slice('/assets/'.length));
-          if (existsSync(assetPath)) {
-            req.url = '/@fs/' + assetPath.replace(/\\/g, '/');
+          const normalizedAssetPath = normalizePath(assetPath);
+          const normalizedAssetsDir = normalizePath(assetsDir);
+          if (normalizedAssetPath.startsWith(normalizedAssetsDir + '/') && existsSync(assetPath)) {
+            req.url = '/@fs/' + normalizedAssetPath;
           }
         }
 
         next();
       });
+
+      // HMR: watch for file add/remove in scanned directories
+      const locationsDir = normalizePath(resolve(projectRoot, 'locations'));
+      const globalEventsDir = normalizePath(
+        resolve(projectRoot, 'global', 'events'),
+      );
+      const globalActionsDir = normalizePath(
+        resolve(projectRoot, 'global', 'actions'),
+      );
+      const linksPath = normalizePath(resolve(projectRoot, 'links.ts'));
+
+      function isInWatchedDir(filePath: string): boolean {
+        const normalized = normalizePath(filePath);
+        return (
+          normalized.startsWith(locationsDir + '/') ||
+          normalized.startsWith(globalEventsDir + '/') ||
+          normalized.startsWith(globalActionsDir + '/')
+        );
+      }
+
+      function isLinksFile(filePath: string): boolean {
+        return normalizePath(filePath) === linksPath;
+      }
+
+      function invalidateAutoDiscovery() {
+        const mod = server?.moduleGraph.getModuleById(resolvedAutoDiscoveryId);
+        if (mod) {
+          server!.moduleGraph.invalidateModule(mod);
+          server!.ws.send({ type: 'full-reload' });
+        }
+      }
+
+      server.watcher.on('add', (filePath) => {
+        if (isLinksFile(filePath) || (filePath.endsWith('.ts') && isInWatchedDir(filePath))) {
+          invalidateAutoDiscovery();
+        }
+      });
+
+      server.watcher.on('unlink', (filePath) => {
+        if (isLinksFile(filePath) || (filePath.endsWith('.ts') && isInWatchedDir(filePath))) {
+          invalidateAutoDiscovery();
+        }
+      });
     },
 
     writeBundle() {

package/templates/env.d.ts

@@ -4,3 +4,11 @@ declare module '*.vue' {
   const component: DefineComponent<{}, {}, any>;
   export default component;
 }
+
+declare module 'virtual:vylos-project' {
+  import type { VylosLocation, VylosEvent, VylosAction, LocationManager } from '@vylos/core';
+  export const locations: VylosLocation[];
+  export const events: VylosEvent[];
+  export const actions: VylosAction[];
+  export const initLinks: ((lm: LocationManager) => void) | undefined;
+}

package/templates/links.ts

@@ -0,0 +1,6 @@
+import type { LocationManager } from '@vylos/core';
+
+export default function (lm: LocationManager) {
+  lm.link('room', ['hallway']);
+  lm.link('hallway', ['room']);
+}

package/templates/main.ts

@@ -1,121 +1,6 @@
-import 'reflect-metadata';
 import './style.css';
-import { createApp, watch } from 'vue';
-import { createPinia } from 'pinia';
-import {
-  GameShell,
-  createEngine,
-  useEngineStateStore,
-  ENGINE_INJECT_KEY,
-  CONFIG_INJECT_KEY,
-  EnginePhase,
-  LocationManager,
-  ActionManager,
-  type EventRunnerCallbacks,
-  type TextEntry,
-  type VylosCharacter,
-} from '@vylos/core';
+import { setupVylos } from '@vylos/core';
 import config from './vylos.config';
-import { useGameStore } from '@game';
+import * as project from 'virtual:vylos-project';
 
-// Locations
-import home from './locations/home/location';
-
-// Events
-import intro from './global/events/intro';
-
-// Actions
-import wait from './global/actions/wait';
-
-const app = createApp(GameShell);
-const pinia = createPinia();
-app.use(pinia);
-
-const engineState = useEngineStateStore(pinia);
-const gameState = useGameStore(pinia);
-
-// Location manager
-const locationManager = new LocationManager();
-locationManager.registerAll([home]);
-
-// Action manager
-const actionManager = new ActionManager();
-actionManager.registerAll([wait]);
-
-const callbacks: EventRunnerCallbacks = {
-  onSay(text: string, speaker: VylosCharacter | null) {
-    engineState.setDialogue({ text, speaker, isNarration: !speaker });
-  },
-  onChoice(options) {
-    engineState.setChoices({ prompt: null, options });
-  },
-  onSetBackground(path) { engineState.setBackground(path); },
-  onSetForeground(path) { engineState.setForeground(path); },
-  onShowOverlay() {},
-  onHideOverlay() {},
-  onSetLocation(id) {
-    gameState.state.locationId = id;
-    engineState.setLocation(id);
-    const bg = locationManager.resolveBackground(id, gameState.state.gameTime);
-    if (bg) engineState.setBackground(bg);
-  },
-  onClear() {
-    engineState.setDialogue(null);
-    engineState.setChoices(null);
-    engineState.setForeground(null);
-    engineState.setOverlay(null);
-  },
-  resolveText(entry: string | TextEntry) {
-    return typeof entry === 'string' ? entry : entry['en'] ?? Object.values(entry)[0] ?? '';
-  },
-  getState() { return gameState.state; },
-  setState(s) { gameState.setState(s); },
-};
-
-const engine = createEngine({ callbacks, projectId: config.id });
-app.provide(ENGINE_INJECT_KEY, engine);
-app.provide(CONFIG_INJECT_KEY, config);
-app.mount('#app');
-
-engineState.setPhase(EnginePhase.MainMenu);
-
-const stopWatch = watch(() => engineState.phase, (newPhase) => {
-  if (newPhase === EnginePhase.Running) {
-    stopWatch();
-    startGame();
-  }
-});
-
-function startGame() {
-  gameState.state.locationId = 'home';
-  gameState.state.gameTime = 12;
-  engineState.setLocation('home');
-
-  engine.run([intro], () => gameState.state, {
-    onTick(state) {
-      const locations = locationManager.getAccessibleFrom(state.locationId, state);
-      engineState.setLocations(locations.map(l => ({
-        id: l.id,
-        name: typeof l.name === 'string' ? l.name : l.name['en'] ?? l.id,
-        accessible: true,
-      })));
-
-      const actions = actionManager.getAvailable(state.locationId, state);
-      engineState.setActions(actions.map(a => ({
-        id: a.id,
-        label: typeof a.label === 'string' ? a.label : a.label['en'] ?? a.id,
-        locationId: a.locationId ?? '',
-      })));
-
-      const resolveText = (t: string | Record<string, string>) =>
-        typeof t === 'string' ? t : t['en'] ?? Object.values(t)[0] ?? '';
-      engineState.setDrawableEvents(engine.eventManager.getDrawableEvents(state, resolveText));
-
-      const bg = locationManager.resolveBackground(state.locationId, state.gameTime);
-      if (bg) engineState.setBackground(bg);
-    },
-    onAction(actionId, state) {
-      actionManager.execute(actionId, state);
-    },
-  }).catch(console.error);
-}
+setupVylos({ config, ...project });