morpheus-cli 0.4.0 → 0.4.2

package/README.md

@@ -153,6 +153,13 @@ The system also supports generic environment variables that apply to all provide
 | `MORPHEUS_SATI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
 | `MORPHEUS_SATI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
 | `MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS`| Enable/disable retrieval of archived sessions in Sati | santi.enableArchivedSessions |
+| `MORPHEUS_APOC_PROVIDER` | Apoc LLM provider | apoc.provider |
+| `MORPHEUS_APOC_MODEL` | Model name for Apoc | apoc.model |
+| `MORPHEUS_APOC_TEMPERATURE` | Temperature for Apoc | apoc.temperature |
+| `MORPHEUS_APOC_MAX_TOKENS` | Maximum tokens for Apoc | apoc.max_tokens |
+| `MORPHEUS_APOC_API_KEY` | API key for Apoc (falls back to provider-specific key) | apoc.api_key |
+| `MORPHEUS_APOC_WORKING_DIR` | Working directory for Apoc file/shell operations | apoc.working_dir |
+| `MORPHEUS_APOC_TIMEOUT_MS` | Timeout in ms for Apoc shell operations (default: 30000) | apoc.timeout_ms |
 | `MORPHEUS_AUDIO_MODEL` | Model name for audio processing | audio.model |
 | `MORPHEUS_AUDIO_ENABLED` | Enable/disable audio processing | audio.enabled |
 | `MORPHEUS_AUDIO_API_KEY` | Generic API key for audio (lower precedence than provider-specific keys) | audio.apiKey |
@@ -206,6 +213,28 @@ When enabled:
 ### 🧩 MCP Support (Model Context Protocol)
 Full integration with [Model Context Protocol](https://modelcontextprotocol.io/), allowing Morpheus to use standardized tools from any MCP-compatible server.
 
+### 🛠️ Apoc (DevTools Subagent)
+
+Morpheus includes **Apoc**, a specialized subagent invoked by Oracle whenever the user requests developer-level operations. Apoc runs with access to the **DevKit** tool set:
+
+| Tool Group | Capabilities |
+|---|---|
+| **Filesystem** | Read, write, append, delete files and directories |
+| **Shell** | Execute shell commands and scripts with timeout control |
+| **Git** | status, log, diff, commit, push, pull, clone, branch |
+| **Packages** | npm/yarn install, update, audit, package.json inspection |
+| **Processes** | List running processes, check ports, terminate processes |
+| **Network** | curl, ping, DNS lookups, HTTP requests |
+| **System** | Environment variables, OS info, disk space, memory usage |
+
+Oracle delegates to Apoc via the `apoc_delegate` tool when you ask things like:
+- *"Run npm install and show me any errors"*
+- *"What's the git status of this repo?"*
+- *"Read the contents of config.json"*
+- *"Execute the build script and tell me what happened"*
+
+Apoc is independently configurable — use a different (e.g., faster, cheaper) model than Oracle for tool execution tasks.
+
 ### 🧠 Sati (Long-Term Memory)
 Morpheus features a dedicated middleware system called **Sati** (Mindfulness) that provides long-term memory capabilities.
 -   **Automated Storage**: Automatically extracts and saves preferences, project details, and facts from conversations.
@@ -309,6 +338,12 @@ santi: # Optional: Sati (Long-Term Memory) specific settings
   provider: "openai" # defaults to llm.provider
   model: "gpt-4o"
   memory_limit: 1000 # Number of messages/items to retrieve
+apoc: # Optional: Apoc DevTools subagent settings
+  provider: "openai" # defaults to llm.provider (can use a cheaper/faster model)
+  model: "gpt-4o-mini"
+  temperature: 0.2
+  working_dir: "/home/user/projects" # root dir for file/shell ops (defaults to process cwd)
+  timeout_ms: 30000 # shell command timeout in ms
 channels:
   telegram:
     enabled: true
@@ -560,6 +595,55 @@ Update the Sati (long-term memory) configuration.
 #### DELETE `/api/config/sati`
 Remove the Sati (long-term memory) configuration (falls back to Oracle config).
 
+*   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
+*   **Response:**
+    ```json
+    {
+      "success": true
+    }
+    ```
+
+
+#### GET `/api/config/apoc`
+Retrieve the Apoc (DevTools subagent) configuration. Falls back to Oracle (LLM) config if not explicitly set.
+
+*   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
+*   **Response:**
+    ```json
+    {
+      "provider": "openai",
+      "model": "gpt-4o-mini",
+      "temperature": 0.2,
+      "api_key": "***",
+      "working_dir": "/home/user/projects",
+      "timeout_ms": 30000
+    }
+    ```
+
+#### POST `/api/config/apoc`
+Update the Apoc (DevTools subagent) configuration.
+
+*   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
+*   **Body:**
+    ```json
+    {
+      "provider": "openai",
+      "model": "gpt-4o-mini",
+      "temperature": 0.2,
+      "working_dir": "/home/user/projects",
+      "timeout_ms": 30000
+    }
+    ```
+*   **Response:**
+    ```json
+    {
+      "success": true
+    }
+    ```
+
+#### DELETE `/api/config/apoc`
+Remove the Apoc configuration (falls back to Oracle config).
+
 *   **Authentication:** Requires `Authorization` header with the password set in `THE_ARCHITECT_PASS`.
 *   **Response:**
     ```json
@@ -860,6 +944,10 @@ npm run test:watch
 │   ├── cli/         # CLI commands and logic
 │   ├── config/      # Configuration management
 │   ├── runtime/     # Core agent logic, lifecycle, and providers
+│   ├── apoc.ts       # Apoc DevTools subagent (filesystem, shell, git, etc.)
+│   ├── oracle.ts     # Oracle main agent (LangChain ReactAgent)
+│   └── providers/    # LLM provider factory (createBare for subagents)
+├── devkit/      # DevKit tool factories (filesystem, shell, git, network, packages, processes, system)
 │   ├── types/       # Shared TypeScript definitions
 │   └── ui/          # React Web UI Dashboard
 └── package.json

package/dist/config/manager.js

@@ -69,6 +69,22 @@ export class ConfigManager {
                 enabled_archived_sessions: resolveBoolean('MORPHEUS_SATI_ENABLED_ARCHIVED_SESSIONS', config.sati.enabled_archived_sessions, true)
             };
         }
+        // Apply precedence to Apoc config
+        let apocConfig;
+        if (config.apoc) {
+            const apocProvider = resolveProvider('MORPHEUS_APOC_PROVIDER', config.apoc.provider, llmConfig.provider);
+            apocConfig = {
+                provider: apocProvider,
+                model: resolveModel(apocProvider, 'MORPHEUS_APOC_MODEL', config.apoc.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_APOC_TEMPERATURE', config.apoc.temperature, llmConfig.temperature),
+                max_tokens: config.apoc.max_tokens !== undefined ? resolveNumeric('MORPHEUS_APOC_MAX_TOKENS', config.apoc.max_tokens, config.apoc.max_tokens) : llmConfig.max_tokens,
+                api_key: resolveApiKey(apocProvider, 'MORPHEUS_APOC_API_KEY', config.apoc.api_key || llmConfig.api_key),
+                base_url: config.apoc.base_url || config.llm.base_url,
+                context_window: config.apoc.context_window !== undefined ? resolveNumeric('MORPHEUS_APOC_CONTEXT_WINDOW', config.apoc.context_window, config.apoc.context_window) : llmConfig.context_window,
+                working_dir: resolveString('MORPHEUS_APOC_WORKING_DIR', config.apoc.working_dir, process.cwd()),
+                timeout_ms: config.apoc.timeout_ms !== undefined ? resolveNumeric('MORPHEUS_APOC_TIMEOUT_MS', config.apoc.timeout_ms, 30_000) : 30_000
+            };
+        }
         // Apply precedence to audio config
         const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
         // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
@@ -112,6 +128,7 @@ export class ConfigManager {
             agent: agentConfig,
             llm: llmConfig,
             sati: satiConfig,
+            apoc: apocConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -153,4 +170,19 @@ export class ConfigManager {
             memory_limit: 10 // Default fallback
         };
     }
+    getApocConfig() {
+        if (this.config.apoc) {
+            return {
+                working_dir: process.cwd(),
+                timeout_ms: 30_000,
+                ...this.config.apoc
+            };
+        }
+        // Fallback to main LLM config with Apoc defaults
+        return {
+            ...this.config.llm,
+            working_dir: process.cwd(),
+            timeout_ms: 30_000
+        };
+    }
 }

package/dist/config/schemas.js

@@ -22,6 +22,10 @@ export const SatiConfigSchema = LLMConfigSchema.extend({
     memory_limit: z.number().int().positive().optional(),
     enabled_archived_sessions: z.boolean().default(true),
 });
+export const ApocConfigSchema = LLMConfigSchema.extend({
+    working_dir: z.string().optional(),
+    timeout_ms: z.number().int().positive().optional(),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
@@ -30,6 +34,7 @@ export const ConfigSchema = z.object({
     }).default(DEFAULT_CONFIG.agent),
     llm: LLMConfigSchema.default(DEFAULT_CONFIG.llm),
     sati: SatiConfigSchema.optional(),
+    apoc: ApocConfigSchema.optional(),
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({
         limit: z.number().int().positive().optional(),

package/dist/devkit/adapters/shell.js

@@ -0,0 +1,80 @@
+import { platform } from 'os';
+export class ShellAdapter {
+    /**
+     * Factory: returns the appropriate adapter for the current OS.
+     * Uses direct imports (ESM-compatible, no require()).
+     */
+    static create() {
+        switch (platform()) {
+            case 'win32': return new WindowsAdapter();
+            case 'darwin': return new MacAdapter();
+            default: return new LinuxAdapter();
+        }
+    }
+}
+// ─── Inline implementations (avoids ESM dynamic import issues) ────────────────
+import { spawn } from 'child_process';
+class WindowsAdapter extends ShellAdapter {
+    getShell() { return { shell: 'cmd.exe', flag: '/c' }; }
+    async run(command, args, options) {
+        return spawnCommand(command, args, { ...options, windowsHide: true, shell: true });
+    }
+    async which(binary) {
+        const result = await this.run('where', [binary], { cwd: process.cwd(), timeout_ms: 5000 });
+        if (result.exitCode !== 0)
+            return null;
+        const first = result.stdout.trim().split(/\r?\n/)[0];
+        return first || null;
+    }
+}
+class LinuxAdapter extends ShellAdapter {
+    getShell() { return { shell: '/bin/bash', flag: '-c' }; }
+    async run(command, args, options) {
+        return spawnCommand(command, args, { ...options, shell: false });
+    }
+    async which(binary) {
+        const result = await this.run('which', [binary], { cwd: process.cwd(), timeout_ms: 5000 });
+        if (result.exitCode !== 0)
+            return null;
+        return result.stdout.trim() || null;
+    }
+}
+class MacAdapter extends ShellAdapter {
+    getShell() { return { shell: '/bin/zsh', flag: '-c' }; }
+    async run(command, args, options) {
+        return spawnCommand(command, args, { ...options, shell: false });
+    }
+    async which(binary) {
+        const result = await this.run('which', [binary], { cwd: process.cwd(), timeout_ms: 5000 });
+        if (result.exitCode !== 0)
+            return null;
+        return result.stdout.trim() || null;
+    }
+}
+function spawnCommand(command, args, options) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            shell: options.shell ?? false,
+            windowsHide: options.windowsHide ?? false,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, options.timeout_ms);
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({ exitCode: 1, stdout, stderr: stderr + err.message, timedOut });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ exitCode: code ?? 1, stdout, stderr, timedOut });
+        });
+    });
+}

package/dist/devkit/index.js

@@ -0,0 +1,10 @@
+// Register all DevKit tool factories
+// Import order matters: each import triggers registerToolFactory() as a side effect
+import './tools/filesystem.js';
+import './tools/shell.js';
+import './tools/processes.js';
+import './tools/network.js';
+import './tools/git.js';
+import './tools/packages.js';
+import './tools/system.js';
+export { buildDevKit } from './registry.js';

package/dist/devkit/registry.js

@@ -0,0 +1,12 @@
+const factories = [];
+export function registerToolFactory(factory) {
+    factories.push(factory);
+}
+/**
+ * Builds the full DevKit tool set for a given context.
+ * Each factory receives the context (working_dir, allowed_commands, etc.)
+ * and returns tools with the context captured in closure.
+ */
+export function buildDevKit(ctx) {
+    return factories.flatMap(factory => factory(ctx));
+}

package/dist/devkit/tools/filesystem.js

@@ -0,0 +1,219 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import fs from 'fs-extra';
+import path from 'path';
+import { glob } from 'glob';
+import { truncateOutput, isWithinDir } from '../utils.js';
+import { registerToolFactory } from '../registry.js';
+function resolveSafe(ctx, filePath) {
+    // Always resolve relative to working_dir
+    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.working_dir, filePath);
+    return resolved;
+}
+function guardPath(ctx, resolved, destructive = false) {
+    // If allowed_commands is empty (Merovingian), no path restriction
+    if (!destructive)
+        return;
+    // For Apoc (non-empty allowed_commands) or explicit working_dir set, guard destructive ops
+    if (ctx.allowed_commands.length > 0 && !isWithinDir(resolved, ctx.working_dir)) {
+        throw new Error(`Path '${resolved}' is outside the working directory '${ctx.working_dir}'. Operation denied.`);
+    }
+}
+export function createFilesystemTools(ctx) {
+    return [
+        tool(async ({ file_path, encoding, start_line, end_line }) => {
+            const resolved = resolveSafe(ctx, file_path);
+            const content = await fs.readFile(resolved, encoding ?? 'utf8');
+            const lines = content.split('\n');
+            const sliced = (start_line || end_line)
+                ? lines.slice((start_line ?? 1) - 1, end_line).join('\n')
+                : content;
+            return truncateOutput(sliced);
+        }, {
+            name: 'read_file',
+            description: 'Read the contents of a file. Optionally specify line range.',
+            schema: z.object({
+                file_path: z.string().describe('Path to the file (absolute or relative to working_dir)'),
+                encoding: z.string().optional().describe('File encoding, default utf8'),
+                start_line: z.number().int().positive().optional().describe('Start line (1-based)'),
+                end_line: z.number().int().positive().optional().describe('End line (inclusive)'),
+            }),
+        }),
+        tool(async ({ file_path, content }) => {
+            const resolved = resolveSafe(ctx, file_path);
+            guardPath(ctx, resolved, true);
+            await fs.ensureDir(path.dirname(resolved));
+            await fs.writeFile(resolved, content, 'utf8');
+            return JSON.stringify({ success: true, path: resolved });
+        }, {
+            name: 'write_file',
+            description: 'Write content to a file, creating it and parent directories if needed.',
+            schema: z.object({
+                file_path: z.string(),
+                content: z.string().describe('Content to write'),
+            }),
+        }),
+        tool(async ({ file_path, content }) => {
+            const resolved = resolveSafe(ctx, file_path);
+            guardPath(ctx, resolved, true);
+            await fs.ensureDir(path.dirname(resolved));
+            await fs.appendFile(resolved, content, 'utf8');
+            return JSON.stringify({ success: true, path: resolved });
+        }, {
+            name: 'append_file',
+            description: 'Append content to a file without overwriting existing content.',
+            schema: z.object({
+                file_path: z.string(),
+                content: z.string(),
+            }),
+        }),
+        tool(async ({ file_path }) => {
+            const resolved = resolveSafe(ctx, file_path);
+            guardPath(ctx, resolved, true);
+            await fs.remove(resolved);
+            return JSON.stringify({ success: true, deleted: resolved });
+        }, {
+            name: 'delete_file',
+            description: 'Delete a file or directory.',
+            schema: z.object({ file_path: z.string() }),
+        }),
+        tool(async ({ source, destination }) => {
+            const src = resolveSafe(ctx, source);
+            const dest = resolveSafe(ctx, destination);
+            guardPath(ctx, dest, true);
+            await fs.ensureDir(path.dirname(dest));
+            await fs.move(src, dest, { overwrite: true });
+            return JSON.stringify({ success: true, from: src, to: dest });
+        }, {
+            name: 'move_file',
+            description: 'Move or rename a file or directory.',
+            schema: z.object({
+                source: z.string(),
+                destination: z.string(),
+            }),
+        }),
+        tool(async ({ source, destination }) => {
+            const src = resolveSafe(ctx, source);
+            const dest = resolveSafe(ctx, destination);
+            await fs.ensureDir(path.dirname(dest));
+            await fs.copy(src, dest);
+            return JSON.stringify({ success: true, from: src, to: dest });
+        }, {
+            name: 'copy_file',
+            description: 'Copy a file or directory to a new location.',
+            schema: z.object({
+                source: z.string(),
+                destination: z.string(),
+            }),
+        }),
+        tool(async ({ dir_path, recursive, pattern }) => {
+            const resolved = resolveSafe(ctx, dir_path ?? '.');
+            const entries = await fs.readdir(resolved, { withFileTypes: true });
+            let results = entries.map(e => ({
+                name: e.name,
+                type: e.isDirectory() ? 'dir' : 'file',
+                path: path.join(resolved, e.name),
+            }));
+            if (pattern) {
+                const re = new RegExp(pattern.replace('*', '.*').replace('?', '.'));
+                results = results.filter(r => re.test(r.name));
+            }
+            if (recursive) {
+                const subResults = [];
+                for (const entry of results.filter(r => r.type === 'dir')) {
+                    try {
+                        const subEntries = await fs.readdir(entry.path, { withFileTypes: true });
+                        subResults.push(...subEntries.map(e => ({
+                            name: e.name,
+                            type: e.isDirectory() ? 'dir' : 'file',
+                            path: path.join(entry.path, e.name),
+                        })));
+                    }
+                    catch { /* skip inaccessible */ }
+                }
+                results.push(...subResults);
+            }
+            return truncateOutput(JSON.stringify(results, null, 2));
+        }, {
+            name: 'list_dir',
+            description: 'List files and directories in a path.',
+            schema: z.object({
+                dir_path: z.string().optional().describe('Directory path, defaults to working_dir'),
+                recursive: z.boolean().optional().describe('Include subdirectory contents'),
+                pattern: z.string().optional().describe('Filter by name pattern (glob-like)'),
+            }),
+        }),
+        tool(async ({ dir_path }) => {
+            const resolved = resolveSafe(ctx, dir_path);
+            await fs.ensureDir(resolved);
+            return JSON.stringify({ success: true, path: resolved });
+        }, {
+            name: 'create_dir',
+            description: 'Create a directory and all parent directories.',
+            schema: z.object({ dir_path: z.string() }),
+        }),
+        tool(async ({ file_path }) => {
+            const resolved = resolveSafe(ctx, file_path);
+            const stat = await fs.stat(resolved);
+            return JSON.stringify({
+                path: resolved,
+                size: stat.size,
+                isDirectory: stat.isDirectory(),
+                isFile: stat.isFile(),
+                created: stat.birthtime.toISOString(),
+                modified: stat.mtime.toISOString(),
+                permissions: stat.mode.toString(8),
+            });
+        }, {
+            name: 'file_info',
+            description: 'Get metadata about a file or directory (size, dates, permissions).',
+            schema: z.object({ file_path: z.string() }),
+        }),
+        tool(async ({ pattern, search_path, regex, case_insensitive, max_results }) => {
+            const base = resolveSafe(ctx, search_path ?? '.');
+            const files = await glob('**/*', { cwd: base, nodir: true, absolute: true });
+            const re = new RegExp(pattern, case_insensitive ? 'i' : undefined);
+            const results = [];
+            for (const file of files) {
+                if (results.length >= (max_results ?? 100))
+                    break;
+                try {
+                    const content = await fs.readFile(file, 'utf8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (re.test(lines[i])) {
+                            results.push({ file: path.relative(base, file), line: i + 1, match: lines[i].trim() });
+                            if (results.length >= (max_results ?? 100))
+                                break;
+                        }
+                    }
+                }
+                catch { /* skip binary/unreadable files */ }
+            }
+            return truncateOutput(JSON.stringify(results, null, 2));
+        }, {
+            name: 'search_in_files',
+            description: 'Search for a pattern (regex) inside file contents.',
+            schema: z.object({
+                pattern: z.string().describe('Regex pattern to search for'),
+                search_path: z.string().optional().describe('Directory to search in, defaults to working_dir'),
+                regex: z.boolean().optional().describe('Treat pattern as regex (default true)'),
+                case_insensitive: z.boolean().optional(),
+                max_results: z.number().int().positive().optional().describe('Max matches to return (default 100)'),
+            }),
+        }),
+        tool(async ({ pattern, search_path }) => {
+            const base = resolveSafe(ctx, search_path ?? '.');
+            const files = await glob(pattern, { cwd: base, absolute: true });
+            return truncateOutput(JSON.stringify(files.map(f => path.relative(base, f)), null, 2));
+        }, {
+            name: 'find_files',
+            description: 'Find files matching a glob pattern.',
+            schema: z.object({
+                pattern: z.string().describe('Glob pattern e.g. "**/*.ts", "src/**/*.json"'),
+                search_path: z.string().optional().describe('Base directory, defaults to working_dir'),
+            }),
+        }),
+    ];
+}
+registerToolFactory(createFilesystemTools);