synapsexcoder 6.0.0

package/dist/commands/command-processor.js

@@ -0,0 +1,796 @@
+/**
+ * Command Processor - Workflow Commands System
+ */
+import { join } from "path";
+export class CommandProcessor {
+    masterAgent;
+    commands = new Map();
+    constructor(masterAgent) {
+        this.masterAgent = masterAgent;
+        this.registerDefaultCommands();
+    }
+    registerCommand(command) {
+        this.commands.set(command.name, command);
+    }
+    registerDefaultCommands() {
+        this.registerCommand({
+            name: "add-context",
+            description: "Add context pattern",
+            usage: "/add-context <type> <name> <description>",
+            handler: this.handleAddContext.bind(this),
+        });
+        this.registerCommand({
+            name: "list-context",
+            description: "List context patterns",
+            usage: "/list-context [type]",
+            handler: this.handleListContext.bind(this),
+        });
+        this.registerCommand({
+            name: "add-thought",
+            description: "Add a thought",
+            usage: "/add-thought <type> <title> <content>",
+            handler: this.handleAddThought.bind(this),
+        });
+        this.registerCommand({
+            name: "list-thoughts",
+            description: "List thoughts",
+            usage: "/list-thoughts [type]",
+            handler: this.handleListThoughts.bind(this),
+        });
+        this.registerCommand({
+            name: "list-agents",
+            description: "List agents",
+            usage: "/list-agents [type]",
+            handler: this.handleListAgents.bind(this),
+        });
+        this.registerCommand({
+            name: "create-agent",
+            description: "Create agent from markdown",
+            usage: "/create-agent <definition-id>",
+            handler: this.handleCreateAgent.bind(this),
+        });
+        this.registerCommand({
+            name: "status",
+            description: "Show system status",
+            usage: "/status",
+            handler: this.handleStatus.bind(this),
+        });
+        this.registerCommand({
+            name: "commit",
+            description: "Commit knowledge/context changes",
+            usage: "/commit [message]",
+            handler: this.handleCommit.bind(this),
+        });
+        this.registerCommand({
+            name: "help",
+            description: "Show available commands",
+            usage: "/help [command]",
+            handler: this.handleHelp.bind(this),
+        });
+        this.registerCommand({
+            name: "create-session",
+            description: "Create a team session",
+            usage: "/create-session <name> <description>",
+            handler: this.handleCreateSession.bind(this),
+        });
+        this.registerCommand({
+            name: "join-session",
+            description: "Join a team session",
+            usage: "/join-session <session-id>",
+            handler: this.handleJoinSession.bind(this),
+        });
+        this.registerCommand({
+            name: "list-sessions",
+            description: "List team sessions",
+            usage: "/list-sessions",
+            handler: this.handleListSessions.bind(this),
+        });
+        this.registerCommand({
+            name: "create-repo",
+            description: "Create a shared repository",
+            usage: "/create-repo <name> <type> <description>",
+            handler: this.handleCreateRepository.bind(this),
+        });
+        this.registerCommand({
+            name: "share-item",
+            description: "Share an item to a repo",
+            usage: "/share-item <repo-id> <item-id>",
+            handler: this.handleShareItem.bind(this),
+        });
+        this.registerCommand({
+            name: "team-activity",
+            description: "Show team activity feed",
+            usage: "/team-activity [session-id]",
+            handler: this.handleTeamActivity.bind(this),
+        });
+        this.registerCommand({
+            name: "list-plugins",
+            description: "List installed plugins",
+            usage: "/list-plugins",
+            handler: this.handleListPlugins.bind(this),
+        });
+        this.registerCommand({
+            name: "enable-plugin",
+            description: "Enable plugin",
+            usage: "/enable-plugin <plugin-id>",
+            handler: this.handleEnablePlugin.bind(this),
+        });
+        this.registerCommand({
+            name: "disable-plugin",
+            description: "Disable plugin",
+            usage: "/disable-plugin <plugin-id>",
+            handler: this.handleDisablePlugin.bind(this),
+        });
+        this.registerCommand({
+            name: "create-plugin",
+            description: "Create plugin scaffold",
+            usage: "/create-plugin <type> <name>",
+            handler: this.handleCreatePlugin.bind(this),
+        });
+        this.registerCommand({
+            name: "token-stats",
+            description: "Show token stats",
+            usage: "/token-stats",
+            handler: this.handleTokenStats.bind(this),
+        });
+        this.registerCommand({
+            name: "optimize-context",
+            description: "Optimize context content",
+            usage: "/optimize-context <content>",
+            handler: this.handleOptimizeContext.bind(this),
+        });
+        // Verification commands (Synapse v4)
+        this.registerCommand({
+            name: "verify",
+            description: "Run repository verification",
+            usage: "/verify [options]",
+            handler: this.handleVerify.bind(this),
+        });
+        this.registerCommand({
+            name: "verify-file",
+            description: "Verify a specific file",
+            usage: "/verify-file <path>",
+            handler: this.handleVerifyFile.bind(this),
+        });
+        this.registerCommand({
+            name: "verify-claims",
+            description: "Verify specific claims",
+            usage: "/verify-claim <claim-id>",
+            handler: this.handleVerifyClaim.bind(this),
+        });
+        this.registerCommand({
+            name: "audit",
+            description: "Run recursive audit",
+            usage: "/audit [depth]",
+            handler: this.handleAudit.bind(this),
+        });
+        // Phase 0 loop command stubs
+        this.registerCommand({
+            name: "SynapeXHelix",
+            description: "Continuous helical refinement loop (plan→execute→verify→re-plan)",
+            usage: "/SynapeXHelix <goal>",
+            handler: this.handleSynapeXHelix.bind(this),
+        });
+        this.registerCommand({
+            name: "SynapseXRalpLoop",
+            description: "Recursive Audit-Learn-Plan loop",
+            usage: "/SynapseXRalpLoop <scope>",
+            handler: this.handleSynapseXRalpLoop.bind(this),
+        });
+        // Knowledge vault slash aliases
+        this.registerCommand({
+            name: "vault",
+            description: "Knowledge vault search",
+            usage: "/vault search <query>",
+            handler: this.handleVaultSearch.bind(this),
+        });
+        // Phase 2 native plugin commands
+        this.registerCommand({
+            name: "env",
+            description: "Runtime environment manager",
+            usage: "/env create|list|destroy <args>",
+            handler: this.handleEnv.bind(this),
+        });
+        this.registerCommand({
+            name: "cited-search",
+            description: "Web search with vault citation storage",
+            usage: "/cited-search <query>",
+            handler: this.handleCitedSearch.bind(this),
+        });
+        this.registerCommand({
+            name: "worktree",
+            description: "Git worktree management",
+            usage: "/worktree list|create|remove <args>",
+            handler: this.handleWorktree.bind(this),
+        });
+        this.registerCommand({
+            name: "observability",
+            description: "Session observability export",
+            usage: "/observability export <session-id>",
+            handler: this.handleObservability.bind(this),
+        });
+        this.registerCommand({
+            name: "migrate",
+            description: "Migrate OpenCode config to SynapseXcoder",
+            usage: "/migrate [config-path]",
+            handler: this.handleMigrate.bind(this),
+        });
+    }
+    async processCommand(input) {
+        const trimmed = input.trim();
+        if (!trimmed.startsWith("/"))
+            return { success: false, output: "Commands must start with /" };
+        const [commandName, ...args] = trimmed.slice(1).split(/\s+/);
+        const command = this.commands.get(commandName.toLowerCase());
+        if (!command)
+            return { success: false, output: `Unknown command: ${commandName}` };
+        return command.handler(args, this.masterAgent);
+    }
+    async handleAddContext(args, masterAgent) {
+        if (args.length < 3)
+            return {
+                success: false,
+                output: "Usage: /add-context <type> <name> <description>",
+            };
+        const [type, name, ...descParts] = args;
+        const patternId = masterAgent.getContextSystem().addPattern({
+            type: type,
+            name,
+            description: descParts.join(" "),
+            examples: [],
+            tags: ["manual"],
+        });
+        return {
+            success: true,
+            output: `Context pattern added: ${patternId}`,
+            data: { patternId },
+        };
+    }
+    async handleListContext(args, masterAgent) {
+        const patterns = args[0]
+            ? masterAgent
+                .getContextSystem()
+                .findRelevantPatterns({ type: args[0] })
+            : masterAgent.getContextSystem().getProjectContext().patterns;
+        if (patterns.length === 0)
+            return { success: true, output: "No context patterns found." };
+        const output = patterns
+            .slice(0, 10)
+            .map((p) => `• ${p.name} (${p.type})\n  ${p.description}`)
+            .join("\n\n");
+        return { success: true, output };
+    }
+    async handleAddThought(args, masterAgent) {
+        if (args.length < 3)
+            return {
+                success: false,
+                output: "Usage: /add-thought <type> <title> <content>",
+            };
+        const [type, title, ...contentParts] = args;
+        const thoughtId = masterAgent.getThoughtsManager().createThought({
+            title,
+            type: type,
+            content: contentParts.join(" "),
+            tags: ["manual"],
+        });
+        return {
+            success: true,
+            output: `Thought added: ${thoughtId}`,
+            data: { thoughtId },
+        };
+    }
+    async handleListThoughts(args, masterAgent) {
+        const thoughts = args[0]
+            ? masterAgent.getThoughtsManager().getThoughtsByType(args[0])
+            : masterAgent.getThoughtsManager().getRecentThoughts(10);
+        if (thoughts.length === 0)
+            return { success: true, output: "No thoughts found." };
+        return {
+            success: true,
+            output: thoughts
+                .map((t) => `• ${t.title} (${t.type})\n  ${t.content.slice(0, 100)}`)
+                .join("\n\n"),
+        };
+    }
+    async handleListAgents(args, masterAgent) {
+        const agents = args[0]
+            ? masterAgent
+                .getAgentConfigManager()
+                .getAgentDefinitionsByType(args[0])
+            : masterAgent.getAgentConfigManager().getAllAgentDefinitions();
+        if (agents.length === 0)
+            return { success: true, output: "No agent definitions found." };
+        return {
+            success: true,
+            output: agents
+                .map((a) => `• ${a.name} (${a.type})\n  ${a.description}`)
+                .join("\n\n"),
+        };
+    }
+    async handleCreateAgent(args, masterAgent) {
+        if (args.length < 1)
+            return { success: false, output: "Usage: /create-agent <definition-id>" };
+        const agent = masterAgent
+            .getAgentConfigManager()
+            .createAgentFromDefinition(args[0], null, null);
+        return {
+            success: true,
+            output: `Agent created from definition: ${args[0]}`,
+            data: { agentId: agent.id, agentType: agent.type },
+        };
+    }
+    async handleStatus(_args, masterAgent) {
+        const status = masterAgent.getStatus();
+        const thoughtsStats = masterAgent.getThoughtsManager().getStats();
+        return {
+            success: true,
+            output: `Master: ${status.status}\nActive Sub-agents: ${masterAgent.getActiveSubAgents().size}\nKnowledge Base: ${thoughtsStats.total} thoughts`,
+        };
+    }
+    async handleCommit(args, masterAgent) {
+        const message = args.join(" ") || "Knowledge and context updates";
+        masterAgent.getContextSystem().updateProjectInfo({});
+        return { success: true, output: `Committed changes: ${message}` };
+    }
+    async handleHelp(args, _masterAgent) {
+        if (args.length > 0) {
+            const command = this.commands.get(args[0]);
+            return command
+                ? {
+                    success: true,
+                    output: `${command.name}: ${command.description}\nUsage: ${command.usage}`,
+                }
+                : { success: false, output: `Unknown command: ${args[0]}` };
+        }
+        return {
+            success: true,
+            output: Array.from(this.commands.values())
+                .map((c) => `/${c.name}: ${c.description}`)
+                .join("\n"),
+        };
+    }
+    async handleCreateSession(args, masterAgent) {
+        if (args.length < 2)
+            return {
+                success: false,
+                output: "Usage: /create-session <name> <description>",
+            };
+        const [name, ...descParts] = args;
+        const sessionId = masterAgent.getTeamSystem().createSession({
+            name,
+            description: descParts.join(" "),
+            ownerId: "default-user",
+            members: ["default-user"],
+            status: "active",
+            settings: {
+                allowGuestAccess: false,
+                requireApproval: true,
+                maxMembers: 10,
+            },
+        });
+        return {
+            success: true,
+            output: `Team session created: ${sessionId}`,
+            data: { sessionId },
+        };
+    }
+    async handleJoinSession(args, masterAgent) {
+        if (args.length < 1)
+            return { success: false, output: "Usage: /join-session <session-id>" };
+        return masterAgent.getTeamSystem().joinSession(args[0], "default-user")
+            ? { success: true, output: `Joined session: ${args[0]}` }
+            : { success: false, output: `Failed to join session: ${args[0]}` };
+    }
+    async handleListSessions(_args, masterAgent) {
+        const sessions = masterAgent.getTeamSystem().listActiveSessions();
+        if (sessions.length === 0)
+            return { success: true, output: "No active team sessions found." };
+        return {
+            success: true,
+            output: sessions
+                .map((s) => `• ${s.name} (${s.id})\n  ${s.description}`)
+                .join("\n\n"),
+        };
+    }
+    async handleCreateRepository(args, masterAgent) {
+        if (args.length < 3)
+            return {
+                success: false,
+                output: "Usage: /create-repo <name> <type> <description>",
+            };
+        const [name, type, ...descParts] = args;
+        const repoId = masterAgent.getTeamSystem().createRepository({
+            name,
+            description: descParts.join(" "),
+            ownerId: "default-user",
+            type: type,
+            visibility: "team",
+            items: [],
+            collaborators: [
+                { userId: "default-user", role: "owner", joinedAt: Date.now() },
+            ],
+        });
+        return {
+            success: true,
+            output: `Repository created: ${repoId}`,
+            data: { repoId },
+        };
+    }
+    async handleShareItem(args, masterAgent) {
+        if (args.length < 2)
+            return {
+                success: false,
+                output: "Usage: /share-item <repo-id> <item-id>",
+            };
+        return masterAgent
+            .getTeamSystem()
+            .addToRepository(args[0], args[1], "default-user")
+            ? {
+                success: true,
+                output: `Shared item ${args[1]} to repository ${args[0]}`,
+            }
+            : { success: false, output: "Failed to share item" };
+    }
+    async handleTeamActivity(args, masterAgent) {
+        const activities = masterAgent
+            .getTeamSystem()
+            .getActivities(args[0] || undefined, 10);
+        if (activities.length === 0)
+            return { success: true, output: "No recent team activities found." };
+        return {
+            success: true,
+            output: activities.map((a) => `• ${a.description}`).join("\n"),
+        };
+    }
+    async handleListPlugins(_args, masterAgent) {
+        const plugins = masterAgent.getPluginManager().listPlugins();
+        if (plugins.length === 0)
+            return { success: true, output: "No plugins installed." };
+        return {
+            success: true,
+            output: plugins
+                .map((p) => `• ${p.manifest.name} v${p.manifest.version} - ${p.enabled ? "enabled" : "disabled"}`)
+                .join("\n"),
+        };
+    }
+    async handleEnablePlugin(args, masterAgent) {
+        if (args.length < 1)
+            return { success: false, output: "Usage: /enable-plugin <plugin-id>" };
+        return masterAgent.getPluginManager().enablePlugin(args[0])
+            ? { success: true, output: `Plugin ${args[0]} enabled` }
+            : { success: false, output: `Plugin ${args[0]} not found` };
+    }
+    async handleDisablePlugin(args, masterAgent) {
+        if (args.length < 1)
+            return { success: false, output: "Usage: /disable-plugin <plugin-id>" };
+        return masterAgent.getPluginManager().disablePlugin(args[0])
+            ? { success: true, output: `Plugin ${args[0]} disabled` }
+            : { success: false, output: `Plugin ${args[0]} not found` };
+    }
+    async handleCreatePlugin(args, masterAgent) {
+        if (args.length < 2)
+            return { success: false, output: "Usage: /create-plugin <type> <name>" };
+        const [type] = args;
+        const scaffold = masterAgent
+            .getPluginManager()
+            .createPluginTemplate(type);
+        return {
+            success: true,
+            output: scaffold,
+        };
+    }
+    async handleTokenStats(_args, masterAgent) {
+        const stats = masterAgent.getTokenOptimizer().getCacheStats();
+        const efficiency = masterAgent.getTokenOptimizer().analyzeEfficiency();
+        return {
+            success: true,
+            output: `Compressed Contexts: ${stats.compressedContexts}\nTokens Saved: ${stats.totalTokensSaved}\nCompression Ratio: ${efficiency.averageCompressionRatio.toFixed(2)}x`,
+        };
+    }
+    async handleOptimizeContext(args, masterAgent) {
+        if (args.length < 1)
+            return { success: false, output: "Usage: /optimize-context <content>" };
+        const compressed = await masterAgent
+            .getTokenOptimizer()
+            .compressContext(args.join(" "));
+        return {
+            success: true,
+            output: `Original: ${compressed.originalSize} tokens\nCompressed: ${compressed.compressedSize} tokens\nRatio: ${compressed.compressionRatio.toFixed(2)}x\n\n${compressed.summary}`,
+            data: { compressed },
+        };
+    }
+    // Verification command handlers (Synapse v4)
+    async handleVerify(args, _masterAgent) {
+        try {
+            const { createVerificationAgent } = await import("../agents/verification-agent.js");
+            const { MessageBus } = await import("../messages/message-bus.js");
+            const { OpenCodeToolBridge } = await import("../synapsexcoder/tool-bridge.js");
+            const options = {};
+            for (let i = 0; i < args.length; i += 2) {
+                if (args[i]?.startsWith("--")) {
+                    options[args[i].slice(2)] = args[i + 1] || "";
+                }
+            }
+            const config = {
+                repositoryRoot: options.root || process.cwd(),
+                recursiveDepth: parseInt(options.depth || "3", 10),
+                autoFix: options.fix === "true",
+                claimParser: { enabled: true, sources: ["src", "docs"] },
+                runtimeVerifier: { enabled: true, checkImports: true, checkExports: true, checkAsyncFlows: true },
+                integrationVerifier: { enabled: true, checkApiChains: true, checkStatePropagation: true, checkEventWiring: true },
+                crossReference: { enabled: true, checkDocsVsCode: true, checkTestsVsBehavior: true, checkConfigsVsDeploy: true },
+                recursiveAudit: { enabled: true, maxDepth: parseInt(options.depth || "3", 10), failFast: false },
+            };
+            const agent = createVerificationAgent(config, new MessageBus(), new OpenCodeToolBridge());
+            const report = await agent.execute({ type: "verify_repository" });
+            return {
+                success: report.status === "pass",
+                output: `Status: ${report.status.toUpperCase()}\nClaims Parsed: ${report.claimsParsed}\nClaims Verified: ${report.claimsVerified}\nDiscrepancies Found: ${report.discrepanciesFound}\nDiscrepancies Resolved: ${report.discrepanciesResolved}\nRecursive Passes: ${report.recursivePasses}`,
+                data: { report },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleVerifyFile(args, _masterAgent) {
+        try {
+            const { createVerificationAgent } = await import("../agents/verification-agent.js");
+            const { MessageBus } = await import("../messages/message-bus.js");
+            const { OpenCodeToolBridge } = await import("../synapsexcoder/tool-bridge.js");
+            if (args.length < 1)
+                return { success: false, output: "Usage: /verify-file <path>" };
+            const filePath = args[0];
+            const config = {
+                repositoryRoot: process.cwd(),
+                recursiveDepth: 1,
+                autoFix: false,
+                claimParser: { enabled: true, sources: [] },
+                runtimeVerifier: { enabled: true, checkImports: true, checkExports: true, checkAsyncFlows: false },
+                integrationVerifier: { enabled: false, checkApiChains: false, checkStatePropagation: false, checkEventWiring: false },
+                crossReference: { enabled: true, checkDocsVsCode: true, checkTestsVsBehavior: false, checkConfigsVsDeploy: false },
+                recursiveAudit: { enabled: false, maxDepth: 1, failFast: false },
+            };
+            const agent = createVerificationAgent(config, new MessageBus(), new OpenCodeToolBridge());
+            await agent.verifyFile(filePath);
+            return {
+                success: true,
+                output: `File verified: ${filePath}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleVerifyClaim(args, _masterAgent) {
+        try {
+            if (args.length < 1)
+                return { success: false, output: "Usage: /verify-claim <claim-id>" };
+            const claimId = args[0];
+            return {
+                success: true,
+                output: `Verifying claim: ${claimId}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleAudit(args, _masterAgent) {
+        try {
+            const { createVerificationAgent } = await import("../agents/verification-agent.js");
+            const { MessageBus } = await import("../messages/message-bus.js");
+            const { OpenCodeToolBridge } = await import("../synapsexcoder/tool-bridge.js");
+            const depth = parseInt(args[0] || "5", 10);
+            const config = {
+                repositoryRoot: process.cwd(),
+                recursiveDepth: depth,
+                autoFix: false,
+                claimParser: { enabled: true, sources: ["src", "docs"] },
+                runtimeVerifier: { enabled: true, checkImports: true, checkExports: true, checkAsyncFlows: true },
+                integrationVerifier: { enabled: true, checkApiChains: true, checkStatePropagation: true, checkEventWiring: true },
+                crossReference: { enabled: true, checkDocsVsCode: true, checkTestsVsBehavior: true, checkConfigsVsDeploy: true },
+                recursiveAudit: { enabled: true, maxDepth: depth, failFast: false },
+            };
+            const agent = createVerificationAgent(config, new MessageBus(), new OpenCodeToolBridge());
+            await agent.execute({ type: "recursive_audit" });
+            const report = agent.getReport();
+            const stats = agent.getStats();
+            return {
+                success: true,
+                output: `Audit Complete\nPasses: ${report?.recursivePasses || 0}\nDiscrepancies Found: ${stats.total}\nDiscrepancies Resolved: ${stats.resolved}`,
+                data: { stats },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `Audit failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleSynapeXHelix(args, masterAgent) {
+        const goal = args.join(" ") || "(no goal specified)";
+        try {
+            const { runHelixLoop } = await import("../synapsexcoder/execution-loops/helix-loop.js");
+            const result = await runHelixLoop(goal, masterAgent, { maxIterations: 3 });
+            const lines = result.iterations.map((it) => `  [${it.iteration}] ${it.phase}: ${it.output.slice(0, 120)}...`);
+            return {
+                success: true,
+                output: `SynapeXHelix complete — converged: ${result.converged}, ` +
+                    `iterations: ${result.totalIterations}, session: ${result.sessionId}\n` +
+                    lines.join("\n"),
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `SynapeXHelix failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleSynapseXRalpLoop(args, masterAgent) {
+        const scope = args.join(" ") || process.cwd();
+        try {
+            const { runRalpLoop } = await import("../synapsexcoder/execution-loops/ralp-loop.js");
+            const result = await runRalpLoop(scope, masterAgent, { maxDepth: 2 });
+            const lines = result.iterations.map((it) => `  [${it.iteration}] ${it.phase}: ${it.findings.join("; ")}`);
+            return {
+                success: true,
+                output: `SynapseXRalpLoop complete — ${result.totalFindings} finding(s), ` +
+                    `session: ${result.sessionId}\n` +
+                    lines.join("\n"),
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `SynapseXRalpLoop failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleVaultSearch(args, _masterAgent) {
+        if (args[0]?.toLowerCase() !== "search" || !args[1]) {
+            return {
+                success: false,
+                output: "Usage: /vault search <query>",
+            };
+        }
+        try {
+            const { KnowledgeVault } = await import("../knowledge-vault/index.js");
+            const vault = new KnowledgeVault();
+            vault.rebuildManifest();
+            const query = args.slice(1).join(" ");
+            const results = vault.search(query, 10);
+            if (results.length === 0) {
+                return { success: true, output: `No vault matches for: ${query}` };
+            }
+            const lines = results.map((r) => `[${r.score}] ${r.entry.title}${r.entry.sourceUrl ? ` — ${r.entry.sourceUrl}` : ""}`);
+            return {
+                success: true,
+                output: `Vault search (${results.length}):\n${lines.join("\n")}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: `Vault search failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async handleEnv(args, _masterAgent) {
+        const { getRuntimeEnvironmentManager } = await import("../synapsexcoder/runtime-environment.js");
+        const mgr = getRuntimeEnvironmentManager();
+        const sub = args[0]?.toLowerCase();
+        if (sub === "create") {
+            const name = args[1] || `env-${Date.now()}`;
+            const template = args[2] || "blank";
+            const env = mgr.create({ name, template });
+            return { success: true, output: `Created environment ${env.id} (${env.name}) at ${env.path}`, data: env };
+        }
+        if (sub === "list") {
+            const envs = mgr.list();
+            if (envs.length === 0)
+                return { success: true, output: "No active environments." };
+            const lines = envs.map((e) => `  ${e.id} — ${e.name} (${e.path})`);
+            return { success: true, output: `Environments:\n${lines.join("\n")}` };
+        }
+        if (sub === "destroy") {
+            const id = args[1];
+            if (!id)
+                return { success: false, output: "Usage: /env destroy <id>" };
+            const ok = mgr.destroy(id);
+            return { success: ok, output: ok ? `Destroyed environment ${id}` : `Environment not found: ${id}` };
+        }
+        return { success: false, output: "Usage: /env create|list|destroy <args>" };
+    }
+    async handleCitedSearch(args, _masterAgent) {
+        const query = args.join(" ");
+        if (!query)
+            return { success: false, output: "Usage: /cited-search <query>" };
+        try {
+            const { getCitedSearchEngine } = await import("../synapsexcoder/cited-search.js");
+            const engine = getCitedSearchEngine();
+            const result = await engine.search(query, 3);
+            const citations = engine.formatCitations(result.results);
+            return {
+                success: true,
+                output: `Cited search: ${result.results.length} result(s), ${result.storedInVault} stored in vault\n${citations}`,
+                data: result,
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Cited search failed: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    async handleWorktree(args, _masterAgent) {
+        const { getWorktreeManager } = await import("../synapsexcoder/worktree-manager.js");
+        const mgr = getWorktreeManager();
+        const sub = args[0]?.toLowerCase();
+        if (sub === "list") {
+            const trees = mgr.list();
+            if (trees.length === 0)
+                return { success: true, output: "No worktrees (or not a git repo)." };
+            const lines = trees.map((w) => `  ${w.branch ?? "detached"} — ${w.path}`);
+            return { success: true, output: `Worktrees:\n${lines.join("\n")}` };
+        }
+        if (sub === "create") {
+            const branch = args[1];
+            if (!branch)
+                return { success: false, output: "Usage: /worktree create <branch> [path]" };
+            try {
+                const wt = mgr.create({ branch, path: args[2] });
+                return { success: true, output: `Created worktree ${wt.branch} at ${wt.path}`, data: wt };
+            }
+            catch (error) {
+                return { success: false, output: `Worktree create failed: ${error instanceof Error ? error.message : String(error)}` };
+            }
+        }
+        if (sub === "remove") {
+            const path = args[1];
+            if (!path)
+                return { success: false, output: "Usage: /worktree remove <path>" };
+            const ok = mgr.remove(path, args[2] === "--force");
+            return { success: ok, output: ok ? `Removed worktree ${path}` : `Failed to remove ${path}` };
+        }
+        return { success: false, output: "Usage: /worktree list|create|remove <args>" };
+    }
+    async handleObservability(args, _masterAgent) {
+        const { getSessionObservability } = await import("../synapsexcoder/session-observability.js");
+        const obs = getSessionObservability();
+        if (args[0]?.toLowerCase() === "export" && args[1]) {
+            const path = obs.exportSession(args[1]);
+            return { success: true, output: `Exported session ${args[1]} to ${path}` };
+        }
+        const sessionId = obs.startSession();
+        return { success: true, output: `Started observability session: ${sessionId}` };
+    }
+    async handleMigrate(args, _masterAgent) {
+        const { migrateOpenCodeConfig } = await import("../synapsexcoder/migration/opencode-config-migrator.js");
+        const source = args[0] || join(process.cwd(), ".opencode", "opencode.jsonc");
+        const result = migrateOpenCodeConfig(source);
+        const lines = [...result.changes, ...result.warnings.map((w) => `WARN: ${w}`)];
+        return {
+            success: result.success,
+            output: result.success
+                ? `Migration complete:\n${lines.join("\n")}`
+                : `Migration failed:\n${lines.join("\n")}`,
+            data: result,
+        };
+    }
+}
+export function createCommandProcessor(masterAgent) {
+    return new CommandProcessor(masterAgent);
+}
+//# sourceMappingURL=command-processor.js.map