@mndrk/agx 2.0.38 → 2.0.40

package/cloud-runtime/standalone/mcp/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runServer } from "./server.js";
+runServer().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/cloud-runtime/standalone/mcp/dist/security.js

@@ -0,0 +1,18 @@
+import { createHmac } from "crypto";
+export function signTask(task, secret) {
+    const payload = JSON.stringify({
+        id: task.id,
+        user_id: task.user_id,
+        content: task.content,
+        stage: task.stage || "ideation",
+        engine: task.engine || "claude",
+        provider: task.provider || null,
+        model: task.model || null,
+        swarm: task.swarm || false,
+        swarm_models: task.swarm_models || null,
+        comments_digest: task.comments_digest ?? null,
+        created_at: task.created_at,
+    });
+    return createHmac("sha256", secret).update(payload).digest("hex");
+}
+//# sourceMappingURL=security.js.map

package/cloud-runtime/standalone/mcp/dist/server.js

@@ -0,0 +1,240 @@
+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 tool handlers and schemas
+import { tasksListSchema, tasksList, tasksGetSchema, tasksGet, tasksCreateSchema, tasksCreate, tasksUpdateSchema, tasksUpdate, tasksLogSchema, tasksLog, } from "./tools/tasks.js";
+import { queuePullSchema, queuePull, queueCompleteSchema, queueComplete, queueFailSchema, queueFail, } from "./tools/queue.js";
+import { learningsAddSchema, learningsAdd, learningsListSchema, learningsList, learningsSearchSchema, learningsSearch, } from "./tools/learnings.js";
+import { auditLogSchema, auditLog, auditListSchema, auditList, } from "./tools/audit.js";
+// Convert Zod schema to JSON Schema (simplified)
+function zodToJsonSchema(zodSchema) {
+    // Get the shape from the Zod schema
+    let shape;
+    const def = zodSchema._def;
+    if (def.typeName === "ZodObject") {
+        shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    }
+    else {
+        return { type: "object", properties: {} };
+    }
+    if (!shape)
+        return { type: "object", properties: {} };
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+        let def = value._def;
+        let prop = {};
+        // Unwrap ZodOptional and ZodDefault
+        let isOptional = false;
+        while (def) {
+            if (def.typeName === "ZodOptional") {
+                isOptional = true;
+                def = def.innerType?._def;
+            }
+            else if (def.typeName === "ZodDefault") {
+                isOptional = true;
+                prop.default = typeof def.defaultValue === "function"
+                    ? def.defaultValue()
+                    : def.defaultValue;
+                def = def.innerType?._def;
+            }
+            else {
+                break;
+            }
+        }
+        if (!def) {
+            properties[key] = { type: "string" };
+            continue;
+        }
+        // Get description from the original or inner def
+        const origDef = value._def;
+        prop.description = def.description || origDef.description;
+        // Determine type
+        switch (def.typeName) {
+            case "ZodString":
+                prop.type = "string";
+                break;
+            case "ZodNumber":
+                prop.type = "number";
+                break;
+            case "ZodBoolean":
+                prop.type = "boolean";
+                break;
+            case "ZodEnum":
+                prop.type = "string";
+                prop.enum = def.values;
+                break;
+            case "ZodRecord":
+                prop.type = "object";
+                break;
+            case "ZodArray":
+                prop.type = "array";
+                break;
+            default:
+                prop.type = "string";
+        }
+        properties[key] = prop;
+        // Track required fields
+        if (!isOptional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : undefined,
+    };
+}
+// Tool definitions
+const tools = [
+    // Tasks
+    {
+        name: "tasks/list",
+        description: "List tasks with optional filters (status, stage, project, user)",
+        inputSchema: zodToJsonSchema(tasksListSchema),
+        handler: tasksList,
+        schema: tasksListSchema,
+    },
+    {
+        name: "tasks/get",
+        description: "Get a task by ID with full context and optionally its logs",
+        inputSchema: zodToJsonSchema(tasksGetSchema),
+        handler: tasksGet,
+        schema: tasksGetSchema,
+    },
+    {
+        name: "tasks/create",
+        description: "Create a new task with title, description, project, and priority",
+        inputSchema: zodToJsonSchema(tasksCreateSchema),
+        handler: tasksCreate,
+        schema: tasksCreateSchema,
+    },
+    {
+        name: "tasks/update",
+        description: "Update task fields (status, stage, priority, project)",
+        inputSchema: zodToJsonSchema(tasksUpdateSchema),
+        handler: tasksUpdate,
+        schema: tasksUpdateSchema,
+    },
+    {
+        name: "tasks/log",
+        description: "Append a log entry to a task",
+        inputSchema: zodToJsonSchema(tasksLogSchema),
+        handler: tasksLog,
+        schema: tasksLogSchema,
+    },
+    // Queue
+    {
+        name: "queue/pull",
+        description: "Get the next available task from the queue for a user. Marks it as in_progress.",
+        inputSchema: zodToJsonSchema(queuePullSchema),
+        handler: queuePull,
+        schema: queuePullSchema,
+    },
+    {
+        name: "queue/complete",
+        description: "Mark current task stage as complete and advance to next stage",
+        inputSchema: zodToJsonSchema(queueCompleteSchema),
+        handler: queueComplete,
+        schema: queueCompleteSchema,
+    },
+    {
+        name: "queue/fail",
+        description: "Mark a task as failed with an error message",
+        inputSchema: zodToJsonSchema(queueFailSchema),
+        handler: queueFail,
+        schema: queueFailSchema,
+    },
+    // Learnings
+    {
+        name: "learnings/add",
+        description: "Record a learning (task-level, project-level, or global)",
+        inputSchema: zodToJsonSchema(learningsAddSchema),
+        handler: learningsAdd,
+        schema: learningsAddSchema,
+    },
+    {
+        name: "learnings/list",
+        description: "List learnings with optional scope and user filters",
+        inputSchema: zodToJsonSchema(learningsListSchema),
+        handler: learningsList,
+        schema: learningsListSchema,
+    },
+    {
+        name: "learnings/search",
+        description: "Search learnings by text query",
+        inputSchema: zodToJsonSchema(learningsSearchSchema),
+        handler: learningsSearch,
+        schema: learningsSearchSchema,
+    },
+    // Audit
+    {
+        name: "audit/log",
+        description: "Record an audit event for a task action",
+        inputSchema: zodToJsonSchema(auditLogSchema),
+        handler: auditLog,
+        schema: auditLogSchema,
+    },
+    {
+        name: "audit/list",
+        description: "List audit events with filters",
+        inputSchema: zodToJsonSchema(auditListSchema),
+        handler: auditList,
+        schema: auditListSchema,
+    },
+];
+export async function createServer() {
+    const server = new Server({
+        name: "agx-mcp-server",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            })),
+        };
+    });
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const tool = tools.find(t => t.name === name);
+        if (!tool) {
+            return {
+                content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        try {
+            // Validate input
+            const validated = tool.schema.parse(args || {});
+            // Execute handler
+            const result = await tool.handler(validated);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function runServer() {
+    const server = await createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("AGX MCP Server running on stdio");
+}
+//# sourceMappingURL=server.js.map

package/cloud-runtime/standalone/mcp/dist/task-context.js

@@ -0,0 +1,287 @@
+import { createHash } from "crypto";
+import { getSupabase, fetchStageConfig } from "./db.js";
+import { parseFrontmatter, resolveTaskConfig, } from "./types.js";
+export async function getTaskComments(taskId) {
+    const supabase = getSupabase();
+    const { data, error } = await supabase
+        .from("task_comments")
+        .select("*")
+        .eq("task_id", taskId)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: true })
+        .order("id", { ascending: true });
+    if (error) {
+        const message = typeof error?.message === "string"
+            ? error.message
+            : "";
+        const code = error.code;
+        const isMissingRelation = code === "42P01" ||
+            code === "PGRST205" ||
+            message.includes('relation "task_comments" does not exist') ||
+            message.includes("Could not find the table 'public.task_comments'");
+        if (isMissingRelation) {
+            return [];
+        }
+        throw error;
+    }
+    return data || [];
+}
+export async function getTaskLearnings(task) {
+    const supabase = getSupabase();
+    const userId = task.user_id;
+    const taskQuery = supabase
+        .from("learnings")
+        .select("*")
+        .eq("scope", "task")
+        .eq("scope_id", task.id);
+    if (userId)
+        taskQuery.eq("user_id", userId);
+    const projectScopeIds = new Set();
+    if (task.project_id)
+        projectScopeIds.add(task.project_id);
+    if (task.project)
+        projectScopeIds.add(task.project);
+    if (!task.project_id && task.project) {
+        const project = await fetchProjectBySlugWithRepos(task.project, userId);
+        if (project?.id)
+            projectScopeIds.add(project.id);
+    }
+    const projectScopeIdList = Array.from(projectScopeIds);
+    const projectQuery = projectScopeIdList.length
+        ? supabase
+            .from("learnings")
+            .select("*")
+            .eq("scope", "project")
+            .in("scope_id", projectScopeIdList)
+        : null;
+    if (projectQuery && userId) {
+        projectQuery.eq("user_id", userId);
+    }
+    const globalQuery = supabase
+        .from("learnings")
+        .select("*")
+        .eq("scope", "global");
+    if (userId)
+        globalQuery.eq("user_id", userId);
+    const [{ data: taskLearnings, error: taskError }, { data: globalLearnings, error: globalError }, projectResult] = await Promise.all([
+        taskQuery,
+        globalQuery,
+        projectQuery ?? Promise.resolve({ data: [], error: null }),
+    ]);
+    if (taskError)
+        throw taskError;
+    if (globalError)
+        throw globalError;
+    if (projectResult?.error)
+        throw projectResult.error;
+    return {
+        task: taskLearnings || [],
+        project: projectResult?.data || [],
+        global: globalLearnings || [],
+    };
+}
+function formatList(items, emptyLabel) {
+    if (!items.length)
+        return emptyLabel;
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function isMissingRelationError(error, relation) {
+    const message = typeof error?.message === "string"
+        ? error.message
+        : "";
+    const code = error.code;
+    return (code === "42P01" ||
+        code === "PGRST205" ||
+        message.includes(`relation "${relation}" does not exist`) ||
+        message.includes(`Could not find the table 'public.${relation}'`));
+}
+function formatProjectMetadata(project) {
+    const lines = [
+        `Name: ${project.name}`,
+        `Slug: ${project.slug}`,
+        `Description: ${project.description?.trim() || "None"}`,
+    ];
+    if (project.ci_cd_info) {
+        lines.push(`CI/CD: ${project.ci_cd_info}`);
+    }
+    const metadata = project.metadata;
+    if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+        const entries = Object.entries(metadata).filter(([key]) => key);
+        if (entries.length) {
+            lines.push("Metadata:");
+            entries.forEach(([key, value]) => {
+                lines.push(`  ${key}: ${JSON.stringify(value)}`);
+            });
+        }
+    }
+    return lines.join("\n");
+}
+function formatRepoLines(repos) {
+    if (!repos.length)
+        return "(none)";
+    return repos
+        .map((repo) => {
+        const parts = [`${repo.name}`];
+        if (repo.path)
+            parts.push(`path: ${repo.path}`);
+        if (repo.git_url)
+            parts.push(`git_url: ${repo.git_url}`);
+        if (repo.notes)
+            parts.push(`notes: ${repo.notes}`);
+        return `- ${parts.join(" | ")}`;
+    })
+        .join("\n");
+}
+async function fetchProjectRepos(projectId) {
+    const supabase = getSupabase();
+    const { data, error } = await supabase
+        .from("project_repos")
+        .select("*")
+        .eq("project_id", projectId);
+    if (error) {
+        if (isMissingRelationError(error, "project_repos")) {
+            return [];
+        }
+        throw error;
+    }
+    return data || [];
+}
+async function fetchProjectByIdWithRepos(projectId, userId) {
+    const supabase = getSupabase();
+    let query = supabase.from("projects").select("*").eq("id", projectId);
+    if (userId)
+        query = query.eq("user_id", userId);
+    const { data, error } = await query.maybeSingle();
+    if (error) {
+        if (isMissingRelationError(error, "projects")) {
+            return null;
+        }
+        throw error;
+    }
+    if (!data)
+        return null;
+    const repos = await fetchProjectRepos(data.id);
+    return { ...data, repos };
+}
+async function fetchProjectBySlugWithRepos(slug, userId) {
+    const supabase = getSupabase();
+    let query = supabase.from("projects").select("*").eq("slug", slug);
+    if (userId)
+        query = query.eq("user_id", userId);
+    const { data, error } = await query.maybeSingle();
+    if (error) {
+        if (isMissingRelationError(error, "projects")) {
+            return null;
+        }
+        throw error;
+    }
+    if (!data)
+        return null;
+    const repos = await fetchProjectRepos(data.id);
+    return { ...data, repos };
+}
+async function resolveProjectContext(task, projectLearnings) {
+    const projectId = task.project_id;
+    const projectSlug = !projectId && task.project ? task.project : undefined;
+    let projectWithRepos = null;
+    if (projectId) {
+        projectWithRepos = await fetchProjectByIdWithRepos(projectId, task.user_id);
+    }
+    if (!projectWithRepos && projectSlug) {
+        projectWithRepos = await fetchProjectBySlugWithRepos(projectSlug, task.user_id);
+    }
+    if (!projectWithRepos) {
+        return null;
+    }
+    return {
+        project: projectWithRepos,
+        repos: projectWithRepos.repos ?? [],
+        learnings: projectLearnings.map((learning) => learning.content),
+    };
+}
+function isPromptRelevantComment(content) {
+    const normalized = String(content || "").trim();
+    if (!normalized)
+        return false;
+    if (normalized.startsWith("[execution/"))
+        return false;
+    if (normalized.startsWith("Execution result from agx"))
+        return false;
+    return true;
+}
+export function computeCommentsDigest(comments) {
+    const normalized = comments.map((comment) => ({
+        id: comment.id,
+        task_id: comment.task_id,
+        author_type: comment.author_type || null,
+        author_id: comment.author_id || null,
+        content: comment.content || "",
+        created_at: comment.created_at || null,
+    }));
+    const serialized = JSON.stringify(normalized);
+    return createHash("sha256").update(serialized).digest("hex");
+}
+export function buildTaskPrompt(args) {
+    const { task, comments, learnings, stage_config, project_context } = args;
+    const { body } = parseFrontmatter(task.content);
+    const description = (task.description ?? body).trim();
+    // Resolve configuration (Task > Stage)
+    const config = resolveTaskConfig(task, stage_config);
+    const metaLines = [
+        `Title: ${task.title || "Untitled"}`,
+        `Slug: ${task.slug || "unspecified"}`,
+        `Stage: ${task.stage || "ideation"}`,
+        `Project: ${task.project || "none"}`,
+        `Engine: ${task.engine || "unspecified"}`,
+        `Provider: ${config.provider}`,
+        `Model: ${config.model}`,
+        `Swarm: ${config.swarm ? "true" : "false"}`,
+        `Swarm Models: ${config.swarm_models.length ? config.swarm_models.map((m) => `${m.provider}:${m.model}`).join(", ") : "none"}`,
+    ];
+    const commentLines = comments
+        .filter((comment) => isPromptRelevantComment(comment.content))
+        .map((comment) => {
+        const when = comment.created_at ? new Date(comment.created_at).toISOString() : "unknown-time";
+        const author = comment.author_type === "agent" ? "agent" : "user";
+        return `[${when}] (${author}) ${comment.content}`;
+    });
+    const projectContextSections = project_context?.project
+        ? [
+            `PROJECT CONTEXT\n${formatProjectMetadata(project_context.project)}`,
+            `REPOSITORY MAP\n${formatRepoLines(project_context.repos)}`,
+            `PROJECT LEARNINGS\n${formatList(project_context.learnings, "(none)")}`,
+        ]
+        : [];
+    const sections = [
+        stage_config.prompt ? `STAGE PROMPT\n${stage_config.prompt}` : null,
+        "EXECUTION RULES\n- Do not use AGX MCP tools or AGX MCP servers for this task.\n- Complete work using local edits, shell commands, and allowed HTTP APIs only.",
+        `TASK\n${description || "(empty)"}`,
+        `COMMENTS\n${formatList(commentLines, "(none)")}`,
+        ...projectContextSections,
+        `LEARNINGS (task)\n${formatList(learnings.task.map((l) => l.content), "(none)")}`,
+        `LEARNINGS (project)\n${formatList(learnings.project.map((l) => l.content), "(none)")}`,
+        `LEARNINGS (global)\n${formatList(learnings.global.map((l) => l.content), "(none)")}`,
+    ].filter((section) => Boolean(section));
+    return sections.join("\n\n");
+}
+export async function buildTaskContext(task) {
+    const supabase = getSupabase();
+    const stageConfigPromise = task.stage ? fetchStageConfig(supabase, task.stage, task.user_id) : Promise.resolve({ prompt: null });
+    const [comments, learnings, stage_config] = await Promise.all([
+        getTaskComments(task.id),
+        getTaskLearnings(task),
+        stageConfigPromise,
+    ]);
+    const project_context = await resolveProjectContext(task, learnings.project);
+    const config = stage_config || { prompt: null };
+    const comments_digest = computeCommentsDigest(comments);
+    return {
+        comments,
+        learnings,
+        stage_config: config,
+        project_context,
+        prompt: buildTaskPrompt({ task, comments, learnings, stage_config: config, project_context }),
+        comments_digest,
+    };
+}
+//# sourceMappingURL=task-context.js.map

package/cloud-runtime/standalone/mcp/dist/test-client.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env tsx
+/**
+ * Test client for AGX MCP Server
+ *
+ * Usage:
+ *   npm run test
+ *   # or
+ *   tsx src/test-client.ts
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { spawn } from "child_process";
+const TEST_USER_ID = "00000000-0000-0000-0000-000000000001"; // Fake UUID for testing
+async function main() {
+    console.log("🧪 AGX MCP Server Test Client\n");
+    // Spawn the MCP server
+    console.log("Starting MCP server...");
+    const serverProcess = spawn("npx", ["tsx", "src/index.ts"], {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "inherit"],
+    });
+    const transport = new StdioClientTransport({
+        command: "npx",
+        args: ["tsx", "src/index.ts"],
+        cwd: process.cwd(),
+    });
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    try {
+        await client.connect(transport);
+        console.log("✅ Connected to MCP server\n");
+        // List all tools
+        console.log("📋 Available Tools:");
+        console.log("─".repeat(50));
+        const tools = await client.listTools();
+        for (const tool of tools.tools) {
+            console.log(`  • ${tool.name}`);
+            console.log(`    ${tool.description}\n`);
+        }
+        // Test tasks/list
+        console.log("\n🔧 Testing tasks/list...");
+        const listResult = await client.callTool({
+            name: "tasks/list",
+            arguments: { limit: 5 },
+        });
+        const listContent = listResult.content;
+        console.log("Result:", JSON.stringify(JSON.parse(listContent[0].text), null, 2));
+        // Test learnings/list
+        console.log("\n🔧 Testing learnings/list...");
+        const learningsResult = await client.callTool({
+            name: "learnings/list",
+            arguments: { scope: "global", limit: 5 },
+        });
+        const learningsContent = learningsResult.content;
+        console.log("Result:", JSON.stringify(JSON.parse(learningsContent[0].text), null, 2));
+        // Test creating a task (if you have a real user ID)
+        // Uncomment below to test task creation
+        /*
+        console.log("\n🔧 Testing tasks/create...");
+        const createResult = await client.callTool({
+          name: "tasks/create",
+          arguments: {
+            title: "Test task from MCP client",
+            description: "This is a test task created via the MCP server",
+            project: "mcp-test",
+            priority: 3,
+          },
+        });
+        console.log("Result:", JSON.stringify(JSON.parse((createResult.content[0] as any).text), null, 2));
+        */
+        console.log("\n✅ All tests completed!");
+    }
+    catch (error) {
+        console.error("❌ Test failed:", error);
+        process.exit(1);
+    }
+    finally {
+        await client.close();
+        serverProcess.kill();
+    }
+}
+main();
+//# sourceMappingURL=test-client.js.map