get-claudia 1.32.0 → 1.34.0

package/gateway/tests/bridge-tooluse.test.js

@@ -0,0 +1,396 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Bridge } from '../src/bridge.js';
+
+// --- Mock helpers ---
+
+/**
+ * Create a Bridge with mocked internals for testing tool_use flow.
+ * Skips start() entirely; sets up provider, mcpClient, and toolManager directly.
+ */
+function createTestBridge(opts = {}) {
+  const config = {
+    model: 'claude-sonnet-4-20250514',
+    maxTokens: 2048,
+    toolUse: opts.toolUse ?? true,
+    toolUseMaxIterations: opts.maxIterations ?? 5,
+    preRecall: opts.preRecall ?? true,
+    channels: {
+      telegram: { model: '', toolUse: opts.telegramToolUse },
+      slack: { model: '', toolUse: opts.slackToolUse },
+    },
+    memoryDaemon: { pythonPath: '/nonexistent', moduleName: 'test' },
+    ...opts.configOverrides,
+  };
+
+  const bridge = new Bridge(config);
+  bridge.provider = opts.provider || 'anthropic';
+  bridge.memoryAvailable = true;
+  bridge._personality = 'You are Claudia.';
+
+  // Mock MCP client
+  bridge.mcpClient = {
+    callTool: opts.mcpCallTool || (async ({ name, arguments: args }) => ({
+      content: [{ type: 'text', text: JSON.stringify({ tool: name, args, ok: true }) }],
+    })),
+    listTools: async () => ({ tools: [] }),
+  };
+
+  // Mock ToolManager
+  bridge._toolManager = {
+    isExposed: (name) => name.startsWith('memory.') && !['memory.purge', 'memory.buffer_turn', 'memory.merge_entities'].includes(name),
+    getAnthropicTools: () => [
+      { name: 'memory.recall', description: 'Search memories', input_schema: { type: 'object', properties: { query: { type: 'string' } } } },
+      { name: 'memory.remember', description: 'Store memory', input_schema: { type: 'object', properties: { content: { type: 'string' } } } },
+    ],
+    getOllamaTools: () => [
+      { type: 'function', function: { name: 'memory.recall', description: 'Search memories', parameters: { type: 'object', properties: { query: { type: 'string' } } } } },
+    ],
+    isReady: () => true,
+    toolCount: 2,
+  };
+  bridge._toolUseEnabled = true;
+
+  // Mock Anthropic client
+  bridge.anthropic = {
+    messages: {
+      create: opts.anthropicCreate || (async () => ({
+        content: [{ type: 'text', text: 'Hello from Claudia!' }],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      })),
+    },
+  };
+
+  return bridge;
+}
+
+describe('Bridge._isToolUseEnabled', () => {
+  it('returns true for Anthropic by default (auto-detect)', () => {
+    const bridge = new Bridge({
+      channels: {},
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge.provider = 'anthropic';
+    assert.equal(bridge._isToolUseEnabled(), true);
+  });
+
+  it('returns false for Ollama by default (auto-detect)', () => {
+    const bridge = new Bridge({
+      channels: {},
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge.provider = 'ollama';
+    assert.equal(bridge._isToolUseEnabled(), false);
+  });
+
+  it('respects global toolUse: false override', () => {
+    const bridge = new Bridge({
+      toolUse: false,
+      channels: {},
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge.provider = 'anthropic';
+    assert.equal(bridge._isToolUseEnabled(), false);
+  });
+
+  it('respects per-channel toolUse override', () => {
+    const bridge = new Bridge({
+      toolUse: true,
+      channels: { telegram: { toolUse: false } },
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge.provider = 'anthropic';
+
+    assert.equal(bridge._isToolUseEnabled('telegram'), false);
+    assert.equal(bridge._isToolUseEnabled('slack'), true);
+  });
+
+  it('per-channel undefined falls through to global', () => {
+    const bridge = new Bridge({
+      toolUse: true,
+      channels: { telegram: { toolUse: undefined } },
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge.provider = 'anthropic';
+    assert.equal(bridge._isToolUseEnabled('telegram'), true);
+  });
+});
+
+describe('Bridge._callAnthropicWithTools', () => {
+  it('handles text-only response (no tool calls)', async () => {
+    const bridge = createTestBridge();
+
+    const result = await bridge._callAnthropicWithTools(
+      'You are Claudia.',
+      [{ role: 'user', content: 'Hello' }],
+      'claude-sonnet-4-20250514',
+      'telegram'
+    );
+
+    assert.equal(result.text, 'Hello from Claudia!');
+    assert.ok(result.usage);
+  });
+
+  it('executes single tool call and returns final text', async () => {
+    let callCount = 0;
+    const bridge = createTestBridge({
+      anthropicCreate: async (params) => {
+        callCount++;
+        if (callCount === 1) {
+          // First call: model wants to use a tool
+          return {
+            content: [
+              { type: 'text', text: 'Let me check...' },
+              { type: 'tool_use', id: 'tu_1', name: 'memory.recall', input: { query: 'user preferences' } },
+            ],
+            stop_reason: 'tool_use',
+            usage: { input_tokens: 50, output_tokens: 30 },
+          };
+        }
+        // Second call: model responds with text
+        return {
+          content: [{ type: 'text', text: 'Based on your preferences, you like coffee.' }],
+          stop_reason: 'end_turn',
+          usage: { input_tokens: 80, output_tokens: 40 },
+        };
+      },
+    });
+
+    const messages = [{ role: 'user', content: 'What do I like?' }];
+    const result = await bridge._callAnthropicWithTools(
+      'System prompt',
+      messages,
+      'claude-sonnet-4-20250514',
+      'telegram'
+    );
+
+    assert.equal(result.text, 'Based on your preferences, you like coffee.');
+    assert.equal(callCount, 2);
+    // Usage should be accumulated
+    assert.equal(result.usage.input_tokens, 130);
+    assert.equal(result.usage.output_tokens, 70);
+  });
+
+  it('handles multiple tool calls in one response', async () => {
+    let callCount = 0;
+    const toolCalls = [];
+
+    const bridge = createTestBridge({
+      anthropicCreate: async () => {
+        callCount++;
+        if (callCount === 1) {
+          return {
+            content: [
+              { type: 'tool_use', id: 'tu_1', name: 'memory.recall', input: { query: 'Alice' } },
+              { type: 'tool_use', id: 'tu_2', name: 'memory.recall', input: { query: 'Bob' } },
+            ],
+            stop_reason: 'tool_use',
+            usage: { input_tokens: 50, output_tokens: 30 },
+          };
+        }
+        return {
+          content: [{ type: 'text', text: 'Found info on both.' }],
+          stop_reason: 'end_turn',
+          usage: { input_tokens: 80, output_tokens: 20 },
+        };
+      },
+      mcpCallTool: async ({ name, arguments: args }) => {
+        toolCalls.push({ name, args });
+        return { content: [{ type: 'text', text: JSON.stringify({ ok: true }) }] };
+      },
+    });
+
+    const result = await bridge._callAnthropicWithTools(
+      'System',
+      [{ role: 'user', content: 'Tell me about Alice and Bob' }],
+      'model',
+      'telegram'
+    );
+
+    assert.equal(result.text, 'Found info on both.');
+    assert.equal(toolCalls.length, 2);
+    assert.equal(toolCalls[0].args.query, 'Alice');
+    assert.equal(toolCalls[1].args.query, 'Bob');
+  });
+
+  it('respects max iterations guard', async () => {
+    let callCount = 0;
+
+    const bridge = createTestBridge({
+      maxIterations: 2,
+      anthropicCreate: async (params) => {
+        callCount++;
+        // Always request tool use (except final forced call without tools)
+        if (params.tools) {
+          return {
+            content: [
+              { type: 'tool_use', id: `tu_${callCount}`, name: 'memory.recall', input: { query: 'test' } },
+            ],
+            stop_reason: 'tool_use',
+            usage: { input_tokens: 10, output_tokens: 10 },
+          };
+        }
+        // Final call without tools
+        return {
+          content: [{ type: 'text', text: 'Final response after max iterations' }],
+          stop_reason: 'end_turn',
+          usage: { input_tokens: 10, output_tokens: 10 },
+        };
+      },
+    });
+
+    const result = await bridge._callAnthropicWithTools(
+      'System',
+      [{ role: 'user', content: 'Keep calling' }],
+      'model',
+      'telegram'
+    );
+
+    assert.equal(result.text, 'Final response after max iterations');
+    // 2 iterations with tools + 1 final without tools = 3 total API calls
+    assert.equal(callCount, 3);
+  });
+});
+
+describe('Bridge._executeToolCall', () => {
+  it('rejects non-exposed tools', async () => {
+    const bridge = createTestBridge();
+    const result = await bridge._executeToolCall('memory.purge', {}, 'telegram');
+
+    const parsed = JSON.parse(result);
+    assert.ok(parsed.error);
+    assert.ok(parsed.error.includes('not available'));
+  });
+
+  it('auto-injects source_channel for memory.remember', async () => {
+    let capturedArgs;
+    const bridge = createTestBridge({
+      mcpCallTool: async ({ name, arguments: args }) => {
+        capturedArgs = args;
+        return { content: [{ type: 'text', text: '{"ok": true}' }] };
+      },
+    });
+
+    await bridge._executeToolCall('memory.remember', { content: 'User likes tea' }, 'telegram');
+
+    assert.equal(capturedArgs.source_channel, 'telegram');
+    assert.equal(capturedArgs.content, 'User likes tea');
+  });
+
+  it('auto-injects source_channel for memory.batch', async () => {
+    let capturedArgs;
+    const bridge = createTestBridge({
+      mcpCallTool: async ({ name, arguments: args }) => {
+        capturedArgs = args;
+        return { content: [{ type: 'text', text: '{"ok": true}' }] };
+      },
+    });
+
+    await bridge._executeToolCall('memory.batch', { operations: [] }, 'slack');
+
+    assert.equal(capturedArgs.source_channel, 'slack');
+  });
+
+  it('does not inject source_channel for read operations', async () => {
+    let capturedArgs;
+    const bridge = createTestBridge({
+      mcpCallTool: async ({ name, arguments: args }) => {
+        capturedArgs = args;
+        return { content: [{ type: 'text', text: '{"results": []}' }] };
+      },
+    });
+
+    await bridge._executeToolCall('memory.recall', { query: 'test' }, 'telegram');
+
+    assert.equal(capturedArgs.source_channel, undefined);
+    assert.equal(capturedArgs.query, 'test');
+  });
+
+  it('returns error JSON on MCP failure (never throws)', async () => {
+    const bridge = createTestBridge({
+      mcpCallTool: async () => {
+        throw new Error('Connection lost');
+      },
+    });
+
+    const result = await bridge._executeToolCall('memory.recall', { query: 'test' }, 'telegram');
+    const parsed = JSON.parse(result);
+
+    assert.ok(parsed.error);
+    assert.ok(parsed.error.includes('Connection lost'));
+  });
+});
+
+describe('Bridge.processMessage with toolUse', () => {
+  it('uses tool loop when toolUse is enabled', async () => {
+    let usedTools = false;
+    const bridge = createTestBridge({
+      anthropicCreate: async (params) => {
+        if (params.tools) usedTools = true;
+        return {
+          content: [{ type: 'text', text: 'Response with tools' }],
+          stop_reason: 'end_turn',
+          usage: { input_tokens: 10, output_tokens: 10 },
+        };
+      },
+    });
+
+    const result = await bridge.processMessage(
+      { text: 'Hello', userId: '1', userName: 'Test', channel: 'telegram' },
+      []
+    );
+
+    assert.equal(result.text, 'Response with tools');
+    assert.ok(usedTools, 'Should have passed tools to API');
+  });
+
+  it('skips tool loop when toolUse is disabled', async () => {
+    let usedTools = false;
+    const bridge = createTestBridge({
+      toolUse: false,
+      anthropicCreate: async (params) => {
+        if (params.tools) usedTools = true;
+        return {
+          content: [{ type: 'text', text: 'Response without tools' }],
+          stop_reason: 'end_turn',
+          usage: { input_tokens: 10, output_tokens: 10 },
+        };
+      },
+    });
+    bridge._toolUseEnabled = false;
+
+    const result = await bridge.processMessage(
+      { text: 'Hello', userId: '1', userName: 'Test', channel: 'telegram' },
+      []
+    );
+
+    assert.equal(result.text, 'Response without tools');
+    assert.ok(!usedTools, 'Should NOT have passed tools to API');
+  });
+});
+
+describe('Bridge._buildSystemPrompt with toolUse', () => {
+  it('appends tool instructions when toolUse is true', () => {
+    const bridge = new Bridge({
+      channels: {},
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge._personality = 'You are Claudia.';
+
+    const prompt = bridge._buildSystemPrompt('', 'Test', 'telegram', true);
+    assert.ok(prompt.includes('# Memory Tools'));
+    assert.ok(prompt.includes('Search for more context'));
+  });
+
+  it('omits tool instructions when toolUse is false', () => {
+    const bridge = new Bridge({
+      channels: {},
+      memoryDaemon: { pythonPath: '/x', moduleName: 'x' },
+    });
+    bridge._personality = 'You are Claudia.';
+
+    const prompt = bridge._buildSystemPrompt('', 'Test', 'telegram', false);
+    assert.ok(!prompt.includes('# Memory Tools'));
+  });
+});

package/gateway/tests/tools.test.js

@@ -0,0 +1,192 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { ToolManager, EXPOSED_TOOLS } from '../src/tools.js';
+
+// Mock MCP tool schemas matching what the daemon returns
+const MOCK_MCP_TOOLS = [
+  {
+    name: 'memory.recall',
+    description: 'Search memories semantically',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        limit: { type: 'integer', description: 'Max results' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'memory.remember',
+    description: 'Store a new memory',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Memory content' },
+        about: { type: ['array', 'string'], description: 'Related entities' },
+        importance: { type: 'number', description: 'Importance score' },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name: 'memory.about',
+    description: 'Get context about an entity',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        entity: { type: 'string' },
+      },
+      required: ['entity'],
+    },
+  },
+  // Gateway-internal tool (should be filtered out)
+  {
+    name: 'memory.buffer_turn',
+    description: 'Buffer a conversation turn',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        user_content: { type: 'string' },
+        assistant_content: { type: 'string' },
+      },
+    },
+  },
+  // Destructive/admin tool (should be filtered out)
+  {
+    name: 'memory.purge',
+    description: 'Purge all memories',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'memory.merge_entities',
+    description: 'Merge duplicate entities',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string' },
+        target: { type: 'string' },
+      },
+    },
+  },
+];
+
+class MockMcpClient {
+  constructor(tools = MOCK_MCP_TOOLS) {
+    this._tools = tools;
+  }
+  async listTools() {
+    return { tools: this._tools };
+  }
+}
+
+describe('ToolManager', () => {
+  it('filters to only exposed tools', async () => {
+    const tm = new ToolManager();
+    await tm.initialize(new MockMcpClient());
+
+    const tools = tm.getAnthropicTools();
+    const names = tools.map((t) => t.name);
+
+    assert.ok(names.includes('memory.recall'));
+    assert.ok(names.includes('memory.remember'));
+    assert.ok(names.includes('memory.about'));
+    assert.ok(!names.includes('memory.buffer_turn'), 'Should filter out gateway-internal tools');
+    assert.ok(!names.includes('memory.purge'), 'Should filter out destructive tools');
+    assert.ok(!names.includes('memory.merge_entities'), 'Should filter out admin tools');
+  });
+
+  it('converts MCP inputSchema to Anthropic input_schema', async () => {
+    const tm = new ToolManager();
+    await tm.initialize(new MockMcpClient());
+
+    const recallTool = tm.getAnthropicTools().find((t) => t.name === 'memory.recall');
+    assert.ok(recallTool);
+    assert.ok(recallTool.input_schema, 'Should have input_schema (snake_case)');
+    assert.equal(recallTool.input_schema.type, 'object');
+    assert.ok(recallTool.input_schema.properties.query);
+    assert.deepEqual(recallTool.input_schema.required, ['query']);
+  });
+
+  it('normalizes union types like ["array", "string"]', async () => {
+    const tm = new ToolManager();
+    await tm.initialize(new MockMcpClient());
+
+    const rememberTool = tm.getAnthropicTools().find((t) => t.name === 'memory.remember');
+    const aboutProp = rememberTool.input_schema.properties.about;
+
+    // Should normalize to the first non-null type
+    assert.equal(aboutProp.type, 'array');
+    // Should note the alternative in description
+    assert.ok(aboutProp.description.includes('string'), 'Should mention alternative type');
+  });
+
+  it('converts to Ollama format', async () => {
+    const tm = new ToolManager();
+    await tm.initialize(new MockMcpClient());
+
+    const tools = tm.getOllamaTools();
+    assert.ok(tools.length > 0);
+
+    const recallTool = tools.find((t) => t.function.name === 'memory.recall');
+    assert.ok(recallTool);
+    assert.equal(recallTool.type, 'function');
+    assert.ok(recallTool.function.description);
+    assert.ok(recallTool.function.parameters);
+    assert.equal(recallTool.function.parameters.type, 'object');
+  });
+
+  it('isExposed returns correct values', () => {
+    const tm = new ToolManager();
+
+    assert.equal(tm.isExposed('memory.recall'), true);
+    assert.equal(tm.isExposed('memory.remember'), true);
+    assert.equal(tm.isExposed('memory.trace'), true);
+    assert.equal(tm.isExposed('memory.buffer_turn'), false);
+    assert.equal(tm.isExposed('memory.purge'), false);
+    assert.equal(tm.isExposed('memory.merge_entities'), false);
+    assert.equal(tm.isExposed('nonexistent.tool'), false);
+  });
+
+  it('handles empty tool list gracefully', async () => {
+    const tm = new ToolManager();
+    await tm.initialize(new MockMcpClient([]));
+
+    assert.deepEqual(tm.getAnthropicTools(), []);
+    assert.deepEqual(tm.getOllamaTools(), []);
+    assert.equal(tm.isReady(), false);
+    assert.equal(tm.toolCount, 0);
+  });
+
+  it('handles MCP client error gracefully', async () => {
+    const failingClient = {
+      async listTools() {
+        throw new Error('Connection refused');
+      },
+    };
+
+    const tm = new ToolManager();
+    await tm.initialize(failingClient);
+
+    assert.equal(tm.isReady(), false);
+    assert.deepEqual(tm.getAnthropicTools(), []);
+  });
+
+  it('EXPOSED_TOOLS contains expected set of 14 tools', () => {
+    assert.equal(EXPOSED_TOOLS.size, 14);
+    assert.ok(EXPOSED_TOOLS.has('memory.recall'));
+    assert.ok(EXPOSED_TOOLS.has('memory.about'));
+    assert.ok(EXPOSED_TOOLS.has('memory.remember'));
+    assert.ok(EXPOSED_TOOLS.has('memory.relate'));
+    assert.ok(EXPOSED_TOOLS.has('memory.entity'));
+    assert.ok(EXPOSED_TOOLS.has('memory.search_entities'));
+    assert.ok(EXPOSED_TOOLS.has('memory.batch'));
+    assert.ok(EXPOSED_TOOLS.has('memory.correct'));
+    assert.ok(EXPOSED_TOOLS.has('memory.invalidate'));
+    assert.ok(EXPOSED_TOOLS.has('memory.trace'));
+    assert.ok(EXPOSED_TOOLS.has('memory.reflections'));
+    assert.ok(EXPOSED_TOOLS.has('memory.project_network'));
+    assert.ok(EXPOSED_TOOLS.has('memory.find_path'));
+    assert.ok(EXPOSED_TOOLS.has('memory.briefing'));
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.32.0",
+  "version": "1.34.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/skills/README.md

@@ -106,7 +106,8 @@ argument-hint: [arg]             # Optional: show in /skill [arg] help
 | `brain/` | 3D memory visualizer | "show your brain" |
 | `brain-monitor/` | Terminal memory dashboard | "brain monitor", "memory dashboard" |
 | `meditate/` | End-of-session reflection | "let's wrap up", "end the session" |
-| `setup-telegram.md` | Guided Telegram relay setup | "set up Telegram", "connect Telegram" |
+| `setup-telegram.md` | Guided Telegram relay setup | "Telegram relay", "set up relay" |
+| `setup-gateway.md` | Guided gateway setup (Telegram/Slack) | "set up gateway", "connect Telegram", "setup messaging" |
 
 ### Explicit Only (`/skill-name`)
 
@@ -146,7 +147,7 @@ effort-level: medium
 | Effort | Skills |
 |--------|--------|
 | **low** | morning-brief, accountability-check, client-health, financial-snapshot, growth-check, databases, diagnose, brain-monitor |
-| **medium** | meeting-prep, draft-reply, follow-up-draft, file-document, new-person, capture-meeting, summarize-doc, memory-audit, brain, gateway, fix-duplicates, memory-health, memory-manager, onboarding, structure-generator, agent-dispatcher, setup-telegram |
+| **medium** | meeting-prep, draft-reply, follow-up-draft, file-document, new-person, capture-meeting, summarize-doc, memory-audit, brain, gateway, fix-duplicates, memory-health, memory-manager, onboarding, structure-generator, agent-dispatcher, setup-telegram, setup-gateway |
 | **high** | weekly-review, meditate, research, what-am-i-missing, map-connections, commitment-detector, capability-suggester, concierge, connector-discovery, pattern-recognizer, relationship-tracker, risk-surfacer, structure-evolution, hire-agent |
 | **max** | ingest-sources, pipeline-review, deep-context |
 

package/template-v2/.claude/skills/gateway/SKILL.md

@@ -9,7 +9,7 @@ effort-level: medium
 
 Manage the Claudia Gateway service (Telegram, Slack) from within a session. Start, stop, or check status without needing a separate terminal.
 
-**Triggers:** `/gateway`, `/gateway start`, `/gateway stop`, `/gateway status`, or natural language like "start the gateway", "connect telegram", "stop the gateway", "is the gateway running?"
+**Triggers:** `/gateway`, `/gateway start`, `/gateway stop`, `/gateway status`, or natural language like "start the gateway", "stop the gateway", "is the gateway running?"
 
 ---
 
@@ -98,7 +98,7 @@ ls ~/.claudia/gateway/src/index.js 2>/dev/null
 
 If not found:
 ```
-"The gateway isn't installed yet. You can set it up by running the gateway installer:
+"The gateway isn't installed yet. Run `/setup-gateway` for a guided walkthrough, or install manually:
 `bash ~/.claudia/gateway/scripts/install.sh`"
 ```
 
@@ -147,9 +147,9 @@ If failed, show the error from the log:
 [relevant lines from log]
 
 Common issues:
-- `TELEGRAM_BOT_TOKEN` not set in your shell profile or `~/.claudia/config.json`
+- `TELEGRAM_BOT_TOKEN` not set in your shell profile. Run `/setup-gateway` to configure it.
 - Ollama not running (if using local models)
-- Port conflict on 3848"
+- Port conflict on 3849"
 ```
 
 ---