@romiluz/clawmongo 0.1.0-rc.0 → 0.1.0-rc.2

package/LICENSE

@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

package/README.md

@@ -1,3 +1,128 @@
 # ClawMongo
 
-A new project created with Intent by Augment.
+> **MongoDB is the brain, OpenClaw is the heart.**
+
+ClawMongo is a MongoDB-native fork of [OpenClaw](https://github.com/TavernAI/OpenClaw) that leverages MongoDB's capabilities (Atlas Search, Vector Search, `$rankFusion`) while maintaining full parity with OpenClaw's features.
+
+[![npm version](https://badge.fury.io/js/@romiluz%2Fclawmongo.svg)](https://www.npmjs.com/package/@romiluz/clawmongo)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **MongoDB-Native Storage** - All data stored in MongoDB with proper indexing and validation
+- **Atlas Search** - Full-text search with autocomplete for sessions and plugins
+- **Vector Search** - `$vectorSearch` with embedding providers (Voyage AI, OpenAI)
+- **$rankFusion** - Native MongoDB fusion of lexical and vector results
+- **7 Messaging Connectors** - WhatsApp, Telegram, Discord, Slack, Google Chat, iMessage, WebSocket
+- **Plugin Framework** - Install plugins from npm with dependency resolution
+- **Automation Engine** - Cron scheduling and event-driven hooks
+- **Production Ready** - Health checks, metrics, rate limiting, graceful shutdown, Docker
+
+## Installation
+
+```bash
+npm install @romiluz/clawmongo
+```
+
+Or use the RC version:
+
+```bash
+npm install @romiluz/clawmongo@next
+```
+
+## Quick Start
+
+```bash
+# Check health
+npx clawmongo health
+
+# Start interactive chat
+npx clawmongo chat
+
+# Send a message
+npx clawmongo send "Hello, ClawMongo!"
+
+# List sessions
+npx clawmongo sessions list
+```
+
+## Configuration
+
+Set environment variables or use a `.env` file:
+
+```bash
+# Required for MongoDB features
+CLAWMONGO_MONGODB_URI=mongodb+srv://...
+
+# LLM Provider (optional - defaults to stub)
+ANTHROPIC_API_KEY=sk-...
+OPENAI_API_KEY=sk-...
+
+# Embedding Provider
+VOYAGE_API_KEY=pa-...
+```
+
+See [docs/ENV.md](docs/ENV.md) for full configuration reference.
+
+## Docker
+
+```bash
+# Build and run
+docker-compose up -d
+
+# Or build manually
+docker build -t clawmongo .
+docker run -p 3000:3000 --env-file .env clawmongo
+```
+
+See [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md) for production deployment guide.
+
+## OpenClaw Parity
+
+ClawMongo maintains 60 capability parity with OpenClaw:
+
+| Category | Capabilities |
+|----------|-------------|
+| Sessions | 10 (lifecycle, scopes, reset) |
+| Retrieval | 12 (lexical, vector, fusion) |
+| Tools | 10 (exec, fs, session) |
+| Connectors | 8 (WhatsApp, Telegram, Discord, Slack, etc.) |
+| Plugins | 10 (lifecycle, hooks, tools) |
+| Automation | 10 (cron, hooks, CLI) |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run type check
+npm run typecheck
+
+# Run health check
+npm run health
+
+# Run sprint checks
+npm run sprint:checks
+```
+
+## Architecture
+
+ClawMongo is organized into modules:
+
+- `src/session/` - Session management
+- `src/retrieval/` - Lexical, vector, and fusion search
+- `src/modules/` - Agent, plugin, automation, gateway
+- `src/connectors/` - Messaging platform connectors
+- `src/cli/` - CLI commands and smoke tests
+- `src/store/mongo/` - MongoDB connection and optimization
+
+## License
+
+MIT - see [LICENSE](LICENSE)
+
+## Credits
+
+- [OpenClaw](https://github.com/TavernAI/OpenClaw) - The original project
+- [MongoDB](https://www.mongodb.com/) - The database
+- [Voyage AI](https://www.voyageai.com/) - Default embedding provider

package/dist/cli/agent-smoke.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env tsx
+/**
+ * Agent Module Smoke Tests
+ *
+ * Tests the core agent module without requiring Anthropic API calls.
+ * Tests types, history, tool execution, and service instantiation.
+ *
+ * @module cli/agent-smoke
+ */
+import { DEFAULT_MODEL_CONFIG, MessageHistory, executeTools, Agent, createAgent } from "../modules/agent/index.js";
+const results = [];
+function test(name, fn) {
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            result
+                .then(() => results.push({ name, passed: true }))
+                .catch((e) => results.push({ name, passed: false, error: String(e) }));
+        }
+        else {
+            results.push({ name, passed: true });
+        }
+    }
+    catch (e) {
+        results.push({ name, passed: false, error: String(e) });
+    }
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`Assertion failed: ${message}`);
+    }
+}
+// ============================================================
+// Test 1: Default model config
+// ============================================================
+test("DEFAULT_MODEL_CONFIG has expected values", () => {
+    assert(DEFAULT_MODEL_CONFIG.model === "claude-sonnet-4-20250514", "model should be claude-sonnet-4-20250514");
+    assert(DEFAULT_MODEL_CONFIG.maxTokens === 4096, "maxTokens should be 4096");
+    assert(DEFAULT_MODEL_CONFIG.temperature === 1.0, "temperature should be 1.0");
+    assert(DEFAULT_MODEL_CONFIG.contextWindowTokens === 180000, "contextWindowTokens should be 180000");
+});
+// ============================================================
+// Test 2: Tool interface
+// ============================================================
+test("Tool interface is valid", () => {
+    const tool = {
+        name: "test_tool",
+        description: "A test tool",
+        inputSchema: {
+            type: "object",
+            properties: {
+                input: { type: "string", description: "Test input" }
+            },
+            required: ["input"]
+        },
+        execute: async (params) => `Executed with: ${JSON.stringify(params)}`
+    };
+    assert(tool.name === "test_tool", "tool name should match");
+    assert(tool.description === "A test tool", "tool description should match");
+    assert(tool.inputSchema.type === "object", "inputSchema type should be object");
+});
+// ============================================================
+// Test 3: Tool execution
+// ============================================================
+test("executeTools executes tools correctly", async () => {
+    const mockTool = {
+        name: "echo",
+        description: "Echo input",
+        inputSchema: { type: "object", properties: {} },
+        execute: async (params) => `Echo: ${JSON.stringify(params)}`
+    };
+    const toolDict = new Map([["echo", mockTool]]);
+    const toolCalls = [
+        { id: "call_1", name: "echo", input: { message: "hello" } }
+    ];
+    const results = await executeTools(toolCalls, toolDict);
+    assert(results.length === 1, "should return 1 result");
+    const first = results[0];
+    assert(first.toolUseId === "call_1", "toolUseId should match");
+    assert(first.content.includes("hello"), "content should include input");
+    assert(first.isError !== true, "should not be error");
+});
+// ============================================================
+// Test 4: Tool not found handling
+// ============================================================
+test("executeTools handles missing tool", async () => {
+    const toolDict = new Map();
+    const toolCalls = [
+        { id: "call_1", name: "nonexistent", input: {} }
+    ];
+    const results = await executeTools(toolCalls, toolDict);
+    assert(results.length === 1, "should return 1 result");
+    const first = results[0];
+    assert(first.isError === true, "should be error");
+    assert(first.content.includes("not found"), "should mention not found");
+});
+// ============================================================
+// Test 5: Tool execution error handling
+// ============================================================
+test("executeTools handles tool errors", async () => {
+    const errorTool = {
+        name: "error_tool",
+        description: "Always errors",
+        inputSchema: { type: "object", properties: {} },
+        execute: async () => { throw new Error("Intentional error"); }
+    };
+    const toolDict = new Map([["error_tool", errorTool]]);
+    const toolCalls = [
+        { id: "call_1", name: "error_tool", input: {} }
+    ];
+    const results = await executeTools(toolCalls, toolDict);
+    assert(results.length === 1, "should return 1 result");
+    const first = results[0];
+    assert(first.isError === true, "should be error");
+    assert(first.content.includes("Intentional error"), "should include error message");
+});
+// ============================================================
+// Test 6: Parallel tool execution
+// ============================================================
+test("executeTools runs tools in parallel", async () => {
+    const executionOrder = [];
+    const slowTool = {
+        name: "slow",
+        description: "Slow tool",
+        inputSchema: { type: "object", properties: {} },
+        execute: async () => {
+            await new Promise(r => setTimeout(r, 50));
+            executionOrder.push("slow");
+            return "slow done";
+        }
+    };
+    const fastTool = {
+        name: "fast",
+        description: "Fast tool",
+        inputSchema: { type: "object", properties: {} },
+        execute: async () => {
+            executionOrder.push("fast");
+            return "fast done";
+        }
+    };
+    const toolDict = new Map([["slow", slowTool], ["fast", fastTool]]);
+    const toolCalls = [
+        { id: "call_1", name: "slow", input: {} },
+        { id: "call_2", name: "fast", input: {} }
+    ];
+    await executeTools(toolCalls, toolDict, true);
+    // In parallel, fast should complete before slow
+    assert(executionOrder[0] === "fast", "fast should execute first in parallel");
+    assert(executionOrder[1] === "slow", "slow should execute second in parallel");
+});
+// ============================================================
+// Test 7: AgentConfig validation
+// ============================================================
+test("AgentConfig is valid", () => {
+    const config = {
+        name: "TestAgent",
+        systemPrompt: "You are a helpful assistant.",
+        tools: [],
+        modelConfig: DEFAULT_MODEL_CONFIG,
+        verbose: false
+    };
+    assert(config.name === "TestAgent", "name should match");
+    assert(config.systemPrompt.includes("helpful"), "systemPrompt should include helpful");
+});
+// ============================================================
+// Test 8: createAgent factory function
+// ============================================================
+test("createAgent creates agent instance", () => {
+    // Note: This test will fail without ANTHROPIC_API_KEY
+    // We're testing the factory function structure, not actual API calls
+    const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+    if (!hasApiKey) {
+        // Skip actual instantiation without API key
+        console.log("  [skipped - no ANTHROPIC_API_KEY]");
+        return;
+    }
+    const agent = createAgent({
+        name: "TestAgent",
+        systemPrompt: "You are a test agent."
+    });
+    assert(agent.getName() === "TestAgent", "agent name should match");
+    assert(agent.getTools().length === 0, "agent should have no tools initially");
+});
+// ============================================================
+// Test 9: Agent tool registration
+// ============================================================
+test("Agent.registerTool adds tools", () => {
+    const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+    if (!hasApiKey) {
+        console.log("  [skipped - no ANTHROPIC_API_KEY]");
+        return;
+    }
+    const agent = createAgent({
+        name: "TestAgent",
+        systemPrompt: "Test"
+    });
+    const tool = {
+        name: "test_tool",
+        description: "Test",
+        inputSchema: { type: "object", properties: {} },
+        execute: async () => "done"
+    };
+    agent.registerTool(tool);
+    assert(agent.getTools().length === 1, "agent should have 1 tool");
+    assert(agent.getTools()[0]?.name === "test_tool", "tool name should match");
+});
+// ============================================================
+// Test 10: Agent token count tracking
+// ============================================================
+test("Agent.getTokenCount returns initial count", () => {
+    const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+    if (!hasApiKey) {
+        console.log("  [skipped - no ANTHROPIC_API_KEY]");
+        return;
+    }
+    const agent = createAgent({
+        name: "TestAgent",
+        systemPrompt: "A short system prompt."
+    });
+    const tokenCount = agent.getTokenCount();
+    assert(tokenCount > 0, "token count should be > 0");
+    assert(tokenCount < 100, "token count for short prompt should be < 100");
+});
+// ============================================================
+// Run all tests and report
+// ============================================================
+async function runTests() {
+    // Wait for async tests to complete
+    await new Promise(r => setTimeout(r, 200));
+    console.log("\n=== Agent Smoke Tests ===\n");
+    let passed = 0;
+    let failed = 0;
+    for (const result of results) {
+        if (result.passed) {
+            console.log(`✅ ${result.name}`);
+            passed++;
+        }
+        else {
+            console.log(`❌ ${result.name}`);
+            console.log(`   Error: ${result.error}`);
+            failed++;
+        }
+    }
+    console.log(`\n📊 Results: ${passed} passed, ${failed} failed\n`);
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+runTests().catch(console.error);

package/dist/cli/automation-smoke.js

@@ -0,0 +1,174 @@
+/**
+ * Automation Module Smoke Tests
+ *
+ * Validates cron and hooks functionality for Sprint 07.
+ */
+import { parseCronExpression, getNextRunTime, getCronRegistry, resetCronRegistry } from "../modules/automation/cron/index.js";
+import { getHookRegistry, getHookHandlerRegistry, getHookExecutor, resetHookServices } from "../modules/automation/hooks/index.js";
+const results = [];
+function test(name, fn) {
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            result
+                .then(() => results.push({ name, passed: true }))
+                .catch((err) => results.push({ name, passed: false, error: String(err) }));
+        }
+        else {
+            results.push({ name, passed: true });
+        }
+    }
+    catch (err) {
+        results.push({ name, passed: false, error: String(err) });
+    }
+}
+function assert(condition, msg) {
+    if (!condition)
+        throw new Error(msg);
+}
+// Cron tests
+test("parseCronExpression parses valid expression", () => {
+    const parts = parseCronExpression("0 9 * * 1");
+    assert(parts !== null, "Should parse valid expression");
+    assert(parts.minute.includes(0), "Minute should be 0");
+    assert(parts.hour.includes(9), "Hour should be 9");
+    assert(parts.dayOfWeek.includes(1), "Day of week should be Monday");
+});
+test("parseCronExpression rejects invalid expression", () => {
+    const parts = parseCronExpression("invalid");
+    assert(parts === null, "Should reject invalid expression");
+});
+test("parseCronExpression handles ranges", () => {
+    const parts = parseCronExpression("0-30 * * * *");
+    assert(parts !== null, "Should parse range");
+    assert(parts.minute.length === 31, "Should have 31 minutes (0-30)");
+});
+test("parseCronExpression handles steps", () => {
+    const parts = parseCronExpression("*/15 * * * *");
+    assert(parts !== null, "Should parse step");
+    if (!parts)
+        throw new Error("Parts should not be null");
+    assert(parts.minute.includes(0), "Should include 0");
+    assert(parts.minute.includes(15), "Should include 15");
+    assert(parts.minute.includes(30), "Should include 30");
+    assert(parts.minute.includes(45), "Should include 45");
+});
+test("getNextRunTime calculates next run for 'at' schedule", () => {
+    const future = new Date(Date.now() + 60000);
+    const schedule = { type: "at", datetime: future };
+    const next = getNextRunTime(schedule);
+    assert(next !== null, "Should return next run time");
+    assert(next.getTime() === future.getTime(), "Should match datetime");
+});
+test("getNextRunTime calculates next run for 'every' schedule", () => {
+    const schedule = { type: "every", interval: 5, unit: "minutes" };
+    const now = new Date();
+    const next = getNextRunTime(schedule, now);
+    assert(next !== null, "Should return next run time");
+    assert(next.getTime() > now.getTime(), "Should be in future");
+});
+test("InMemoryCronRegistry can create and list jobs", async () => {
+    resetCronRegistry();
+    const registry = getCronRegistry();
+    const job = await registry.create({
+        name: "Test Job",
+        schedule: { type: "every", interval: 1, unit: "hours" },
+        handler: "test:handler"
+    });
+    assert(job.id.startsWith("cron-"), "Job ID should have prefix");
+    assert(registry.list().length === 1, "Should have 1 job");
+});
+test("InMemoryCronRegistry can pause and resume jobs", async () => {
+    resetCronRegistry();
+    const registry = getCronRegistry();
+    const job = await registry.create({
+        name: "Pausable Job",
+        schedule: { type: "every", interval: 1, unit: "days" },
+        handler: "test:handler"
+    });
+    await registry.pause(job.id);
+    assert(registry.get(job.id)?.state === "paused", "Should be paused");
+    await registry.resume(job.id);
+    assert(registry.get(job.id)?.state === "active", "Should be active");
+});
+// Hook tests
+test("InMemoryHookRegistry can register and list hooks", async () => {
+    resetHookServices();
+    const registry = getHookRegistry();
+    const hook = await registry.register({
+        name: "Test Hook",
+        event: "message:received",
+        handler: "test:on-message"
+    });
+    assert(hook.id.startsWith("hook-"), "Hook ID should have prefix");
+    assert(registry.list().length === 1, "Should have 1 hook");
+});
+test("InMemoryHookRegistry listForEvent returns sorted hooks", async () => {
+    resetHookServices();
+    const registry = getHookRegistry();
+    await registry.register({ name: "Low", event: "session:start", handler: "h1", priority: "low" });
+    await registry.register({ name: "High", event: "session:start", handler: "h2", priority: "high" });
+    await registry.register({ name: "Normal", event: "session:start", handler: "h3", priority: "normal" });
+    const hooks = registry.listForEvent("session:start");
+    assert(hooks.length === 3, "Should have 3 hooks");
+    const first = hooks[0];
+    assert(Boolean(first && first.priority === "high"), "First should be high priority");
+    const second = hooks[1];
+    assert(Boolean(second && second.priority === "normal"), "Second should be normal");
+    const third = hooks[2];
+    assert(Boolean(third && third.priority === "low"), "Third should be low");
+});
+test("InMemoryHookExecutor emits events and executes handlers", async () => {
+    resetHookServices();
+    const registry = getHookRegistry();
+    const handlerRegistry = getHookHandlerRegistry();
+    const executor = getHookExecutor();
+    let executed = false;
+    const handler = {
+        id: "test:handler",
+        name: "Test Handler",
+        execute: async () => { executed = true; return "ok"; }
+    };
+    handlerRegistry.register(handler);
+    await registry.register({ name: "Emit Test", event: "gateway:startup", handler: "test:handler" });
+    const emitResults = await executor.emit("gateway:startup", { data: {} });
+    assert(emitResults.length === 1, "Should have 1 result");
+    const first = emitResults[0];
+    assert(Boolean(first && first.success), "Should succeed");
+    assert(executed, "Handler should have executed");
+});
+test("InMemoryHookExecutor skips hooks with filter mismatch", async () => {
+    resetHookServices();
+    const registry = getHookRegistry();
+    const executor = getHookExecutor();
+    await registry.register({
+        name: "Filtered Hook",
+        event: "message:received",
+        handler: "test:handler",
+        filter: { channels: ["whatsapp"] }
+    });
+    const emitResults = await executor.emit("message:received", { channelId: "telegram", data: {} });
+    assert(emitResults.length === 1, "Should have 1 result");
+    const result = emitResults[0];
+    assert(Boolean(result && result.skipped), "Should be skipped");
+    assert(Boolean(result && result.skipReason === "Channel not in filter"), "Should have skip reason");
+});
+// Print results
+setTimeout(() => {
+    console.log("\n=== Automation Module Smoke Tests ===\n");
+    let passed = 0;
+    let failed = 0;
+    for (const r of results) {
+        if (r.passed) {
+            console.log(`✓ ${r.name}`);
+            passed++;
+        }
+        else {
+            console.log(`✗ ${r.name}`);
+            console.log(`  Error: ${r.error}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed}/${passed + failed} tests passed`);
+    process.exit(failed > 0 ? 1 : 0);
+}, 100);

package/dist/cli/cli-chat-smoke.js

@@ -0,0 +1,46 @@
+/**
+ * CLI Chat Command Smoke Test
+ *
+ * Validates S5-004: CLI chat command
+ */
+import { chatCommand } from "./commands/chat.js";
+const results = [];
+function test(name, fn) {
+    try {
+        fn();
+        results.push({ name, passed: true });
+    }
+    catch (err) {
+        results.push({ name, passed: false, error: err instanceof Error ? err.message : String(err) });
+    }
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+// Test chat command structure
+test("chatCommand has correct name", () => {
+    assert(chatCommand.name === "chat", "Expected name 'chat'");
+});
+test("chatCommand has description", () => {
+    assert(chatCommand.description.length > 0, "Expected description");
+});
+test("chatCommand has execute function", () => {
+    assert(typeof chatCommand.execute === "function", "Expected execute function");
+});
+test("chatCommand has usage string", () => {
+    assert(typeof chatCommand.usage === "string", "Expected usage string");
+    assert(chatCommand.usage.length > 0, "Expected non-empty usage");
+});
+test("chatCommand has aliases (optional)", () => {
+    // Aliases are optional but should be an array if present
+    if (chatCommand.aliases) {
+        assert(Array.isArray(chatCommand.aliases), "Expected aliases to be array if present");
+    }
+    assert(true, "Aliases check passed");
+});
+// Output results
+const passed = results.filter((r) => r.passed).length;
+const failed = results.filter((r) => !r.passed).length;
+console.log(JSON.stringify({ tests: results.length, passed, failed, results }, null, 2));
+process.exitCode = failed > 0 ? 1 : 0;