droid-mode 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "droid-mode",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Progressive Code-Mode MCP integration for Factory.ai Droid - access MCP tools without context bloat",
   "type": "module",
   "main": "dist/cli.js",

package/templates/skills/droid-mode/lib/hydrate.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 import fs from "node:fs";
-import { ensureDir, nowIsoCompact, safeIdentifier, writeJson, getDroidModeDataDir, serverNameToDirName } from "./util.mjs";
+import { ensureDir, nowIsoCompact, safeIdentifier, uniqueSafeToolMap, writeJson, getDroidModeDataDir, serverNameToDirName } from "./util.mjs";
 
 /** @param {string} s */
 function toPascalCase(s) {
@@ -104,11 +104,9 @@ export function hydrateTools(opts) {
     if (t) selected.push(t);
   }
 
-  const toolmap = {};
-  for (const t of selected) {
-    const safe = safeIdentifier(t?.name || "tool");
-    toolmap[safe] = t?.name || safe;
-  }
+  // Build collision-free toolmap using shared function
+  const selectedNames = selected.map(t => t?.name || "tool");
+  const toolmap = uniqueSafeToolMap(selectedNames);
 
   writeJson(path.join(baseOut, "tools.json"), selected);
   writeJson(path.join(baseOut, "toolmap.json"), toolmap);
@@ -117,15 +115,22 @@ export function hydrateTools(opts) {
   const toolmapModule = `// Auto-generated by droid-mode.\nexport default ${JSON.stringify(toolmap, null, 2)};\n`;
   fs.writeFileSync(path.join(baseOut, "toolmap.mjs"), toolmapModule, "utf-8");
 
-  // types.d.ts
+  // types.d.ts - use toolmap keys (already collision-free)
   const typeLines = [
     `// Auto-generated by droid-mode (best-effort).`,
     `// This file exists to improve IDE autocomplete; it is NOT a contract.`,
     ``,
   ];
 
+  // Build reverse map: toolName -> safeName for lookup
+  const nameToSafe = Object.create(null);
+  for (const [safe, name] of Object.entries(toolmap)) {
+    nameToSafe[name] = safe;
+  }
+
   for (const t of selected) {
-    const safe = safeIdentifier(t?.name || "tool");
+    const toolName = t?.name || "tool";
+    const safe = nameToSafe[toolName] || safeIdentifier(toolName);
     const pascal = toPascalCase(safe);
     const inSchema = t?.inputSchema || t?.parameters || null;
     const outSchema = t?.outputSchema || null;

package/templates/skills/droid-mode/lib/run.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import vm from "node:vm";
-import { nowIsoCompact, sha256Hex, safeIdentifier, ensureDir, getDroidModeDataDir, writeJson, serverNameToDirName } from "./util.mjs";
+import { nowIsoCompact, sha256Hex, uniqueSafeToolMap, ensureDir, getDroidModeDataDir, writeJson, serverNameToDirName } from "./util.mjs";
 
 /**
  * Static, best-effort disallow list for sandboxed workflows.
@@ -100,13 +100,10 @@ export function createToolApi(opts) {
     throw lastError;
   };
 
-  // safe-name wrapper map
+  // Build collision-free toolmap using shared function
+  const toolmap = uniqueSafeToolMap(opts.toolNames ?? []);
   const t = {};
-  const toolmap = {};
-
-  for (const toolName of opts.toolNames) {
-    const safe = safeIdentifier(toolName);
-    toolmap[safe] = toolName;
+  for (const [safe, toolName] of Object.entries(toolmap)) {
     t[safe] = (args) => call(toolName, args);
   }
 

package/templates/skills/droid-mode/lib/util.mjs

@@ -56,6 +56,55 @@ export function safeIdentifier(toolName) {
   return "_" + camel;
 }
 
+/**
+ * Build a collision-free safeName -> toolName map.
+ * All colliding tools get a hash suffix (not just the "losers").
+ * Guarantees deterministic output regardless of input order.
+ * 
+ * @param {string[]} toolNames
+ * @returns {Record<string, string>} safeName -> originalToolName
+ */
+export function uniqueSafeToolMap(toolNames) {
+  const map = Object.create(null);
+  
+  // Phase 1: Group by base identifier, caching base names
+  // Handle undefined/null names with fallback (matches prior behavior)
+  const groups = new Map(); // base -> [{name, base}, ...]
+  for (const rawName of toolNames) {
+    // Matches exact prior semantics: t?.name || "tool"
+    // Only null/undefined/empty-string fall back; whitespace-only IS kept
+    const toolName = rawName || "tool";
+    const base = safeIdentifier(toolName);
+    if (!groups.has(base)) groups.set(base, []);
+    groups.get(base).push({ name: toolName, base });
+  }
+
+  // Phase 2: Assign safe names (sort colliding groups for determinism)
+  for (const [base, tools] of groups) {
+    if (tools.length === 1) {
+      // No collision: use base name directly
+      map[base] = tools[0].name;
+    } else {
+      // Collision: sort by string comparison for determinism
+      // (localeCompare varies by OS/locale; relational operators are consistent)
+      tools.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+      for (const { name: toolName, base: cachedBase } of tools) {
+        const suffix = sha256Hex(toolName).slice(0, 8); // 8 chars = 4B combinations
+        let safe = `${cachedBase}_${suffix}`;
+        // Guarantee uniqueness even on hash collision (extremely rare)
+        let counter = 0;
+        while (map[safe] !== undefined) {
+          counter++;
+          safe = `${cachedBase}_${suffix}_${counter}`;
+        }
+        map[safe] = toolName;
+      }
+    }
+  }
+
+  return map;
+}
+
 /**
  * Lightweight CLI args parser (supports: --k=v, --k v, flags, positional args).
  * Returns { _: string[], flags: Record<string, string|boolean> }.