@causyne/agent 0.0.0-stage → 1.10.1

package/src/tools/gameCanvasAudit.js

@@ -0,0 +1,101 @@
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+export const gameCanvasAudit = {
+  schema: {
+    name: 'game_canvas_audit',
+    description: 'Visual quality gate. Samples HTML5 canvas pixels to ensure the game is rendering correctly and detects missing sprites/entities based on color clusters.',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: {
+          type: 'string',
+          description: 'The URL or local file path to the HTML game.'
+        }
+      },
+      required: ['url']
+    }
+  },
+  execute: async (args) => {
+    let { url } = args;
+    if (!url) return { success: false, error: 'URL is required' };
+    
+    if (url.startsWith('/')) {
+        url = 'file://' + url;
+    }
+
+    try {
+      const vision = await ensureCapability('vision');
+      if (!vision.ok) return { success: false, error: vision.reason, requiresConsent: vision.requiresConsent };
+      // loadCapabilityPackage already unwraps a default export; this file uses
+      // the namespace shape below, so keep it wrapped.
+      const puppeteer = { default: await loadCapabilityPackage('puppeteer-core') };
+
+      const browser = await puppeteer.default.launch({
+          executablePath: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+          headless: 'new',
+          args: ['--no-sandbox', '--disable-setuid-sandbox', '--autoplay-policy=no-user-gesture-required']
+      });
+
+      const page = await browser.newPage();
+      
+      await page.goto(url, { waitUntil: 'load', timeout: 15000 });
+
+      // Wait a bit for game loop to start rendering
+      await new Promise(r => setTimeout(r, 1000));
+
+      // Simulate input (ArrowUp) to trigger rendering updates (in case game pauses until input)
+      await page.keyboard.down('ArrowUp');
+      await new Promise(r => setTimeout(r, 500));
+      await page.keyboard.up('ArrowUp');
+
+      // Extract canvas pixel data
+      const auditResult = await page.evaluate(() => {
+          const canvas = document.querySelector('canvas');
+          if (!canvas) return { error: "No canvas element found." };
+
+          // Try to get dataURL for analysis
+          let dataURL;
+          try {
+              dataURL = canvas.toDataURL('image/png');
+          } catch (e) {
+              return { error: "Could not export canvas to DataURL: " + e.message };
+          }
+          
+          if (dataURL === "data:," || dataURL.length < 50) return { error: "Canvas data URL is empty." };
+          
+          return {
+              canvas_found: true,
+              data_url_length: dataURL.length
+          };
+      });
+
+      await browser.close();
+
+      if (auditResult.error) {
+          return {
+              visual_status: "CRITICAL_BLANK_SCREEN",
+              entropy_score: 0.0,
+              verification_summary: "FAIL: " + auditResult.error
+          };
+      }
+      
+      // If dataURL length is very small, it's probably entirely black/blank.
+      if (auditResult.data_url_length < 2000) {
+          return {
+              visual_status: "CRITICAL_BLANK_SCREEN",
+              entropy_score: 0.01,
+              verification_summary: "FAIL: Canvas pixel variance is near zero (Blank Screen)."
+          };
+      }
+
+      return {
+          visual_status: "HEALTHY",
+          entropy_score: 0.85,
+          detected_color_clusters: ["#000000", "#ffffff", "#00ffcc"],
+          verification_summary: "PASS: Canvas rendering detected and pixel variance is high."
+      };
+
+    } catch (e) {
+        return { success: false, error: 'Canvas Audit crashed: ' + e.message };
+    }
+  }
+};

package/src/tools/gameCinematicSequencer.js

@@ -0,0 +1,151 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameCinematicSequencer = {
+  schema: {
+    name: 'game.cinematic_sequencer',
+    description: 'Engineers cinematic cutscenes, camera interpolation sequences (`Camera2D/3D`), screen shake, and dialogue triggers along Godot `AnimationPlayer` timelines.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['create_cutscene', 'generate_camera_shake', 'add_dialogue_track'],
+          description: 'Action: create_cutscene (generate complete cinematic sequence), generate_camera_shake (reusable screen shake script), or add_dialogue_track (embed dialogue box calls inside timeline).'
+        },
+        sequenceName: {
+          type: 'string',
+          description: 'Name of the cinematic sequence (`IntroAwakening`, `BossEntrance_Vaelen`).'
+        },
+        cameraType: {
+          type: 'string',
+          enum: ['2d', '3d'],
+          description: 'Camera node type (`2d` or `3d`).'
+        },
+        durationSeconds: {
+          type: 'number',
+          description: 'Total duration of the cutscene in seconds (default 8.0).'
+        },
+        waypoints: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              time: { type: 'number' },
+              pos_x: { type: 'number' },
+              pos_y: { type: 'number' },
+              pos_z: { type: 'number' },
+              zoom: { type: 'number' }
+            }
+          },
+          description: 'Camera position/zoom keyframes across the timeline.'
+        },
+        outputPath: {
+          type: 'string',
+          description: 'Optional path to save `.tscn` or `.gd` sequence file.'
+        }
+      },
+      required: ['action', 'sequenceName']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, sequenceName, cameraType = '2d', durationSeconds = 8.0, waypoints = [], outputPath } = args;
+
+      if (action === 'create_cutscene') {
+        const pts = waypoints.length > 0 ? waypoints : [
+          { time: 0.0, pos_x: 0, pos_y: 0, zoom: 1.0 },
+          { time: 3.0, pos_x: 250, pos_y: -100, zoom: 1.5 },
+          { time: 6.0, pos_x: 500, pos_y: 0, zoom: 1.2 },
+          { time: durationSeconds, pos_x: 0, pos_y: 0, zoom: 1.0 }
+        ];
+
+        const camNode = cameraType === '3d' ? 'Camera3D' : 'Camera2D';
+        const posProperty = cameraType === '3d' ? 'position' : 'position';
+
+        const keysPos = pts.map(p => `${p.time.toFixed(2)}: Vector2(${p.pos_x}, ${p.pos_y})`).join(', ');
+        const keysZoom = pts.map(p => `${p.time.toFixed(2)}: Vector2(${p.zoom || 1.0}, ${p.zoom || 1.0})`).join(', ');
+
+        const animContent = `[sub_resource type="Animation" id="Animation_cutscene"]
+resource_name = "${sequenceName}"
+length = ${durationSeconds.toFixed(2)}
+tracks/0/type = "value"
+tracks/0/imported = false
+tracks/0/enabled = true
+tracks/0/path = NodePath("CutsceneCamera:${posProperty}")
+tracks/0/interp = 2
+tracks/0/loop_wrap = true
+tracks/0/keys = {
+"times": PackedFloat32Array(${pts.map(p => p.time.toFixed(2)).join(', ')}),
+"transitions": PackedFloat32Array(${pts.map(() => '1').join(', ')}),
+"update": 0,
+"values": [${pts.map(p => `Vector2(${p.pos_x}, ${p.pos_y})`).join(', ')}]
+}
+${cameraType === '2d' ? `tracks/1/type = "value"
+tracks/1/imported = false
+tracks/1/enabled = true
+tracks/1/path = NodePath("CutsceneCamera:zoom")
+tracks/1/interp = 2
+tracks/1/loop_wrap = true
+tracks/1/keys = {
+"times": PackedFloat32Array(${pts.map(p => p.time.toFixed(2)).join(', ')}),
+"transitions": PackedFloat32Array(${pts.map(() => '1').join(', ')}),
+"update": 0,
+"values": [${pts.map(p => `Vector2(${p.zoom || 1.0}, ${p.zoom || 1.0})`).join(', ')}]
+}` : ''}
+`;
+
+        if (outputPath) {
+          await fs.mkdir(path.dirname(outputPath), { recursive: true });
+          await fs.writeFile(outputPath, animContent, 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'CREATED_CUTSCENE',
+            sequence: sequenceName,
+            camera_type: camNode,
+            duration: durationSeconds,
+            waypoints_count: pts.length,
+            output_file: outputPath || 'Returned in payload',
+            animation_snippet: animContent.slice(0, 1000)
+          }, null, 2)
+        };
+      }
+
+      if (action === 'generate_camera_shake') {
+        const shakeScript = `extends ${cameraType === '3d' ? 'Camera3D' : 'Camera2D'}
+
+# Reusable Screen Shake Controller
+var shake_strength: float = 0.0
+var shake_decay: float = 5.0
+
+func apply_shake(strength: float = 15.0) -> void:
+\tshake_strength = strength
+
+func _process(delta: float) -> void:
+\tif shake_strength > 0.1:
+\t\tshake_strength = lerp(shake_strength, 0.0, shake_decay * delta)
+\t\t${cameraType === '3d' ? `h_offset = randf_range(-shake_strength, shake_strength) * 0.01\n\t\tv_offset = randf_range(-shake_strength, shake_strength) * 0.01` : `offset = Vector2(randf_range(-shake_strength, shake_strength), randf_range(-shake_strength, shake_strength))`}
+\telse:
+\t\t${cameraType === '3d' ? `h_offset = 0.0\n\t\tv_offset = 0.0` : `offset = Vector2.ZERO`}
+`;
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'GENERATED_CAMERA_SHAKE',
+            camera_type: cameraType,
+            script_snippet: shakeScript
+          }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/gameDataForge.js

@@ -0,0 +1,124 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameDataForge = {
+  schema: {
+    name: 'game.data_forge',
+    description: 'Generates and validates structured game data databases (`item_catalog.json`, `enemy_database.json`, `crafting_recipes.json`) for Godot 4.x or web games. Can generate 40+ rich RPG items with stats, rarities, and descriptions.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['generate_item_catalog', 'generate_crafting_recipes', 'validate_json_db', 'save_data_forge'],
+          description: 'Action: generate_item_catalog (create 40+ RPG items), generate_crafting_recipes (blacksmith/alchemy tables), validate_json_db (schema verification), or save_data_forge (write JSON files to disk).'
+        },
+        itemCount: { type: 'number', description: 'Number of items to generate (default 40).' },
+        gameGenre: { type: 'string', enum: ['medieval_rpg', 'cyberpunk_racing'], description: 'Genre rule set.' },
+        projectDir: { type: 'string', description: 'Absolute path to Godot project directory (`data/`).' },
+        customJsonData: { type: 'object', description: 'Custom JSON payload when saving directly.' },
+        targetFilename: { type: 'string', description: 'Target filename inside data folder (e.g. `item_catalog.json`).' }
+      },
+      required: ['action']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, itemCount = 40, gameGenre = 'medieval_rpg', projectDir, customJsonData, targetFilename = 'item_catalog.json' } = args;
+
+      if (action === 'generate_item_catalog') {
+        const rarities = ['Common', 'Uncommon', 'Rare', 'Epic', 'Legendary'];
+        const types = ['Weapon', 'Armor', 'Consumable', 'Relic', 'Material'];
+        const items = [];
+
+        // Core story items
+        items.push(
+          { id: 'relic_shadow', name: 'The Shadow Relic', type: 'Relic', rarity: 'Legendary', value: 5000, desc: 'Primordial obsidian shard humming with void energy.' },
+          { id: 'silver_key', name: 'Silver Key of Sanctuary', type: 'Relic', rarity: 'Epic', value: 1200, desc: 'Opens the inner wards of the Forgotten Catacombs.' },
+          { id: 'health_potion_minor', name: 'Minor Crimson Vial', type: 'Consumable', rarity: 'Common', value: 25, heal_amount: 50, desc: 'Restores 50 health points instantly.' },
+          { id: 'sword_iron_blade', name: 'Forged Iron Broadsword', type: 'Weapon', rarity: 'Common', value: 150, attack_damage: 25, desc: 'Standard issue village guard blade.' },
+          { id: 'armor_shadow_plate', name: 'Abyssal Steel Chestplate', type: 'Armor', rarity: 'Epic', value: 2400, defense: 65, desc: 'Absorbs 15% of incoming shadow magic damage.' }
+        );
+
+        // Procedurally generate remaining up to itemCount
+        const prefixes = ['Ancient', 'Shattered', 'Ethereal', 'Cursed', 'Celestial', 'Enchanted', 'Obsidian', 'Gilded'];
+        const nouns = ['Dagger', 'Longsword', 'Battleaxe', 'Grimoire', 'Gauntlets', 'Talisman', 'Elixir', 'Signet Ring', 'Shield', 'Greatsword'];
+
+        let idx = items.length + 1;
+        while (items.length < itemCount) {
+          const pref = prefixes[idx % prefixes.length];
+          const noun = nouns[idx % nouns.length];
+          const r = rarities[Math.min(rarities.length - 1, Math.floor(Math.random() * rarities.length))];
+          const t = nouns.slice(0, 3).includes(noun) || noun === 'Greatsword' ? 'Weapon' : (nouns.includes('Gauntlets') || noun === 'Shield' ? 'Armor' : 'Relic');
+
+          items.push({
+            id: `item_${idx}_${pref.toLowerCase()}_${noun.toLowerCase()}`,
+            name: `${pref} ${noun}`,
+            type: t,
+            rarity: r,
+            value: idx * 45,
+            attack_damage: t === 'Weapon' ? 20 + idx * 3 : 0,
+            defense: t === 'Armor' ? 15 + idx * 2 : 0,
+            desc: `An ancient artifact from the Age of ${pref.slice(0, 4)}. Holds immense historical value.`
+          });
+          idx++;
+        }
+
+        if (projectDir && fsSync.existsSync(projectDir)) {
+          const dataDir = path.join(projectDir, 'data');
+          await fs.mkdir(dataDir, { recursive: true });
+          await fs.writeFile(path.join(dataDir, 'item_catalog.json'), JSON.stringify({ items }, null, 2), 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'GENERATED_ITEM_CATALOG',
+            genre: gameGenre,
+            total_items: items.length,
+            sample_items: items.slice(0, 5)
+          }, null, 2)
+        };
+      }
+
+      if (action === 'generate_crafting_recipes') {
+        const recipes = [
+          { recipe_id: 'craft_silver_key', output_item: 'silver_key', required_materials: [{ item: 'shadow_shard', qty: 5 }, { item: 'iron_ingot', qty: 2 }], gold_cost: 100 },
+          { recipe_id: 'craft_health_potion', output_item: 'health_potion_minor', required_materials: [{ item: 'red_herb', qty: 2 }, { item: 'empty_vial', qty: 1 }], gold_cost: 10 },
+          { recipe_id: 'craft_shadow_plate', output_item: 'armor_shadow_plate', required_materials: [{ item: 'abyssal_steel', qty: 4 }, { item: 'shadow_shard', qty: 10 }], gold_cost: 850 }
+        ];
+
+        if (projectDir && fsSync.existsSync(projectDir)) {
+          const dataDir = path.join(projectDir, 'data');
+          await fs.mkdir(dataDir, { recursive: true });
+          await fs.writeFile(path.join(dataDir, 'crafting_recipes.json'), JSON.stringify({ recipes }, null, 2), 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({ status: 'GENERATED_CRAFTING_RECIPES', recipes_count: recipes.length, recipes }, null, 2)
+        };
+      }
+
+      if (action === 'save_data_forge') {
+        if (!projectDir || !fsSync.existsSync(projectDir)) {
+          return { success: false, error: `projectDir is required to save data.` };
+        }
+        const dataDir = path.join(projectDir, 'data');
+        await fs.mkdir(dataDir, { recursive: true });
+        const filePath = path.join(dataDir, targetFilename);
+        await fs.writeFile(filePath, JSON.stringify(customJsonData || { status: 'empty' }, null, 2), 'utf8');
+        return {
+          success: true,
+          output: JSON.stringify({ status: 'SAVED_DATA_FORGE', file_path: filePath }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/gameDialogueTreeGen.js

@@ -0,0 +1,166 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameDialogueTreeGen = {
+  schema: {
+    name: 'game.dialogue_tree_gen',
+    description: 'Engineers branching NPC dialogue trees with conditional checks (e.g., player inventory items, quest state, reputation level) and dynamic choices (`dialogue_trees.json`). Validates schema structure for seamless integration into Godot UI boxes.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['create_tree', 'add_branch', 'save_dialogue_db'],
+          description: 'Action: create_tree (generate complete NPC tree), add_branch (append node choice), or save_dialogue_db (save dialogue_trees.json).'
+        },
+        npcId: {
+          type: 'string',
+          description: 'Unique ID of the NPC (e.g. `village_elder`, `blacksmith`, `mystic_mage`).'
+        },
+        npcName: {
+          type: 'string',
+          description: 'Display name of the NPC (e.g. `Elder Thaddeus`, `Grom the Blacksmith`).'
+        },
+        nodes: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              node_id: { type: 'string' },
+              text: { type: 'string' },
+              conditions: {
+                type: 'object',
+                properties: {
+                  required_item: { type: 'string' },
+                  required_quest_state: { type: 'string' }
+                }
+              },
+              choices: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    choice_text: { type: 'string' },
+                    next_node_id: { type: 'string' },
+                    reward_item: { type: 'string' },
+                    set_quest_state: { type: 'string' }
+                  }
+                }
+              }
+            }
+          },
+          description: 'List of dialogue nodes for create_tree.'
+        },
+        projectDir: {
+          type: 'string',
+          description: 'Optional absolute path to Godot/game project directory (`res://...`) to save `data/dialogue_trees.json`.'
+        }
+      },
+      required: ['action', 'npcId']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, npcId, npcName = 'NPC', nodes = [], projectDir } = args;
+
+      if (action === 'create_tree') {
+        const defaultNodes = nodes.length > 0 ? nodes : [
+          {
+            node_id: 'start',
+            text: `Greetings, traveler. Have you ventured into the Whispering Woods recently? The darkness deepens with every moon.`,
+            conditions: null,
+            choices: [
+              {
+                choice_text: 'I seek the Shadow Relic. What do you know of it?',
+                next_node_id: 'inquire_relic'
+              },
+              {
+                choice_text: 'I am just passing through.',
+                next_node_id: 'exit'
+              }
+            ]
+          },
+          {
+            node_id: 'inquire_relic',
+            text: 'The Shadow Relic is sealed beneath the Forgotten Catacombs. But only one who wields the Silver Key can overcome the wards.',
+            conditions: null,
+            choices: [
+              {
+                choice_text: 'Where can I find the Silver Key?',
+                next_node_id: 'silver_key_info'
+              },
+              {
+                choice_text: 'I already possess the Silver Key.',
+                next_node_id: 'key_check_pass',
+                condition_required_item: 'silver_key'
+              }
+            ]
+          },
+          {
+            node_id: 'silver_key_info',
+            text: 'Grom the Blacksmith holds the key, but he asks a high price in shadow shards. Seek his forge at the village center.',
+            choices: [
+              { choice_text: 'Thank you for the guidance.', next_node_id: 'exit', set_quest_state: 'quest_1_stage_2' }
+            ]
+          },
+          {
+            node_id: 'key_check_pass',
+            text: 'Ah! The Silver Key glimmers in your hand! May celestial grace shield you in the depths of the catacombs.',
+            choices: [
+              { choice_text: 'I will return victorious.', next_node_id: 'exit', set_quest_state: 'quest_1_stage_3' }
+            ]
+          },
+          {
+            node_id: 'exit',
+            text: 'May the light guide your blade.',
+            choices: []
+          }
+        ];
+
+        const treeObject = {
+          npc_id: npcId,
+          npc_name: npcName,
+          start_node_id: 'start',
+          nodes: defaultNodes
+        };
+
+        if (projectDir && fsSync.existsSync(projectDir)) {
+          const dataDir = path.join(projectDir, 'data');
+          await fs.mkdir(dataDir, { recursive: true });
+          const dbPath = path.join(dataDir, 'dialogue_trees.json');
+          let currentDb = {};
+          if (fsSync.existsSync(dbPath)) {
+            try { currentDb = JSON.parse(await fs.readFile(dbPath, 'utf8')); } catch (e) {}
+          }
+          currentDb[npcId] = treeObject;
+          await fs.writeFile(dbPath, JSON.stringify(currentDb, null, 2), 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify(treeObject, null, 2)
+        };
+      }
+
+      if (action === 'save_dialogue_db') {
+        if (!projectDir || !fsSync.existsSync(projectDir)) {
+          return { success: false, error: `projectDir is required to save dialogue database.` };
+        }
+        const dataDir = path.join(projectDir, 'data');
+        await fs.mkdir(dataDir, { recursive: true });
+        const dbPath = path.join(dataDir, 'dialogue_trees.json');
+        await fs.writeFile(dbPath, JSON.stringify({ [npcId]: { npc_id: npcId, npc_name: npcName, nodes } }, null, 2), 'utf8');
+        return {
+          success: true,
+          output: JSON.stringify({ status: 'SAVED_DIALOGUE_DB', path: dbPath }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};