@mndrk/agx 2.0.36 → 2.0.39

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

package/cloud-runtime/standalone/mcp/dist/tools/audit.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { getSupabase } from "../db.js";
+// ============ SCHEMAS ============
+export const auditLogSchema = z.object({
+    userId: z.string().uuid().describe("User ID"),
+    taskId: z.string().uuid().describe("Task ID"),
+    action: z.enum(["dispatch", "execute", "complete", "reject", "fail"]).describe("Action type"),
+    payload: z.record(z.string(), z.unknown()).default({}).describe("Action payload/details"),
+    signature: z.string().default("unsigned").describe("HMAC signature"),
+    result: z.enum(["pending", "success", "rejected", "failed"]).default("pending").describe("Result"),
+    ipAddress: z.string().optional().describe("Client IP address"),
+    userAgent: z.string().optional().describe("Client user agent"),
+});
+export const auditListSchema = z.object({
+    userId: z.string().uuid().describe("User ID"),
+    taskId: z.string().uuid().optional().describe("Filter by task ID"),
+    action: z.enum(["dispatch", "execute", "complete", "reject", "fail"]).optional().describe("Filter by action"),
+    result: z.enum(["pending", "success", "rejected", "failed"]).optional().describe("Filter by result"),
+    limit: z.number().int().min(1).max(100).default(50).describe("Max results"),
+    offset: z.number().int().min(0).default(0).describe("Pagination offset"),
+});
+// ============ HANDLERS ============
+export async function auditLog(args) {
+    const supabase = getSupabase();
+    const { data, error } = await supabase
+        .from("task_audit_log")
+        .insert({
+        user_id: args.userId,
+        task_id: args.taskId,
+        action: args.action,
+        payload: args.payload,
+        signature: args.signature,
+        ip_address: args.ipAddress,
+        user_agent: args.userAgent,
+        result: args.result,
+    })
+        .select("id")
+        .single();
+    if (error)
+        throw new Error(`Failed to write audit log: ${error.message}`);
+    return {
+        id: data.id,
+        logged: true,
+    };
+}
+export async function auditList(args) {
+    const supabase = getSupabase();
+    let query = supabase
+        .from("task_audit_log")
+        .select("*")
+        .eq("user_id", args.userId)
+        .order("dispatched_at", { ascending: false })
+        .range(args.offset, args.offset + args.limit - 1);
+    if (args.taskId)
+        query = query.eq("task_id", args.taskId);
+    if (args.action)
+        query = query.eq("action", args.action);
+    if (args.result)
+        query = query.eq("result", args.result);
+    const { data, error } = await query;
+    if (error)
+        throw new Error(`Failed to list audit logs: ${error.message}`);
+    return {
+        logs: data || [],
+        count: data?.length || 0,
+        hasMore: data?.length === args.limit,
+    };
+}
+//# sourceMappingURL=audit.js.map

package/cloud-runtime/standalone/mcp/dist/tools/learnings.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { getSupabase } from "../db.js";
+// ============ SCHEMAS ============
+export const learningsAddSchema = z.object({
+    scope: z.enum(["task", "project", "global"]).describe("Learning scope"),
+    content: z.string().min(1).describe("Learning content"),
+    scopeId: z.string().optional().describe("Task ID or project name (for task/project scope)"),
+    userId: z.string().uuid().optional().describe("User ID"),
+});
+export const learningsListSchema = z.object({
+    scope: z.enum(["task", "project", "global"]).default("global").describe("Filter by scope"),
+    scopeId: z.string().optional().describe("Filter by scope ID (task ID or project name)"),
+    userId: z.string().uuid().optional().describe("Filter by user ID"),
+    limit: z.number().int().min(1).max(100).default(50).describe("Max results"),
+});
+export const learningsSearchSchema = z.object({
+    query: z.string().min(1).describe("Search query"),
+    scope: z.enum(["task", "project", "global"]).optional().describe("Filter by scope"),
+    userId: z.string().uuid().optional().describe("Filter by user ID"),
+    limit: z.number().int().min(1).max(100).default(20).describe("Max results"),
+});
+// ============ HANDLERS ============
+export async function learningsAdd(args) {
+    const supabase = getSupabase();
+    // Validate scopeId requirement
+    if (args.scope === "task" && !args.scopeId) {
+        throw new Error("scopeId (task ID) is required for task-level learnings");
+    }
+    if (args.scope === "project" && !args.scopeId) {
+        throw new Error("scopeId (project name) is required for project-level learnings");
+    }
+    const { data, error } = await supabase
+        .from("learnings")
+        .insert({
+        scope: args.scope,
+        scope_id: args.scopeId,
+        content: args.content,
+        user_id: args.userId,
+    })
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to add learning: ${error.message}`);
+    return { learning: data };
+}
+export async function learningsList(args) {
+    const supabase = getSupabase();
+    let query = supabase
+        .from("learnings")
+        .select("*")
+        .eq("scope", args.scope)
+        .order("created_at", { ascending: false })
+        .limit(args.limit);
+    if (args.scopeId)
+        query = query.eq("scope_id", args.scopeId);
+    if (args.userId)
+        query = query.eq("user_id", args.userId);
+    const { data, error } = await query;
+    if (error)
+        throw new Error(`Failed to list learnings: ${error.message}`);
+    return {
+        learnings: data || [],
+        count: data?.length || 0,
+    };
+}
+export async function learningsSearch(args) {
+    const supabase = getSupabase();
+    // Simple text search using ILIKE
+    // For true semantic search, would need vector embeddings + pgvector
+    let query = supabase
+        .from("learnings")
+        .select("*")
+        .ilike("content", `%${args.query}%`)
+        .order("created_at", { ascending: false })
+        .limit(args.limit);
+    if (args.scope)
+        query = query.eq("scope", args.scope);
+    if (args.userId)
+        query = query.eq("user_id", args.userId);
+    const { data, error } = await query;
+    if (error)
+        throw new Error(`Failed to search learnings: ${error.message}`);
+    return {
+        learnings: data || [],
+        count: data?.length || 0,
+    };
+}
+//# sourceMappingURL=learnings.js.map