@siftd/connect-agent 0.1.0 → 0.2.0

package/dist/orchestrator.js

@@ -0,0 +1,532 @@
+/**
+ * Master Orchestrator Agent
+ *
+ * This is the BRAIN - it orchestrates, remembers, and delegates.
+ * It does NOT do the work itself. Claude Code CLI workers do the work.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { spawn } from 'child_process';
+import { AdvancedMemoryStore } from './core/memory-advanced.js';
+import { TaskScheduler } from './core/scheduler.js';
+const SYSTEM_PROMPT = `You are the MASTER ORCHESTRATOR - the user's intelligent assistant accessed via web browser.
+
+CRITICAL IDENTITY:
+You are NOT a coding assistant. You are NOT a worker. You are the ORCHESTRATOR.
+Your job is to UNDERSTAND, REMEMBER, DELEGATE, and SYNTHESIZE.
+
+You have a powerful worker at your disposal: Claude Code CLI. It can:
+- Read, write, edit any file on the user's machine
+- Run any shell command
+- Explore codebases
+- Make multi-file changes
+- Run builds, tests, deployments
+- Do complex development work
+
+YOUR ROLE vs WORKER ROLE:
+┌─────────────────────────────────────────────────────────────────┐
+│ YOU (Master Orchestrator)          │ WORKER (Claude Code CLI)  │
+├────────────────────────────────────┼────────────────────────────┤
+│ Understand user intent             │ Execute file operations   │
+│ Remember user preferences          │ Run shell commands        │
+│ Track ongoing projects             │ Make code changes         │
+│ Decide what needs to be done       │ Explore codebases         │
+│ Delegate complex tasks             │ Build/test/deploy         │
+│ Synthesize results for user        │ Handle multi-step tasks   │
+│ Schedule future work               │ Do the actual work        │
+│ Maintain conversation context      │ Work autonomously         │
+└────────────────────────────────────┴────────────────────────────┘
+
+DELEGATION STRATEGY:
+- ALWAYS delegate: file operations, code changes, builds, tests, deployments
+- ALWAYS delegate: multi-step tasks, codebase exploration
+- ALWAYS delegate: anything requiring filesystem or shell access
+- Handle yourself: simple questions, scheduling, memory operations, conversation
+
+NEVER TRY TO DO THE WORK YOURSELF. You don't have filesystem access. You don't have shell access.
+Your only tools are: delegate_to_worker, remember, search_memory, schedule_task.
+
+WHEN YOU DELEGATE:
+1. Be specific about what you want done
+2. Include context about user preferences from memory
+3. Tell the user you're delegating ("Let me have my worker handle that...")
+4. Wait for results and synthesize them into a clear response
+
+MEMORY SYSTEM:
+You have persistent memory. Use it to:
+- Remember user preferences ("I prefer TypeScript", "I use pnpm")
+- Track ongoing projects and their status
+- Note user's communication style
+- Store important facts about the user's system/environment
+- Remember past conversations and decisions
+
+COMMUNICATION STYLE:
+- Be concise - this is a chat interface, not documentation
+- Be direct - say what you're doing
+- Be helpful - anticipate needs based on memory
+- Acknowledge the user as someone you know and work with
+
+You are the user's intelligent agent - you remember them, understand their projects,
+and orchestrate work on their behalf. You are the persistent layer that makes
+working with AI feel like having a knowledgeable assistant who knows you.`;
+export class MasterOrchestrator {
+    client;
+    model;
+    maxTokens;
+    memory;
+    scheduler;
+    jobs = new Map();
+    jobCounter = 0;
+    userId;
+    workspaceDir;
+    constructor(options) {
+        this.client = new Anthropic({ apiKey: options.apiKey });
+        this.model = options.model || 'claude-sonnet-4-20250514';
+        this.maxTokens = options.maxTokens || 4096;
+        this.userId = options.userId;
+        this.workspaceDir = options.workspaceDir || process.env.HOME || '/tmp';
+        // Initialize memory with user-specific paths
+        this.memory = new AdvancedMemoryStore({
+            dbPath: `memories_${options.userId}.db`,
+            vectorPath: `./memory_vectors_${options.userId}`,
+            voyageApiKey: options.voyageApiKey
+        });
+        this.scheduler = new TaskScheduler(`scheduled_${options.userId}.json`);
+    }
+    /**
+     * Process a user message
+     */
+    async processMessage(message, conversationHistory = [], sendMessage) {
+        // Build context from memory
+        const memoryContext = await this.getMemoryContext(message);
+        // Build system prompt with memory context
+        const systemWithMemory = memoryContext
+            ? `${SYSTEM_PROMPT}\n\nRELEVANT MEMORIES:\n${memoryContext}`
+            : SYSTEM_PROMPT;
+        // Add user message
+        const messages = [
+            ...conversationHistory,
+            { role: 'user', content: message }
+        ];
+        try {
+            const response = await this.runAgentLoop(messages, systemWithMemory, sendMessage);
+            // Auto-remember important things from the conversation
+            await this.autoRemember(message, response);
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return `Error: ${errorMessage}`;
+        }
+    }
+    /**
+     * Get relevant memory context for a message
+     */
+    async getMemoryContext(message) {
+        try {
+            const memories = await this.memory.search(message, { limit: 5 });
+            if (memories.length === 0)
+                return null;
+            return memories.map(m => `[${m.type}] ${m.content}`).join('\n');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Auto-remember important information from conversations
+     */
+    async autoRemember(userMessage, response) {
+        // Look for preference indicators
+        const prefIndicators = ['i prefer', 'i like', 'i always', 'i never', 'i use', 'my favorite'];
+        const lower = userMessage.toLowerCase();
+        for (const indicator of prefIndicators) {
+            if (lower.includes(indicator)) {
+                await this.memory.remember(userMessage, {
+                    type: 'semantic',
+                    source: 'auto-extract',
+                    importance: 0.7,
+                    tags: ['preference', 'user']
+                });
+                break;
+            }
+        }
+    }
+    /**
+     * Run the agentic loop
+     */
+    async runAgentLoop(messages, system, sendMessage) {
+        const tools = this.getToolDefinitions();
+        let currentMessages = [...messages];
+        let iterations = 0;
+        const maxIterations = 15;
+        while (iterations < maxIterations) {
+            iterations++;
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: this.maxTokens,
+                system,
+                tools,
+                messages: currentMessages
+            });
+            // Check if done
+            if (response.stop_reason === 'end_turn' || !this.hasToolUse(response.content)) {
+                return this.extractText(response.content);
+            }
+            // Process tool calls
+            const toolResults = await this.processToolCalls(response.content, sendMessage);
+            // Continue conversation
+            currentMessages = [
+                ...currentMessages,
+                { role: 'assistant', content: response.content },
+                { role: 'user', content: toolResults }
+            ];
+        }
+        return 'Maximum iterations reached.';
+    }
+    /**
+     * Get tool definitions for the orchestrator
+     */
+    getToolDefinitions() {
+        return [
+            {
+                name: 'delegate_to_worker',
+                description: `Delegate a task to Claude Code CLI worker. This is your PRIMARY tool.
+
+Use this for ANY task that involves:
+- Reading, writing, or editing files
+- Running shell commands
+- Exploring codebases
+- Making code changes
+- Building, testing, deploying
+- ANY filesystem or system operation
+
+The worker will execute the task autonomously and return results.
+Be specific about what you want done.`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'Detailed description of what the worker should do'
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'Additional context (user preferences, project info, etc)'
+                        },
+                        working_directory: {
+                            type: 'string',
+                            description: 'Directory to work in (defaults to user home)'
+                        }
+                    },
+                    required: ['task']
+                }
+            },
+            {
+                name: 'remember',
+                description: 'Store something in persistent memory. Use for user preferences, project info, important facts.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        content: {
+                            type: 'string',
+                            description: 'What to remember'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['episodic', 'semantic', 'procedural'],
+                            description: 'Memory type: episodic (events), semantic (facts), procedural (how-to)'
+                        },
+                        importance: {
+                            type: 'number',
+                            description: 'Importance 0-1 (higher = remembered longer)'
+                        }
+                    },
+                    required: ['content']
+                }
+            },
+            {
+                name: 'search_memory',
+                description: 'Search your memory for relevant information. Use before delegating to include user context.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'What to search for'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['episodic', 'semantic', 'procedural'],
+                            description: 'Filter by memory type'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'schedule_task',
+                description: 'Schedule a task for future execution.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'The task to execute later'
+                        },
+                        when: {
+                            type: 'string',
+                            description: 'When to run (e.g., "in 30 minutes", "daily at 9:00", "tomorrow at 14:00")'
+                        }
+                    },
+                    required: ['task', 'when']
+                }
+            },
+            {
+                name: 'list_scheduled',
+                description: 'List all scheduled tasks.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
+            {
+                name: 'memory_stats',
+                description: 'Get statistics about your memory system.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            }
+        ];
+    }
+    /**
+     * Process tool calls
+     */
+    async processToolCalls(content, sendMessage) {
+        const toolUseBlocks = content.filter((block) => block.type === 'tool_use');
+        const results = [];
+        for (const toolUse of toolUseBlocks) {
+            const input = toolUse.input;
+            let result;
+            // Notify user of action
+            if (sendMessage) {
+                const preview = this.formatToolPreview(toolUse.name, input);
+                if (preview)
+                    await sendMessage(preview);
+            }
+            switch (toolUse.name) {
+                case 'delegate_to_worker':
+                    result = await this.delegateToWorker(input.task, input.context, input.working_directory);
+                    break;
+                case 'remember':
+                    result = await this.executeRemember(input.content, input.type, input.importance);
+                    break;
+                case 'search_memory':
+                    result = await this.executeSearchMemory(input.query, input.type);
+                    break;
+                case 'schedule_task':
+                    result = await this.executeScheduleTask(input.task, input.when);
+                    break;
+                case 'list_scheduled':
+                    result = await this.executeListScheduled();
+                    break;
+                case 'memory_stats':
+                    result = await this.executeMemoryStats();
+                    break;
+                default:
+                    result = { success: false, output: `Unknown tool: ${toolUse.name}` };
+            }
+            results.push({
+                type: 'tool_result',
+                tool_use_id: toolUse.id,
+                content: result.output,
+                is_error: !result.success
+            });
+        }
+        return results;
+    }
+    /**
+     * Delegate task to Claude Code CLI worker
+     */
+    async delegateToWorker(task, context, workingDir) {
+        const id = `worker_${Date.now()}_${++this.jobCounter}`;
+        const cwd = workingDir || this.workspaceDir;
+        // Build prompt for worker
+        let prompt = task;
+        if (context) {
+            prompt = `Context: ${context}\n\nTask: ${task}`;
+        }
+        prompt += '\n\nKeep your response concise and focused on results.';
+        console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
+        return new Promise((resolve) => {
+            const job = {
+                id,
+                task: task.slice(0, 200),
+                status: 'running',
+                startTime: Date.now(),
+                output: ''
+            };
+            // Spawn Claude Code CLI - use -p flag and pipe prompt to stdin
+            const child = spawn('claude', ['-p'], {
+                cwd,
+                env: { ...process.env },
+                shell: false
+            });
+            job.process = child;
+            this.jobs.set(id, job);
+            // Send prompt to stdin
+            if (child.stdin) {
+                child.stdin.write(prompt);
+                child.stdin.end();
+            }
+            // Timeout after 5 minutes
+            const timeout = setTimeout(() => {
+                if (job.status === 'running') {
+                    job.status = 'timeout';
+                    job.endTime = Date.now();
+                    child.kill('SIGTERM');
+                    resolve({
+                        success: false,
+                        output: `Worker timed out after 5 minutes.\nPartial output:\n${job.output.slice(-1000)}`
+                    });
+                }
+            }, 5 * 60 * 1000);
+            child.stdout?.on('data', (data) => {
+                job.output += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                // Ignore status messages
+                const text = data.toString();
+                if (!text.includes('Checking') && !text.includes('Connected')) {
+                    job.output += text;
+                }
+            });
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                job.status = code === 0 ? 'completed' : 'failed';
+                job.endTime = Date.now();
+                const duration = ((job.endTime - job.startTime) / 1000).toFixed(1);
+                console.log(`[ORCHESTRATOR] Worker ${id} finished in ${duration}s`);
+                resolve({
+                    success: code === 0,
+                    output: job.output.trim() || '(No output)'
+                });
+            });
+            child.on('error', (err) => {
+                clearTimeout(timeout);
+                job.status = 'failed';
+                job.endTime = Date.now();
+                resolve({
+                    success: false,
+                    output: `Worker error: ${err.message}`
+                });
+            });
+        });
+    }
+    /**
+     * Execute remember tool
+     */
+    async executeRemember(content, type, importance) {
+        try {
+            const id = await this.memory.remember(content, {
+                type: type || undefined,
+                importance
+            });
+            return { success: true, output: `Remembered (${id})` };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to remember: ${error}` };
+        }
+    }
+    /**
+     * Execute search memory tool
+     */
+    async executeSearchMemory(query, type) {
+        try {
+            const memories = await this.memory.search(query, {
+                type: type || undefined,
+                limit: 10
+            });
+            if (memories.length === 0) {
+                return { success: true, output: 'No relevant memories found.' };
+            }
+            const output = memories.map(m => `[${m.type}] (${(m.importance * 100).toFixed(0)}%) ${m.content}`).join('\n\n');
+            return { success: true, output };
+        }
+        catch (error) {
+            return { success: false, output: `Memory search failed: ${error}` };
+        }
+    }
+    /**
+     * Execute schedule task tool
+     */
+    async executeScheduleTask(task, when) {
+        try {
+            const taskId = this.scheduler.schedule(task, when, this.userId);
+            const scheduled = this.scheduler.get(taskId);
+            return {
+                success: true,
+                output: `Scheduled: ${taskId}\nWhen: ${scheduled ? this.scheduler.formatSchedule(scheduled.schedule) : when}`
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Scheduling failed: ${error}` };
+        }
+    }
+    /**
+     * Execute list scheduled tool
+     */
+    async executeListScheduled() {
+        const tasks = this.scheduler.list();
+        if (tasks.length === 0) {
+            return { success: true, output: 'No scheduled tasks.' };
+        }
+        const output = tasks.map(t => `${t.enabled ? '✓' : '⏸'} ${t.id}: ${t.task.slice(0, 50)}... (${this.scheduler.formatSchedule(t.schedule)})`).join('\n');
+        return { success: true, output };
+    }
+    /**
+     * Execute memory stats tool
+     */
+    async executeMemoryStats() {
+        const stats = this.memory.stats();
+        return {
+            success: true,
+            output: `Memories: ${stats.total} (episodic: ${stats.byType.episodic}, semantic: ${stats.byType.semantic}, procedural: ${stats.byType.procedural})\nAvg importance: ${(stats.avgImportance * 100).toFixed(0)}%\nAssociations: ${stats.totalAssociations}`
+        };
+    }
+    /**
+     * Format tool preview for user
+     */
+    formatToolPreview(name, input) {
+        switch (name) {
+            case 'delegate_to_worker':
+                return `Delegating to worker: ${input.task.slice(0, 80)}...`;
+            case 'remember':
+                return `Remembering: ${input.content.slice(0, 50)}...`;
+            case 'search_memory':
+                return `Searching memory: ${input.query}`;
+            case 'schedule_task':
+                return `Scheduling: ${input.task} for ${input.when}`;
+            default:
+                return null;
+        }
+    }
+    hasToolUse(content) {
+        return content.some(block => block.type === 'tool_use');
+    }
+    extractText(content) {
+        return content
+            .filter(block => block.type === 'text')
+            .map(block => block.text)
+            .join('\n');
+    }
+    /**
+     * Shutdown cleanly
+     */
+    shutdown() {
+        this.scheduler.shutdown();
+        this.memory.close();
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.1.0",
-  "description": "Local agent that connects to Connect web app - control Claude Code remotely",
+  "version": "0.2.0",
+  "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -18,11 +18,13 @@
   },
   "keywords": [
     "agent",
+    "orchestrator",
     "cli",
     "connect",
     "claude",
     "remote",
-    "terminal"
+    "terminal",
+    "memory"
   ],
   "repository": {
     "type": "git",
@@ -35,12 +37,18 @@
     "access": "public"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "better-sqlite3": "^11.7.0",
     "commander": "^12.1.0",
     "conf": "^13.0.1",
-    "ora": "^8.1.1"
+    "node-cron": "^3.0.3",
+    "ora": "^8.1.1",
+    "vectra": "^0.9.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^22.10.2",
+    "@types/node-cron": "^3.0.11",
     "typescript": "^5.7.2"
   }
 }