@guinetik/gcanvas 1.0.0

package/scripts/bundle4llm.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+/**
+ * bundle4llm
+ * -------------
+ * Create a comprehensive, single-file, import/export-free JavaScript bundle
+ * ideal for feeding into LLMs without worrying about dependencies.
+ *
+ * Features:
+ * - Recursively resolves and includes all exported modules
+ * - Flattens directory structure
+ * - Orders files by export order in index files
+ * - Sanitizes code based on selected preset (defaults to ES2020)
+ * - Skips index.js files from output (used only for ordering)
+ * - Ensures comprehensive module inclusion
+ * - Supports verbose logging with --verbose or -v
+ * - Optional comment stripping with --strip-comments
+ * - Accurate token estimation for various LLM models
+ *
+ * Usage:
+ *   bundle4llm --src ./src --out ./dist --file bundle.js --preset es2020 --strip-comments --model claude -v
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { argv } from 'process';
+
+const args = Object.fromEntries(
+  argv.slice(2).map(arg => {
+    const [key, val] = arg.replace(/^--?/, '').split('=');
+    return [key, val ?? true];
+  })
+);
+
+const srcDir = path.resolve(args.src || './src');
+const outDir = path.resolve(args.out || './dist');
+const outFile = args.file || 'llm-bundle.js';
+const verbose = args.v || args.verbose;
+const stripComments = args['strip-comments'] || false;
+const preset = args.preset || 'es2020';
+const model = args.model || 'claude'; // Default to Claude model
+
+// Deep file collection with recursive export resolution
+function collectModules(indexPath, fileMap = {}, visited = new Set(), depth = 0) {
+  // Prevent infinite recursion
+  if (depth > 10) return fileMap;
+  
+  // Prevent revisiting the same index file
+  if (visited.has(indexPath)) return fileMap;
+  visited.add(indexPath);
+
+  // Read index file contents
+  if (!fs.existsSync(indexPath)) return fileMap;
+  const content = fs.readFileSync(indexPath, 'utf-8');
+
+  // Find all export declarations
+  const exportMatches = [
+    ...content.matchAll(/export\s+(?:\*|{[^}]*})\s*from\s+['"](.+)['"]/g),
+    ...content.matchAll(/export\s+{[^}]*}\s*from\s+['"](.+)['"]/g)
+  ];
+
+  // Resolve and process each exported module
+  for (const match of exportMatches) {
+    const rawPath = match[1];
+    const modulePath = rawPath.startsWith('.') 
+      ? path.resolve(path.dirname(indexPath), rawPath)
+      : path.resolve(srcDir, rawPath);
+    
+    // Normalize path
+    const normalizedPath = modulePath.replace(/\.js$/, '');
+    const jsPath = normalizedPath + '.js';
+
+    // If it's a directory, look for its index file
+    const indexInDir = path.join(normalizedPath, 'index.js');
+    
+    if (fs.existsSync(jsPath) && !fileMap[jsPath]) {
+      // Add the module file
+      fileMap[jsPath] = jsPath;
+      
+      // If it's a directory with an index, recursively collect its exports
+      if (fs.existsSync(indexInDir)) {
+        collectModules(indexInDir, fileMap, visited, depth + 1);
+      }
+    } else if (fs.existsSync(indexInDir)) {
+      // Recursively collect exports from subdirectory index
+      collectModules(indexInDir, fileMap, visited, depth + 1);
+    }
+  }
+
+  return fileMap;
+}
+
+// Order modules based on index file export order
+function orderModules(srcDir) {
+  const indexPath = path.join(srcDir, 'index.js');
+  const fileMap = collectModules(indexPath);
+  
+  // Convert to array and sort
+  return Object.values(fileMap)
+    .filter(filePath => !filePath.endsWith('index.js'));
+}
+
+// Sanitization presets
+const sanitizationPresets = {
+  // ES2020 sanitization - strips imports and optionally comments
+  es2020: (code, options = {}) => {
+    let result = code;
+    
+    // Strip import statements
+    result = result
+      .split('\n')
+      .filter(line => !/^\s*import\b/.test(line))
+      .join('\n');
+    
+    // Optionally strip comments
+    if (options.stripComments) {
+      // Strip block comments
+      result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+      // Strip line comments
+      result = result.replace(/\/\/.*$/gm, '');
+    }
+    
+    return result.trim();
+  },
+  
+  // ES2015 sanitization - more conservative approach
+  es2015: (code, options = {}) => {
+    let result = code;
+    
+    // Strip import statements
+    result = result
+      .split('\n')
+      .filter(line => !/^\s*import\b/.test(line))
+      .join('\n');
+      
+    // Optionally strip comments
+    if (options.stripComments) {
+      // Strip block comments
+      result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+      // Strip line comments
+      result = result.replace(/\/\/.*$/gm, '');
+    }
+    
+    return result.trim();
+  },
+  
+  // Minimal sanitization - only strips imports
+  minimal: (code, options = {}) => {
+    let result = code
+      .split('\n')
+      .filter(line => !/^\s*import\b/.test(line))
+      .join('\n');
+      
+    return result.trim();
+  }
+};
+
+// Generic sanitize function that uses the selected preset
+function sanitizeCode(code, presetName, options = {}) {
+  const sanitizer = sanitizationPresets[presetName] || sanitizationPresets.es2020;
+  return sanitizer(code, options);
+}
+
+/**
+ * Improved token estimation function supporting multiple LLM models
+ * 
+ * @param {string} text - The text to estimate tokens for
+ * @param {string} model - Model identifier ('claude', 'gpt3', 'gpt4', etc.)
+ * @return {number} Estimated token count
+ */
+function estimateTokens(text, model = 'claude') {
+  // Basic character counting
+  const charCount = text.length;
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+  
+  // Model-specific token ratio estimations
+  const modelRatios = {
+    // Anthropic Claude models
+    'claude': { 
+      charRatio: 3.5,      // ~3.5 chars per token for Claude
+      wordRatio: 0.75,     // ~0.75 words per token for Claude
+    },
+    // OpenAI models
+    'gpt3': {
+      charRatio: 4.0,      // ~4 chars per token for GPT-3
+      wordRatio: 0.75,     // ~0.75 words per token for GPT-3
+    },
+    'gpt4': {
+      charRatio: 3.8,      // ~3.8 chars per token for GPT-4
+      wordRatio: 0.7,      // ~0.7 words per token for GPT-4
+    },
+    // Default fallback
+    'default': {
+      charRatio: 4.0,
+      wordRatio: 0.75,
+    }
+  };
+  
+  // Get the appropriate ratio for the model
+  const ratio = modelRatios[model] || modelRatios.default;
+  
+  // Estimate based on character count and word count, using an average of both methods
+  const charBasedEstimate = Math.ceil(charCount / ratio.charRatio);
+  const wordBasedEstimate = Math.ceil(wordCount / ratio.wordRatio);
+  
+  // Language features that tend to increase token count
+  const codeFeatures = {
+    symbols: (text.match(/[{}[\]()<>:;,."'`~!@#$%^&*+=|\\/?-]/g) || []).length,
+    indentation: (text.match(/^ +/gm) || []).length,
+    camelCase: (text.match(/[a-z][A-Z]/g) || []).length,
+  };
+  
+  // Adjustment for code-specific features (symbols, indentation, camelCase)
+  const codeAdjustment = codeFeatures.symbols * 0.1 + 
+                          codeFeatures.indentation * 0.05 + 
+                          codeFeatures.camelCase * 0.2;
+  
+  // Calculate weighted average with more weight on char-based for code
+  const weightedEstimate = (charBasedEstimate * 0.7) + (wordBasedEstimate * 0.3);
+  
+  // Add code-specific adjustment
+  const finalEstimate = Math.ceil(weightedEstimate + codeAdjustment);
+  
+  return finalEstimate;
+}
+
+// Main bundling function
+function bundleLLMBuild(srcDir, outDir, outFile, options = {}) {
+  const orderedFiles = orderModules(srcDir);
+  const { verbose, stripComments, preset, model } = options;
+
+  let output = '/**\n * bundle4llm Output\n';
+  output += ` * Generated: ${new Date().toISOString()}\n`;
+  output += ` * Source: ${srcDir}\n`;
+  output += ` * Preset: ${preset}\n`;
+  if (stripComments) output += ` * Comments: Stripped\n`;
+  output += ` */\n\n`;
+
+  let currentDir = '';
+  for (const file of orderedFiles) {
+    const fileDir = path.dirname(file).replace(srcDir, '');
+    if (fileDir !== currentDir) {
+      currentDir = fileDir;
+      output += `\n// =========================================\n`;
+      output += `// DIRECTORY: ${currentDir || '/'}\n`;
+      output += `// =========================================\n\n`;
+    }
+
+    let contents = fs.readFileSync(file, 'utf-8');
+    contents = sanitizeCode(contents, preset, { stripComments });
+    
+    if (verbose) console.log('📦 Including:', file);
+    output += contents + '\n\n';
+  }
+
+  // Ensure output directory exists
+  fs.mkdirSync(outDir, { recursive: true });
+  
+  // Write the bundled file
+  const fullOutputPath = path.join(outDir, outFile);
+  fs.writeFileSync(fullOutputPath, output);
+
+  const totalTokens = estimateTokens(output, model).toLocaleString();
+  console.log(`✅ Created LLM build → ${fullOutputPath}`);
+  console.log(`📊 Total modules included: ${orderedFiles.length}`);
+  console.log(`🔧 Preset: ${preset}${stripComments ? ', comments stripped' : ''}`);
+  console.log(`🔍 Estimated tokens (${model}): ${totalTokens}`);
+}
+
+// Execute the bundle
+bundleLLMBuild(srcDir, outDir, outFile, {
+  verbose,
+  stripComments,
+  preset,
+  model
+});

package/scripts/clearconsole.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const targetDir = process.argv[2] || "./src"; // default to ./src
+
+function isLineCommented(line) {
+  return /^\s*\/\/.*console\.log/.test(line);
+}
+
+function isInsideBlockComment(lines, index) {
+  for (let i = index; i >= 0; i--) {
+    if (lines[i].includes("*/")) break;
+    if (lines[i].includes("/*")) return true;
+  }
+  return false;
+}
+
+function processFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  const modified = lines.map((line, i) => {
+    if (
+      line.includes("console.log") &&
+      !isLineCommented(line) &&
+      !isInsideBlockComment(lines, i)
+    ) {
+      return line.replace(/(.*?)(console\.log.*)/, "$1// $2");
+    }
+    return line;
+  });
+  fs.writeFileSync(filePath, modified.join("\n"), "utf8");
+  console.log(`✔ Commented console.log in: ${filePath}`);
+}
+
+function walkDir(dir) {
+  fs.readdirSync(dir).forEach((file) => {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      walkDir(fullPath);
+    } else if (/\.(js|ts|jsx|tsx)$/.test(fullPath)) {
+      processFile(fullPath);
+    }
+  });
+}
+
+walkDir(targetDir);

package/src/collision/collision-system.js

@@ -0,0 +1,332 @@
+import { Collision } from "./collision.js";
+
+/**
+ * CollisionSystem - Manages collision groups and detection
+ *
+ * Provides an organized way to manage multiple groups of collidable objects
+ * and efficiently check collisions between them.
+ *
+ * @example
+ * const collisions = new CollisionSystem();
+ *
+ * // Register groups
+ * collisions.createGroup('players');
+ * collisions.createGroup('enemies');
+ * collisions.createGroup('bullets');
+ *
+ * // Add objects to groups
+ * collisions.add('players', player);
+ * collisions.add('enemies', alien);
+ * collisions.add('bullets', bullet);
+ *
+ * // Set up collision handlers
+ * collisions.onCollision('bullets', 'enemies', (bullet, enemy) => {
+ *   bullet.destroy();
+ *   enemy.takeDamage();
+ * });
+ *
+ * // Check collisions each frame
+ * collisions.update();
+ */
+export class CollisionSystem {
+  constructor() {
+    /** @type {Map<string, Set<Object>>} */
+    this.groups = new Map();
+
+    /** @type {Array<Object>} Collision pair definitions */
+    this.pairs = [];
+
+    /** @type {boolean} Whether to use quadtree optimization */
+    this.useQuadtree = false;
+  }
+
+  /**
+   * Create a new collision group
+   *
+   * @param {string} name - Unique group name
+   * @returns {CollisionSystem} this for chaining
+   */
+  createGroup(name) {
+    if (!this.groups.has(name)) {
+      this.groups.set(name, new Set());
+    }
+    return this;
+  }
+
+  /**
+   * Add an object to a collision group
+   * Object must have either getBounds() method or bounds property
+   *
+   * @param {string} groupName - Group to add to
+   * @param {Object} obj - Object with getBounds() or bounds property
+   * @returns {CollisionSystem} this for chaining
+   */
+  add(groupName, obj) {
+    const group = this.groups.get(groupName);
+    if (!group) {
+      throw new Error(`Collision group '${groupName}' does not exist. Call createGroup('${groupName}') first.`);
+    }
+    group.add(obj);
+    return this;
+  }
+
+  /**
+   * Remove an object from a collision group
+   *
+   * @param {string} groupName - Group to remove from
+   * @param {Object} obj - Object to remove
+   * @returns {boolean} True if object was in the group
+   */
+  remove(groupName, obj) {
+    const group = this.groups.get(groupName);
+    if (!group) return false;
+    return group.delete(obj);
+  }
+
+  /**
+   * Remove an object from all groups
+   *
+   * @param {Object} obj - Object to remove
+   */
+  removeFromAll(obj) {
+    for (const group of this.groups.values()) {
+      group.delete(obj);
+    }
+  }
+
+  /**
+   * Clear all objects from a group
+   *
+   * @param {string} groupName - Group to clear
+   */
+  clearGroup(groupName) {
+    const group = this.groups.get(groupName);
+    if (group) {
+      group.clear();
+    }
+  }
+
+  /**
+   * Clear all groups
+   */
+  clearAll() {
+    for (const group of this.groups.values()) {
+      group.clear();
+    }
+  }
+
+  /**
+   * Get all objects in a group
+   *
+   * @param {string} groupName - Group name
+   * @returns {Array<Object>} Array of objects in the group
+   */
+  getGroup(groupName) {
+    const group = this.groups.get(groupName);
+    return group ? Array.from(group) : [];
+  }
+
+  /**
+   * Register a collision callback between two groups
+   *
+   * @param {string} groupA - First group name
+   * @param {string} groupB - Second group name
+   * @param {Function} callback - Called with (objA, objB) on collision
+   * @param {Object} [options={}] - Additional options
+   * @param {boolean} [options.once=false] - If true, only trigger once per pair per frame
+   * @returns {CollisionSystem} this for chaining
+   */
+  onCollision(groupA, groupB, callback, options = {}) {
+    this.pairs.push({
+      groupA,
+      groupB,
+      callback,
+      once: options.once ?? false,
+    });
+    return this;
+  }
+
+  /**
+   * Remove all collision callbacks for a pair of groups
+   *
+   * @param {string} groupA - First group name
+   * @param {string} groupB - Second group name
+   */
+  offCollision(groupA, groupB) {
+    this.pairs = this.pairs.filter(
+      (pair) => !(pair.groupA === groupA && pair.groupB === groupB)
+    );
+  }
+
+  /**
+   * Check and handle all registered collision pairs
+   * Call this each frame in your update loop
+   */
+  update() {
+    for (const pair of this.pairs) {
+      this._checkPair(pair);
+    }
+  }
+
+  /**
+   * Check collisions between two specific groups (without callbacks)
+   * Returns array of colliding pairs
+   *
+   * @param {string} groupA - First group name
+   * @param {string} groupB - Second group name
+   * @returns {Array<Array>} Array of [objA, objB] colliding pairs
+   */
+  check(groupA, groupB) {
+    const setA = this.groups.get(groupA);
+    const setB = this.groups.get(groupB);
+    if (!setA || !setB) return [];
+
+    const collisions = [];
+
+    for (const objA of setA) {
+      if (!this._isActive(objA)) continue;
+      const boundsA = this._getBounds(objA);
+      if (!boundsA) continue;
+
+      for (const objB of setB) {
+        if (objA === objB) continue;
+        if (!this._isActive(objB)) continue;
+
+        const boundsB = this._getBounds(objB);
+        if (!boundsB) continue;
+
+        if (Collision.rectRect(boundsA, boundsB)) {
+          collisions.push([objA, objB]);
+        }
+      }
+    }
+
+    return collisions;
+  }
+
+  /**
+   * Check if an object collides with any object in a group
+   *
+   * @param {Object} obj - Object to test
+   * @param {string} groupName - Group to test against
+   * @returns {Object|null} First colliding object, or null
+   */
+  checkAgainstGroup(obj, groupName) {
+    const group = this.groups.get(groupName);
+    if (!group) return null;
+
+    const boundsA = this._getBounds(obj);
+    if (!boundsA) return null;
+
+    for (const other of group) {
+      if (obj === other) continue;
+      if (!this._isActive(other)) continue;
+
+      const boundsB = this._getBounds(other);
+      if (!boundsB) continue;
+
+      if (Collision.rectRect(boundsA, boundsB)) {
+        return other;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if an object collides with any object in a group
+   * Returns all colliding objects
+   *
+   * @param {Object} obj - Object to test
+   * @param {string} groupName - Group to test against
+   * @returns {Array<Object>} All colliding objects
+   */
+  checkAllAgainstGroup(obj, groupName) {
+    const group = this.groups.get(groupName);
+    if (!group) return [];
+
+    const boundsA = this._getBounds(obj);
+    if (!boundsA) return [];
+
+    const collisions = [];
+
+    for (const other of group) {
+      if (obj === other) continue;
+      if (!this._isActive(other)) continue;
+
+      const boundsB = this._getBounds(other);
+      if (!boundsB) continue;
+
+      if (Collision.rectRect(boundsA, boundsB)) {
+        collisions.push(other);
+      }
+    }
+
+    return collisions;
+  }
+
+  /**
+   * @private
+   */
+  _checkPair(pair) {
+    const setA = this.groups.get(pair.groupA);
+    const setB = this.groups.get(pair.groupB);
+    if (!setA || !setB) return;
+
+    for (const objA of setA) {
+      if (!this._isActive(objA)) continue;
+      const boundsA = this._getBounds(objA);
+      if (!boundsA) continue;
+
+      for (const objB of setB) {
+        if (objA === objB) continue;
+        if (!this._isActive(objB)) continue;
+
+        const boundsB = this._getBounds(objB);
+        if (!boundsB) continue;
+
+        if (Collision.rectRect(boundsA, boundsB)) {
+          pair.callback(objA, objB);
+
+          // If 'once' option, skip remaining checks for this objA
+          if (pair.once) break;
+        }
+      }
+    }
+  }
+
+  /**
+   * Get bounds from an object (supports getBounds() method or bounds property)
+   * @private
+   */
+  _getBounds(obj) {
+    if (typeof obj.getBounds === "function") {
+      return obj.getBounds();
+    }
+    if (obj.bounds) {
+      return obj.bounds;
+    }
+    // Fallback: try to construct bounds from x, y, width, height
+    if (obj.x !== undefined && obj.y !== undefined) {
+      return {
+        x: obj.x - (obj.width || 0) / 2,
+        y: obj.y - (obj.height || 0) / 2,
+        width: obj.width || 0,
+        height: obj.height || 0,
+      };
+    }
+    return null;
+  }
+
+  /**
+   * Check if an object is still active (for filtering dead objects)
+   * @private
+   */
+  _isActive(obj) {
+    // Support common patterns for "active" objects
+    if (obj.active === false) return false;
+    if (obj.destroyed === true) return false;
+    if (obj.alive === false) return false;
+    return true;
+  }
+}