@gonzih/cc-agent 0.15.23 → 0.15.25

package/dist/index.js

@@ -20,13 +20,14 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { JobManager, normalizeRepoUrl } from "./agent.js";
+import { JobManager, repoKey, normalizeRepoUrl } from "./agent.js";
 import { listDrivers, getDriverStatus } from "./drivers/index.js";
 import { runSwarm, getSwarmStatus, SWARM_MAX_AGENTS_HARD_CAP } from "./swarm.js";
+import { runWorkflow, getWorkflowStatus, WORKFLOW_MAX_STAGES_HARD_CAP } from "./workflow.js";
 import { MetaAgentManager } from "./meta-agent.js";
 import { buildEvaluatorTask } from "./evaluator.js";
 import { loadProfiles, upsertProfile, deleteProfile, getProfile, interpolate } from "./profiles.js";
-import { planStore, jobStore, learningsStore, profileStore } from "./store.js";
+import { planStore, jobStore, learningsStore, profileStore, wikiStore } from "./store.js";
 import { seedBuiltinProfiles } from "./seeds.js";
 import { getNamespace } from "./namespace.js";
 import { initRedis, getRedis } from "./redis.js";
@@ -535,6 +536,92 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 },
             },
         },
+        {
+            name: "get_wiki",
+            description: "Return all wiki pages for a repo. Wiki pages are structured knowledge injected automatically into every spawn_agent call for the repo. Use this to inspect what knowledge is stored.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    repo_url: {
+                        type: "string",
+                        description: "Repository URL, e.g. 'https://github.com/gonzih/cc-agent'",
+                    },
+                },
+                required: ["repo_url"],
+            },
+        },
+        {
+            name: "get_wiki_page",
+            description: "Return a single wiki page by name for a repo.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    repo_url: {
+                        type: "string",
+                        description: "Repository URL",
+                    },
+                    page: {
+                        type: "string",
+                        description: "Page name to retrieve",
+                    },
+                },
+                required: ["repo_url", "page"],
+            },
+        },
+        {
+            name: "update_wiki_page",
+            description: "Create or update a wiki page for a repo. Content is markdown. Pages are auto-injected into spawn_agent calls for this repo.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    repo_url: {
+                        type: "string",
+                        description: "Repository URL",
+                    },
+                    page: {
+                        type: "string",
+                        description: "Page name (human-readable, e.g. 'Architecture', 'Gotchas')",
+                    },
+                    content: {
+                        type: "string",
+                        description: "Markdown content for the page",
+                    },
+                },
+                required: ["repo_url", "page", "content"],
+            },
+        },
+        {
+            name: "delete_wiki_page",
+            description: "Delete a single wiki page for a repo.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    repo_url: {
+                        type: "string",
+                        description: "Repository URL",
+                    },
+                    page: {
+                        type: "string",
+                        description: "Page name to delete",
+                    },
+                },
+                required: ["repo_url", "page"],
+            },
+        },
+        {
+            name: "list_wiki_pages",
+            description: "List all wiki page names for a repo.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    repo_url: {
+                        type: "string",
+                        description: "Repository URL",
+                    },
+                },
+                required: ["repo_url"],
+            },
+        },
         {
             name: "docker_ps",
             description: "List currently running cc-agent Docker containers. Shows container name, status, and uptime.",
@@ -778,6 +865,55 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["swarm_id"],
             },
         },
+        {
+            name: "generate_workflow",
+            description: "Auto-decompose a high-level goal into an ordered sequence of stages, then spawn all jobs with stage-based dependency enforcement. Returns immediately with workflow_id, job_ids, and the stage breakdown. Use get_workflow_status to poll progress. Each stage only starts after ALL jobs in the prior stage complete — guaranteeing ordered execution even across 100s of agents.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    goal: {
+                        type: "string",
+                        description: "High-level natural language goal to decompose into workflow stages (e.g. 'build, test, and deploy X')",
+                    },
+                    repo_url: {
+                        type: "string",
+                        description: "Git repository URL for all spawned agents (https://github.com/owner/repo)",
+                    },
+                    max_stages: {
+                        type: "number",
+                        description: `Maximum number of sequential stages (default 8, hard cap ${WORKFLOW_MAX_STAGES_HARD_CAP})`,
+                    },
+                    max_agents_per_stage: {
+                        type: "number",
+                        description: "Maximum number of parallel agents per stage (default 3)",
+                    },
+                    max_budget_per_agent: {
+                        type: "number",
+                        description: "Maximum USD budget per spawned agent (default 5)",
+                    },
+                    agent_model: {
+                        type: "string",
+                        description: "Model override for spawned agents (optional)",
+                    },
+                    agent_driver: {
+                        type: "string",
+                        description: "Driver override for spawned agents (optional, e.g. 'claude', 'aider')",
+                    },
+                },
+                required: ["goal", "repo_url"],
+            },
+        },
+        {
+            name: "get_workflow_status",
+            description: "Poll the status of a workflow created by generate_workflow. Returns goal, stage breakdown, per-step job IDs and statuses.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    workflow_id: { type: "string", description: "Workflow ID returned by generate_workflow" },
+                },
+                required: ["workflow_id"],
+            },
+        },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
@@ -1397,6 +1533,70 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                     }],
             };
         }
+        case "get_wiki": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const slug = repoKey(repoUrl);
+            logger.info("[mcp] get_wiki", { slug });
+            const pages = await wikiStore.getAllPages(slug);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ repo: slug, pages, total: pages.length }),
+                    }],
+            };
+        }
+        case "get_wiki_page": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const slug = repoKey(repoUrl);
+            const page = a.page;
+            logger.info("[mcp] get_wiki_page", { slug, page });
+            const content = await wikiStore.getPage(slug, page);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ repo: slug, page, content, found: content !== null }),
+                    }],
+            };
+        }
+        case "update_wiki_page": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const slug = repoKey(repoUrl);
+            const page = a.page;
+            const content = a.content;
+            logger.info("[mcp] update_wiki_page", { slug, page, length: content.length });
+            await wikiStore.savePage(slug, page, content);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ ok: true, repo: slug, page }),
+                    }],
+            };
+        }
+        case "delete_wiki_page": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const slug = repoKey(repoUrl);
+            const page = a.page;
+            logger.info("[mcp] delete_wiki_page", { slug, page });
+            const deleted = await wikiStore.deletePage(slug, page);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ ok: deleted, repo: slug, page }),
+                    }],
+            };
+        }
+        case "list_wiki_pages": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const slug = repoKey(repoUrl);
+            logger.info("[mcp] list_wiki_pages", { slug });
+            const pages = await wikiStore.listPages(slug);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ repo: slug, pages, total: pages.length }),
+                    }],
+            };
+        }
         case "docker_ps": {
             logger.info("[mcp] docker_ps");
             const containers = await listCcAgentContainers();
@@ -1852,6 +2052,108 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                     }],
             };
         }
+        case "generate_workflow": {
+            const repoUrl = normalizeRepoUrl(a.repo_url);
+            const goal = a.goal;
+            const maxStages = typeof a.max_stages === "number" ? a.max_stages : 8;
+            const maxAgentsPerStage = typeof a.max_agents_per_stage === "number" ? a.max_agents_per_stage : 3;
+            if (maxStages > WORKFLOW_MAX_STAGES_HARD_CAP) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ error: `max_stages ${maxStages} exceeds hard cap of ${WORKFLOW_MAX_STAGES_HARD_CAP}` }),
+                        }],
+                };
+            }
+            logger.info("[mcp] generate_workflow", {
+                repo_url: repoUrl,
+                goal: goal.slice(0, 80),
+                max_stages: maxStages,
+                max_agents_per_stage: maxAgentsPerStage,
+            });
+            try {
+                const result = await runWorkflow({
+                    repoUrl,
+                    goal,
+                    maxStages,
+                    maxAgentsPerStage,
+                    maxBudgetPerAgent: typeof a.max_budget_per_agent === "number" ? a.max_budget_per_agent : 5,
+                    agentModel: a.agent_model,
+                    agentDriver: a.agent_driver,
+                    manager,
+                    redis: getRedis(),
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                workflow_id: result.workflow_id,
+                                total_stages: result.total_stages,
+                                total_jobs: result.total_jobs,
+                                job_ids: result.job_ids,
+                                stages: result.stages,
+                                message: `Workflow started with ${result.total_jobs} agents across ${result.total_stages} stages. Use get_workflow_status to poll progress.`,
+                            }),
+                        }],
+                };
+            }
+            catch (err) {
+                logger.error("[mcp] generate_workflow failed", { err: String(err) });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ error: String(err) }),
+                        }],
+                };
+            }
+        }
+        case "get_workflow_status": {
+            const workflowId = a.workflow_id;
+            logger.info("[mcp] get_workflow_status", { workflow_id: workflowId });
+            const record = await getWorkflowStatus(workflowId, getRedis());
+            if (!record) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ error: `Workflow '${workflowId}' not found` }),
+                        }],
+                };
+            }
+            // Enrich with current job statuses per stage
+            const enrichedStages = await Promise.all(record.stages.map(async (stage) => {
+                const enrichedSteps = await Promise.all(stage.steps.map(async (step) => {
+                    let status;
+                    let score;
+                    if (step.job_id) {
+                        const jobRec = await jobStore.getJob(step.job_id);
+                        status = jobRec?.status;
+                        score = jobRec?.score;
+                    }
+                    return { ...step, status: status ?? "unknown", score: score ?? null };
+                }));
+                const stageStatuses = enrichedSteps.map((s) => s.status);
+                const allDone = stageStatuses.every((s) => s === "done");
+                const anyFailed = stageStatuses.some((s) => s === "failed");
+                const stageStatus = allDone ? "done" : anyFailed ? "failed" : "running";
+                return { stage: stage.stage, status: stageStatus, steps: enrichedSteps };
+            }));
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            workflow_id: record.workflow_id,
+                            goal: record.goal,
+                            status: record.status,
+                            total_stages: record.stages.length,
+                            total_jobs: record.all_job_ids.length,
+                            stages: enrichedStages,
+                            created_at: record.created_at,
+                            completed_at: record.completed_at ?? null,
+                            error: record.error ?? null,
+                        }),
+                    }],
+            };
+        }
         default:
             throw new Error(`Unknown tool: ${name}`);
     }