@directivegames/genesys.sdk 3.2.2 → 3.2.4

package/src/templates/scripts/genesys/remove-engine-comments.ts

@@ -1,135 +1,135 @@
-#!/usr/bin/env tsx
-
-import { readdir, readFile, stat, writeFile } from 'fs/promises';
-import { join } from 'path';
-
-/**
- * Recursively finds all TypeScript files in a directory
- */
-async function findTsFiles(dir: string): Promise<string[]> {
-  const files: string[] = [];
-
-  try {
-    const entries = await readdir(dir);
-
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      const stats = await stat(fullPath);
-
-      if (stats.isDirectory()) {
-        const subFiles = await findTsFiles(fullPath);
-        files.push(...subFiles);
-      } else if (entry.endsWith('.ts') || entry.endsWith('.tsx')) {
-        files.push(fullPath);
-      }
-    }
-  } catch (error) {
-    console.warn(`Warning: Could not read directory ${dir}:`, error);
-  }
-
-  return files;
-}
-
-/**
- * Removes comments from TypeScript code using regex
- */
-function removeComments(code: string): { cleaned: string; hadComments: boolean } {
-  const originalLength = code.length;
-
-  // Remove single-line comments (// comments)
-  // This regex handles // comments but preserves URLs and string literals
-  let cleaned = code.replace(/^(\s*)\/\/.*$/gm, '$1');
-
-  // Remove multi-line comments (/* ... */ and /** ... */)
-  // This regex handles nested quotes and preserves strings
-  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
-
-  // Clean up multiple consecutive empty lines (replace with single empty line)
-  cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n');
-
-  // Trim trailing whitespace on each line
-  cleaned = cleaned.replace(/[ \t]+$/gm, '');
-
-  const hadComments = cleaned.length !== originalLength || cleaned !== code;
-
-  return { cleaned, hadComments };
-}
-
-/**
- * Removes comments from a TypeScript file
- */
-async function removeCommentsFromFile(filePath: string): Promise<boolean> {
-  try {
-    const content = await readFile(filePath, 'utf8');
-    const { cleaned, hadComments } = removeComments(content);
-
-    if (!hadComments) {
-      return false; // No comments to remove
-    }
-
-    await writeFile(filePath, cleaned, 'utf8');
-    return true;
-  } catch (error) {
-    console.error(`Error processing file ${filePath}:`, error);
-    return false;
-  }
-}
-
-async function main() {
-  const engineDir = '.engine';
-
-  console.log(`Searching for TypeScript files in ${engineDir}...`);
-  console.log(`Current working directory: ${process.cwd()}`);
-
-  try {
-    const tsFiles = await findTsFiles(engineDir);
-
-    console.log(`Found ${tsFiles.length} TypeScript files.`);
-    if (tsFiles.length > 0) {
-      console.log('First few files:');
-      tsFiles.slice(0, 5).forEach(file => console.log(`  - ${file}`));
-    }
-
-    if (tsFiles.length === 0) {
-      console.log('No TypeScript files found in .engine folder.');
-      return;
-    }
-
-    let processedCount = 0;
-    let modifiedCount = 0;
-
-    for (const filePath of tsFiles) {
-      console.log(`Processing: ${filePath}`);
-
-      try {
-        const wasModified = await removeCommentsFromFile(filePath);
-        processedCount++;
-
-        if (wasModified) {
-          modifiedCount++;
-          console.log('  ✓ Comments removed');
-        } else {
-          console.log('  - No comments found');
-        }
-      } catch (error) {
-        console.error(`  ✗ Error: ${error}`);
-      }
-    }
-
-    console.log('\nCompleted:');
-    console.log(`- Files processed: ${processedCount}`);
-    console.log(`- Files modified: ${modifiedCount}`);
-    console.log(`- Files skipped: ${processedCount - modifiedCount}`);
-
-  } catch (error) {
-    console.error('Error:', error);
-    process.exit(1);
-  }
-}
-
-// Always run main if this file is executed directly
-main().catch((error) => {
-  console.error('Unexpected error:', error);
-  console.error('Stack trace:', error.stack);
-  process.exit(1);
+#!/usr/bin/env tsx
+
+import { readdir, readFile, stat, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+/**
+ * Recursively finds all TypeScript files in a directory
+ */
+async function findTsFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+
+  try {
+    const entries = await readdir(dir);
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await stat(fullPath);
+
+      if (stats.isDirectory()) {
+        const subFiles = await findTsFiles(fullPath);
+        files.push(...subFiles);
+      } else if (entry.endsWith('.ts') || entry.endsWith('.tsx')) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${dir}:`, error);
+  }
+
+  return files;
+}
+
+/**
+ * Removes comments from TypeScript code using regex
+ */
+function removeComments(code: string): { cleaned: string; hadComments: boolean } {
+  const originalLength = code.length;
+
+  // Remove single-line comments (// comments)
+  // This regex handles // comments but preserves URLs and string literals
+  let cleaned = code.replace(/^(\s*)\/\/.*$/gm, '$1');
+
+  // Remove multi-line comments (/* ... */ and /** ... */)
+  // This regex handles nested quotes and preserves strings
+  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Clean up multiple consecutive empty lines (replace with single empty line)
+  cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n');
+
+  // Trim trailing whitespace on each line
+  cleaned = cleaned.replace(/[ \t]+$/gm, '');
+
+  const hadComments = cleaned.length !== originalLength || cleaned !== code;
+
+  return { cleaned, hadComments };
+}
+
+/**
+ * Removes comments from a TypeScript file
+ */
+async function removeCommentsFromFile(filePath: string): Promise<boolean> {
+  try {
+    const content = await readFile(filePath, 'utf8');
+    const { cleaned, hadComments } = removeComments(content);
+
+    if (!hadComments) {
+      return false; // No comments to remove
+    }
+
+    await writeFile(filePath, cleaned, 'utf8');
+    return true;
+  } catch (error) {
+    console.error(`Error processing file ${filePath}:`, error);
+    return false;
+  }
+}
+
+async function main() {
+  const engineDir = '.engine';
+
+  console.log(`Searching for TypeScript files in ${engineDir}...`);
+  console.log(`Current working directory: ${process.cwd()}`);
+
+  try {
+    const tsFiles = await findTsFiles(engineDir);
+
+    console.log(`Found ${tsFiles.length} TypeScript files.`);
+    if (tsFiles.length > 0) {
+      console.log('First few files:');
+      tsFiles.slice(0, 5).forEach(file => console.log(`  - ${file}`));
+    }
+
+    if (tsFiles.length === 0) {
+      console.log('No TypeScript files found in .engine folder.');
+      return;
+    }
+
+    let processedCount = 0;
+    let modifiedCount = 0;
+
+    for (const filePath of tsFiles) {
+      console.log(`Processing: ${filePath}`);
+
+      try {
+        const wasModified = await removeCommentsFromFile(filePath);
+        processedCount++;
+
+        if (wasModified) {
+          modifiedCount++;
+          console.log('  ✓ Comments removed');
+        } else {
+          console.log('  - No comments found');
+        }
+      } catch (error) {
+        console.error(`  ✗ Error: ${error}`);
+      }
+    }
+
+    console.log('\nCompleted:');
+    console.log(`- Files processed: ${processedCount}`);
+    console.log(`- Files modified: ${modifiedCount}`);
+    console.log(`- Files skipped: ${processedCount - modifiedCount}`);
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+// Always run main if this file is executed directly
+main().catch((error) => {
+  console.error('Unexpected error:', error);
+  console.error('Stack trace:', error.stack);
+  process.exit(1);
 });

package/src/templates/scripts/genesys/run-mcp-inspector.bat

@@ -1,5 +1,5 @@
-pushd %~dp0
-cd ..
-set DANGEROUSLY_OMIT_AUTH=1
-pnpm dlx @modelcontextprotocol/inspector pnpm dlx tsx ./scripts/genesys/genesys-mcp.ts
+pushd %~dp0
+cd ..
+set DANGEROUSLY_OMIT_AUTH=1
+pnpm dlx @modelcontextprotocol/inspector pnpm dlx tsx ./scripts/genesys/genesys-mcp.ts
 popd

package/src/templates/scripts/genesys/storageProvider.ts

@@ -1,182 +1,182 @@
-import fs from 'fs';
-import path from 'path';
-
-import * as ENGINE from 'genesys.js';
-import { AssetPath, AssetPathEncodeState } from 'genesys.js';
-
-import { getProjectRoot } from './common.js';
-
-
-export class StorageProvider implements ENGINE.IStorageProvider {
-  public async resolvePath(assetPath: AssetPath, expiry?: number): Promise<AssetPath> {
-    if (assetPath.isResolved()) {
-      return assetPath;
-    }
-
-    assetPath.resolvePath(this.getFullPath(assetPath.initialPath), AssetPathEncodeState.Decoded);
-    return assetPath;
-  }
-
-  public getFullPath(filePath: string): string {
-    let fullPath = filePath;
-    let rootPath = undefined;
-
-    if (filePath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
-      filePath = filePath.slice(ENGINE.PROJECT_PATH_PREFIX.length);
-      rootPath = getProjectRoot();
-    }
-    else if (filePath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
-      filePath = filePath.slice(ENGINE.ENGINE_PATH_PREFIX.length);
-      rootPath = path.join(getProjectRoot(), 'node_modules', 'genesys.js');
-    }
-
-    if (rootPath !== undefined) {
-      fullPath = AssetPath.join(rootPath, filePath);
-    }
-    return fullPath;
-  }
-
-  public async downloadFileAsBuffer(
-    assetPath: AssetPath,
-  ): Promise<ArrayBuffer> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    if (!fs.existsSync(fullPath)) {
-      return new ArrayBuffer(0);
-    }
-
-    const data = fs.readFileSync(fullPath);
-    const arrayBuffer = data.buffer.slice(
-      data.byteOffset,
-      data.byteOffset + data.byteLength
-    );
-    return arrayBuffer;
-  }
-
-  public async downloadFileAsJson<T>(assetPath: AssetPath): Promise<T> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    if (!fs.existsSync(fullPath)) {
-      return {} as T;
-    }
-    return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
-  }
-
-  public async downloadFileAsText(assetPath: AssetPath): Promise<string> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    if (!fs.existsSync(fullPath)) {
-      return '';
-    }
-    return fs.readFileSync(fullPath, 'utf8');
-  }
-
-  public async exists(assetPath: AssetPath): Promise<boolean> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    return fs.existsSync(fullPath);
-  }
-
-  public async buildCurrentProject(runTsc: boolean): Promise<boolean> {
-    throw new Error('Not implemented');
-  }
-
-  public async uploadFile(assetPath: AssetPath, content: Blob | File | string | ArrayBuffer, options?: ENGINE.FileUploadOptions): Promise<{
-        path: string;
-        name: string;
-    }>
-  {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-
-    if (typeof content === 'string') {
-      fs.writeFileSync(fullPath, content);
-    } else {
-      throw new Error(`Unsupported content type: ${typeof content}`);
-    }
-
-    return {
-      path: fullPath,
-      name: path.basename(fullPath)
-    };
-  }
-
-  public async deleteFile(assetPath: AssetPath): Promise<void> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-    if (fs.existsSync(fullPath)) {
-      fs.unlinkSync(fullPath);
-    }
-  }
-
-  public async listFiles(assetPath: AssetPath, recursive?: boolean, includeHiddenFiles?: boolean): Promise<ENGINE.FileListResult> {
-    assetPath = await this.resolvePath(assetPath);
-    const fullPath = getResolvedPath(assetPath);
-
-    if (!fs.existsSync(fullPath)) {
-      return { files: [], directories: [] };
-    }
-
-    const files: ENGINE.FileItem[] = [];
-    const directories: ENGINE.FileItem[] = [];
-
-    const processDirectory = (dirPath: string, basePath: string = '') => {
-      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-      for (const entry of entries) {
-        // Skip hidden files if not requested
-        if (!includeHiddenFiles && entry.name.startsWith('.')) {
-          continue;
-        }
-
-        const fullEntryPath = path.join(dirPath, entry.name);
-        const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
-        const stats = fs.statSync(fullEntryPath);
-
-        const fileItem: ENGINE.FileItem = {
-          name: entry.name,
-          path: relativePath,
-          absolutePath: fullEntryPath,
-          size: stats.size,
-          modifiedTime: stats.mtime,
-          isDirectory: entry.isDirectory()
-        };
-
-        if (entry.isDirectory()) {
-          directories.push(fileItem);
-
-          // Recursively process subdirectories if requested
-          if (recursive) {
-            processDirectory(fullEntryPath, relativePath);
-          }
-        } else {
-          files.push(fileItem);
-        }
-      }
-    };
-
-    // Check if the path is a directory
-    const stats = fs.statSync(fullPath);
-    if (stats.isDirectory()) {
-      processDirectory(fullPath);
-    } else {
-      // If it's a file, return just that file
-      const fileItem: ENGINE.FileItem = {
-        name: path.basename(fullPath),
-        path: path.basename(fullPath),
-        absolutePath: fullPath,
-        size: stats.size,
-        modifiedTime: stats.mtime,
-        isDirectory: false
-      };
-      files.push(fileItem);
-    }
-
-    return { files, directories };
-  }
-}
-
-export function getResolvedPath(assetPath: ENGINE.AssetPath): string {
-  return assetPath.getResolvedPath(false);
-}
+import fs from 'fs';
+import path from 'path';
+
+import * as ENGINE from 'genesys.js';
+import { AssetPath, AssetPathEncodeState } from 'genesys.js';
+
+import { getProjectRoot } from './common.js';
+
+
+export class StorageProvider implements ENGINE.IStorageProvider {
+  public async resolvePath(assetPath: AssetPath, expiry?: number): Promise<AssetPath> {
+    if (assetPath.isResolved()) {
+      return assetPath;
+    }
+
+    assetPath.resolvePath(this.getFullPath(assetPath.initialPath), AssetPathEncodeState.Decoded);
+    return assetPath;
+  }
+
+  public getFullPath(filePath: string): string {
+    let fullPath = filePath;
+    let rootPath = undefined;
+
+    if (filePath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+      filePath = filePath.slice(ENGINE.PROJECT_PATH_PREFIX.length);
+      rootPath = getProjectRoot();
+    }
+    else if (filePath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+      filePath = filePath.slice(ENGINE.ENGINE_PATH_PREFIX.length);
+      rootPath = path.join(getProjectRoot(), 'node_modules', 'genesys.js');
+    }
+
+    if (rootPath !== undefined) {
+      fullPath = AssetPath.join(rootPath, filePath);
+    }
+    return fullPath;
+  }
+
+  public async downloadFileAsBuffer(
+    assetPath: AssetPath,
+  ): Promise<ArrayBuffer> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (!fs.existsSync(fullPath)) {
+      return new ArrayBuffer(0);
+    }
+
+    const data = fs.readFileSync(fullPath);
+    const arrayBuffer = data.buffer.slice(
+      data.byteOffset,
+      data.byteOffset + data.byteLength
+    );
+    return arrayBuffer;
+  }
+
+  public async downloadFileAsJson<T>(assetPath: AssetPath): Promise<T> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (!fs.existsSync(fullPath)) {
+      return {} as T;
+    }
+    return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+  }
+
+  public async downloadFileAsText(assetPath: AssetPath): Promise<string> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (!fs.existsSync(fullPath)) {
+      return '';
+    }
+    return fs.readFileSync(fullPath, 'utf8');
+  }
+
+  public async exists(assetPath: AssetPath): Promise<boolean> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    return fs.existsSync(fullPath);
+  }
+
+  public async buildCurrentProject(runTsc: boolean): Promise<boolean> {
+    throw new Error('Not implemented');
+  }
+
+  public async uploadFile(assetPath: AssetPath, content: Blob | File | string | ArrayBuffer, options?: ENGINE.FileUploadOptions): Promise<{
+        path: string;
+        name: string;
+    }>
+  {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+
+    if (typeof content === 'string') {
+      fs.writeFileSync(fullPath, content);
+    } else {
+      throw new Error(`Unsupported content type: ${typeof content}`);
+    }
+
+    return {
+      path: fullPath,
+      name: path.basename(fullPath)
+    };
+  }
+
+  public async deleteFile(assetPath: AssetPath): Promise<void> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+    }
+  }
+
+  public async listFiles(assetPath: AssetPath, recursive?: boolean, includeHiddenFiles?: boolean): Promise<ENGINE.FileListResult> {
+    assetPath = await this.resolvePath(assetPath);
+    const fullPath = getResolvedPath(assetPath);
+
+    if (!fs.existsSync(fullPath)) {
+      return { files: [], directories: [] };
+    }
+
+    const files: ENGINE.FileItem[] = [];
+    const directories: ENGINE.FileItem[] = [];
+
+    const processDirectory = (dirPath: string, basePath: string = '') => {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        // Skip hidden files if not requested
+        if (!includeHiddenFiles && entry.name.startsWith('.')) {
+          continue;
+        }
+
+        const fullEntryPath = path.join(dirPath, entry.name);
+        const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
+        const stats = fs.statSync(fullEntryPath);
+
+        const fileItem: ENGINE.FileItem = {
+          name: entry.name,
+          path: relativePath,
+          absolutePath: fullEntryPath,
+          size: stats.size,
+          modifiedTime: stats.mtime,
+          isDirectory: entry.isDirectory()
+        };
+
+        if (entry.isDirectory()) {
+          directories.push(fileItem);
+
+          // Recursively process subdirectories if requested
+          if (recursive) {
+            processDirectory(fullEntryPath, relativePath);
+          }
+        } else {
+          files.push(fileItem);
+        }
+      }
+    };
+
+    // Check if the path is a directory
+    const stats = fs.statSync(fullPath);
+    if (stats.isDirectory()) {
+      processDirectory(fullPath);
+    } else {
+      // If it's a file, return just that file
+      const fileItem: ENGINE.FileItem = {
+        name: path.basename(fullPath),
+        path: path.basename(fullPath),
+        absolutePath: fullPath,
+        size: stats.size,
+        modifiedTime: stats.mtime,
+        isDirectory: false
+      };
+      files.push(fileItem);
+    }
+
+    return { files, directories };
+  }
+}
+
+export function getResolvedPath(assetPath: ENGINE.AssetPath): string {
+  return assetPath.getResolvedPath(false);
+}