create-walle 0.9.11 → 0.9.13

package/template/wall-e/coding/tool-registry.js

@@ -0,0 +1,361 @@
+'use strict';
+
+class ToolRegistry {
+  constructor({
+    builtinTools = [],
+    middleware = null,
+    localTools = null,
+    mcpClient = null,
+    skillRunner = null,
+    agentCatalog = null,
+    taskTool = null,
+    taskRunner = null,
+    agentRuntime = null,
+    brain = null,
+    transcript = null,
+    projectRoot = process.cwd(),
+    enableTaskTool = false,
+    specialHandlers = {},
+  } = {}) {
+    this.middleware = middleware || null;
+    this.localTools = localTools || null;
+    this.mcpClient = mcpClient || null;
+    this.skillRunner = skillRunner || null;
+    this.taskTool = taskTool || null;
+    this.bridgeToolTargets = new Map();
+    if (!this.taskTool && enableTaskTool) {
+      const { AgentCatalog } = require('./agent-catalog');
+      const { TaskTool } = require('./task-tool');
+      this.taskTool = new TaskTool({
+        agentCatalog: agentCatalog || new AgentCatalog({ projectRoot }),
+        runner: taskRunner,
+        agentRuntime,
+        brain,
+        transcript,
+      });
+    }
+    this.specialHandlers = { ...specialHandlers };
+    this.tools = new Map();
+    for (const tool of builtinTools || []) {
+      this.register(tool.name, tool);
+    }
+  }
+
+  register(name, definition = {}) {
+    if (!name) throw new Error('tool name is required');
+    const normalized = normalizeDefinition({ name, ...definition });
+    this.tools.set(name, normalized);
+    return normalized;
+  }
+
+  async getDefinitions(ctx = {}) {
+    const merged = new Map();
+    for (const [name, def] of this.tools) merged.set(name, normalizeDefinition(def));
+    if (this.middleware?.getRegisteredTools) {
+      for (const [name, def] of Object.entries(this.middleware.getRegisteredTools())) {
+        merged.set(name, normalizeDefinition({ name, ...def }));
+      }
+    }
+    for (const bridge of await this._bridgeDefinitions(ctx)) {
+      if (!merged.has(bridge.name)) merged.set(bridge.name, bridge);
+    }
+
+    let definitions = [...merged.values()].map(publicDefinition);
+    if (this.middleware?.run) {
+      definitions = await this.middleware.run('tool.definitions', ctx, definitions);
+    }
+    return definitions;
+  }
+
+  async execute(name, args = {}, ctx = {}) {
+    if (this.specialHandlers[name]) {
+      return this.specialHandlers[name](args, ctx);
+    }
+
+    const middlewareTool = this.middleware?.getRegisteredTools?.()[name];
+    if (middlewareTool) {
+      if (typeof middlewareTool.execute !== 'function') {
+        return invalidTool(name, 'Registered tool has no execute function');
+      }
+      return middlewareTool.execute(args, ctx);
+    }
+
+    const registered = this.tools.get(name);
+    if (registered?.execute) {
+      return registered.execute(args, ctx);
+    }
+
+    if (name === 'mcp_call' && this.mcpClient?.callTool) {
+      return this._callMcpTool(args.server || '', args.tool, args.arguments || {}, ctx);
+    }
+    const bridgeTarget = this.bridgeToolTargets.get(name);
+    if (bridgeTarget?.type === 'mcp' && this.mcpClient?.callTool) {
+      return this._callMcpTool(bridgeTarget.server, bridgeTarget.tool, args, ctx);
+    }
+    if (bridgeTarget?.type === 'skill') {
+      return this._runSkill(bridgeTarget.name, args, ctx);
+    }
+    if (name === 'skill' && this.skillRunner) {
+      return this._runSkill(args.name, args.arguments || {}, ctx);
+    }
+    if (name === 'task' && this.taskTool) {
+      return this.taskTool.execute(args, ctx);
+    }
+
+    const local = this.localTools || safeLocalTools();
+    if (local?.executeLocalTool) {
+      const result = await local.executeLocalTool(name, args);
+      if (result !== null && result !== undefined) return result;
+    }
+    return invalidTool(name, `Unknown tool: ${name}`);
+  }
+
+  async _bridgeDefinitions() {
+    this.bridgeToolTargets.clear();
+    const definitions = [];
+    if (this.mcpClient) {
+      definitions.push(normalizeDefinition({
+        name: 'mcp_call',
+        description: 'Call an MCP tool by server and tool name.',
+        input_schema: {
+          type: 'object',
+          properties: {
+            server: { type: 'string' },
+            tool: { type: 'string' },
+            arguments: { type: 'object' },
+          },
+          required: ['server', 'tool'],
+        },
+      }));
+      const tools = await this._listMcpTools();
+      for (const tool of tools) {
+        const publicName = uniqueBridgeName('mcp', tool.server, tool.name, definitions, this.bridgeToolTargets);
+        this.bridgeToolTargets.set(publicName, {
+          type: 'mcp',
+          server: tool.server || '',
+          tool: tool.name,
+        });
+        definitions.push(normalizeDefinition({
+          name: publicName,
+          description: bridgeDescription('MCP', tool.server, tool.name, tool.description),
+          input_schema: tool.input_schema,
+        }));
+      }
+    }
+    if (this.skillRunner) {
+      definitions.push(normalizeDefinition({
+        name: 'skill',
+        description: 'Run a Wall-E skill by name with JSON arguments.',
+        input_schema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            arguments: { type: 'object' },
+          },
+          required: ['name'],
+        },
+      }));
+      const skills = await this._listSkills();
+      for (const skill of skills) {
+        const publicName = uniqueBridgeName('skill', '', skill.name, definitions, this.bridgeToolTargets);
+        this.bridgeToolTargets.set(publicName, {
+          type: 'skill',
+          name: skill.name,
+        });
+        definitions.push(normalizeDefinition({
+          name: publicName,
+          description: bridgeDescription('Skill', '', skill.name, skill.description),
+          input_schema: skill.input_schema,
+        }));
+      }
+    }
+    if (this.taskTool) {
+      definitions.push(normalizeDefinition(this.taskTool.definition()));
+    }
+    return definitions;
+  }
+
+  async _listMcpTools() {
+    const client = this.mcpClient;
+    if (!client) return [];
+    try {
+      if (typeof client.listTools === 'function') {
+        return normalizeMcpToolList(await client.listTools());
+      }
+      if (typeof client.getTools === 'function') {
+        return normalizeMcpToolList(await client.getTools());
+      }
+    } catch {}
+    return [];
+  }
+
+  async _listSkills() {
+    const runner = this.skillRunner;
+    if (!runner) return [];
+    try {
+      const raw = typeof runner.listSkills === 'function'
+        ? await runner.listSkills()
+        : typeof runner.getSkills === 'function'
+          ? await runner.getSkills()
+          : Array.isArray(runner.skills)
+            ? runner.skills
+            : [];
+      return normalizeSkillList(raw);
+    } catch {}
+    return [];
+  }
+
+  _callMcpTool(server, tool, args, ctx) {
+    if (!this.mcpClient?.callTool) return invalidTool(tool, 'MCP client has no callTool function');
+    if (server) return this.mcpClient.callTool(server, tool, args || {}, ctx);
+    return this.mcpClient.callTool(tool, args || {}, ctx);
+  }
+
+  _runSkill(name, args, ctx) {
+    if (!this.skillRunner) return invalidTool(name, 'Skill runner is not configured');
+    if (typeof this.skillRunner === 'function') {
+      return this.skillRunner({ name, arguments: args || {} }, ctx);
+    }
+    if (typeof this.skillRunner.run === 'function') {
+      return this.skillRunner.run(name, args || {}, ctx);
+    }
+    if (typeof this.skillRunner.execute === 'function') {
+      return this.skillRunner.execute({ name, arguments: args || {} }, ctx);
+    }
+    return invalidTool(name, 'Skill runner has no execute function');
+  }
+}
+
+function normalizeDefinition(def = {}) {
+  const inputSchema = def.input_schema || def.parameters || {
+    type: 'object',
+    properties: {},
+  };
+  return {
+    ...def,
+    name: def.name,
+    description: def.description || '',
+    input_schema: inputSchema,
+  };
+}
+
+function publicDefinition(def = {}) {
+  return {
+    name: def.name,
+    description: def.description || '',
+    input_schema: def.input_schema || def.parameters || { type: 'object', properties: {} },
+  };
+}
+
+function invalidTool(name, message) {
+  return {
+    error: message,
+    invalid: true,
+    tool: name,
+  };
+}
+
+function normalizeMcpToolList(raw) {
+  const out = [];
+  for (const item of flattenToolList(raw)) {
+    const name = item.tool || item.name;
+    if (!name) continue;
+    out.push({
+      server: item.server || item.serverName || '',
+      name,
+      description: item.description || '',
+      input_schema: schemaFrom(item),
+    });
+  }
+  return out;
+}
+
+function normalizeSkillList(raw) {
+  return flattenToolList(raw).map((item) => ({
+    name: item.name,
+    description: item.description || '',
+    input_schema: schemaFrom(item),
+  })).filter((item) => item.name);
+}
+
+function flattenToolList(raw, inheritedServer = '') {
+  if (!raw) return [];
+  if (Array.isArray(raw)) {
+    return raw.flatMap((item) => flattenToolList(item, inheritedServer));
+  }
+  if (raw.tools && Array.isArray(raw.tools)) {
+    const server = raw.server || raw.serverName || raw.name || inheritedServer;
+    return raw.tools.flatMap((tool) => flattenToolList({ ...tool, server: tool.server || server }, server));
+  }
+  if (raw.result?.tools) return flattenToolList(raw.result.tools, inheritedServer);
+  if (raw.servers && typeof raw.servers === 'object') return flattenToolList(raw.servers, inheritedServer);
+  if (typeof raw === 'object' && !raw.name && !raw.tool && !raw.inputSchema && !raw.input_schema && !raw.parameters) {
+    const rows = [];
+    for (const [server, value] of Object.entries(raw)) {
+      rows.push(...flattenToolList(value, server));
+    }
+    return rows;
+  }
+  return [{ ...raw, server: raw.server || inheritedServer }];
+}
+
+function schemaFrom(item = {}) {
+  return item.input_schema || item.inputSchema || item.parameters || {
+    type: 'object',
+    properties: {},
+  };
+}
+
+function bridgeDescription(kind, server, name, description) {
+  const prefix = server ? `${kind} ${server}.${name}` : `${kind} ${name}`;
+  return description ? `${prefix}: ${description}` : prefix;
+}
+
+function uniqueBridgeName(prefix, server, name, definitions, targets) {
+  const base = compactToolName(`${prefix}${server ? `__${server}` : ''}__${name}`);
+  const used = new Set([
+    ...definitions.map((definition) => definition.name),
+    ...targets.keys(),
+  ]);
+  if (!used.has(base)) return base;
+  const hash = shortHash(`${prefix}:${server}:${name}`);
+  return compactToolName(`${base}__${hash}`);
+}
+
+function compactToolName(value) {
+  const cleaned = String(value || '')
+    .replace(/[^A-Za-z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/_{3,}/g, '__')
+    || 'tool';
+  if (cleaned.length <= 64) return cleaned;
+  const hash = shortHash(cleaned);
+  return `${cleaned.slice(0, 55)}_${hash}`;
+}
+
+function shortHash(value) {
+  let hash = 5381;
+  const text = String(value || '');
+  for (let i = 0; i < text.length; i++) {
+    hash = ((hash << 5) + hash) ^ text.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36).slice(0, 8);
+}
+
+function safeLocalTools() {
+  try {
+    return require('../tools/local-tools');
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  ToolRegistry,
+  normalizeDefinition,
+  publicDefinition,
+  invalidTool,
+  normalizeMcpToolList,
+  normalizeSkillList,
+  compactToolName,
+};

package/template/wall-e/coding/transcript-writer.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const os = require('node:os');
+const { WorkspaceReplay } = require('./workspace-replay');
+
+const VERSION = 'walle-jsonl-v1';
+
+class CodingTranscript {
+  constructor({
+    sessionId,
+    replay = null,
+    cwd = '',
+    chatSessionId = '',
+    label = '',
+    modelId = '',
+    modelProvider = '',
+    runtimeMode = '',
+    agent = '',
+    mode = '',
+    now = () => new Date().toISOString(),
+  } = {}) {
+    if (!sessionId) throw new Error('sessionId is required');
+    this.sessionId = sessionId;
+    this.replay = replay || new WorkspaceReplay({ now });
+    this.defaults = { cwd, chatSessionId, label, modelId, modelProvider, runtimeMode, agent, mode };
+    this.now = now;
+    this._sessions = new Set();
+  }
+
+  ensureSession(opts = {}) {
+    const sessionId = opts.sessionId || this.sessionId;
+    if (this._sessions.has(sessionId)) return null;
+    this._sessions.add(sessionId);
+    return this.replay.appendRecord(sessionId, {
+      type: 'session_meta',
+      provider: 'walle',
+      version: VERSION,
+      sessionId,
+      chatSessionId: opts.chatSessionId || this.defaults.chatSessionId || '',
+      cwd: opts.cwd || this.defaults.cwd || '',
+      label: opts.label || this.defaults.label || '',
+      modelId: opts.modelId || this.defaults.modelId || '',
+      modelProvider: opts.modelProvider || this.defaults.modelProvider || '',
+      runtimeMode: opts.runtimeMode || this.defaults.runtimeMode || '',
+      agent: opts.agent || this.defaults.agent || '',
+      mode: opts.mode || this.defaults.mode || '',
+      hostname: os.hostname(),
+      uuid: newUuid(),
+      timestamp: opts.timestamp || this.now(),
+    });
+  }
+
+  append(record = {}) {
+    const sessionId = record.sessionId || this.sessionId;
+    this.ensureSession({ sessionId, cwd: record.cwd || this.defaults.cwd });
+    return this.replay.appendRecord(sessionId, normalizeRecord({
+      sessionId,
+      cwd: this.defaults.cwd,
+      timestamp: this.now(),
+      ...record,
+    }));
+  }
+
+  appendPart(arg, partType, data, opts = {}) {
+    if (arguments.length === 1 && arg && typeof arg === 'object') {
+      const record = arg;
+      const sessionId = record.sessionId || this.sessionId;
+      this.ensureSession({ sessionId, cwd: record.cwd || this.defaults.cwd });
+      return this.append({
+        type: 'walle_part',
+        ...record,
+        sessionId,
+        cwd: record.cwd || this.defaults.cwd,
+        chatSessionId: record.chatSessionId || this.defaults.chatSessionId,
+        partType: record.partType || 'event',
+        data: record.data || {},
+      });
+    }
+    const sessionId = arg || this.sessionId;
+    this.ensureSession({ sessionId, cwd: opts.cwd || this.defaults.cwd });
+    return this.replay.appendPart(sessionId, partType || 'event', data || {}, {
+      cwd: opts.cwd || this.defaults.cwd,
+      chatSessionId: opts.chatSessionId || this.defaults.chatSessionId,
+      parentUuid: opts.parentUuid || null,
+    });
+  }
+
+  appendUserMessage(text, opts = {}) {
+    return this.append(messageRecord('user', text, opts, this));
+  }
+
+  appendAssistantMessage(text, opts = {}) {
+    const record = messageRecord('assistant', text, opts, this);
+    record.modelId = opts.model || opts.modelId || this.defaults.modelId || '';
+    record.modelProvider = opts.provider || opts.modelProvider || this.defaults.modelProvider || '';
+    record.tokens = opts.tokens || {};
+    record.cost = Number.isFinite(opts.cost) ? opts.cost : null;
+    return this.append(record);
+  }
+}
+
+function createCodingTranscript(opts = {}) {
+  if (opts.transcript) return opts.transcript;
+  if (opts.persistTranscript === false) return null;
+  return new CodingTranscript(opts);
+}
+
+function normalizeRecord(record = {}) {
+  return {
+    provider: 'walle',
+    version: VERSION,
+    uuid: record.uuid || newUuid(),
+    timestamp: record.timestamp || new Date().toISOString(),
+    ...record,
+  };
+}
+
+function messageRecord(role, text, opts = {}, transcript) {
+  const sessionId = opts.sessionId || transcript.sessionId;
+  return normalizeRecord({
+    type: role,
+    sessionId,
+    chatSessionId: opts.chatSessionId || transcript.defaults.chatSessionId || '',
+    parentUuid: opts.parentUuid || null,
+    cwd: opts.cwd || transcript.defaults.cwd || '',
+    message: {
+      role,
+      content: [{ type: 'text', text: String(text || '') }],
+    },
+  });
+}
+
+function newUuid() {
+  return crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex');
+}
+
+module.exports = {
+  VERSION,
+  CodingTranscript,
+  createCodingTranscript,
+  normalizeRecord,
+};