@mndrk/agx 2.0.26 → 2.0.32

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

@@ -1,66 +0,0 @@
-export const defaultStagePrompts = {
-    ideation: {
-        prompt: "Do the hard work to understand the user's true intent, as they may not know it themselves. Interpret their request and present concrete scenarios to help them visualize options. Iterate until something 'clicks'. It is okay if only 1 out of 10 proposals resonates; the goal is finding that alignment.",
-        outputs: ["research.md"],
-        provider: "gemini",
-        model: "gemini-2.0-flash-thinking-exp",
-        swarm: false,
-    },
-    planning: {
-        prompt: "Translate the aligned intent into an implementation plan.",
-        outputs: ["plan.md", "tasks.md"],
-        provider: "claude",
-        model: "claude-3-5-sonnet-latest",
-        swarm: false,
-    },
-    coding: {
-        prompt: "Implement the plan with clean, reviewed code. Keep changes minimal and well-scoped. Add or update tests as needed. Note any deviations from plan and why.",
-        outputs: ["code", "tests", "PR"],
-        provider: "claude",
-        model: "claude-3-5-sonnet-latest",
-        swarm: false,
-    },
-    qa: {
-        prompt: "Test thoroughly against the acceptance criteria. Cover edge cases and regression risks. Document test results and fix any issues found before proceeding.",
-        outputs: ["test results", "bug fixes"],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-    acceptance: {
-        prompt: "Prepare a concise demo or summary of changes. Verify requirements are met and gather user feedback. Capture approvals or list follow-up actions.",
-        outputs: ["approval", "feedback"],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-    pr: {
-        prompt: "Create and review pull request. Ensure all checks pass and merge. Note any deviations from plan and why.",
-        outputs: ["pull request", "merge commit"],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-    pr_review: {
-        prompt: "Review the PR. Verify code quality and functionality. Approve or request changes.",
-        outputs: ["review comments", "approval"],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-    merge: {
-        prompt: "Merge the PR and verify deployment.",
-        outputs: ["merge", "deployment verification"],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-    done: {
-        prompt: "Task completed. Ensure artifacts are stored, logs are clear, and any follow-ups are recorded.",
-        outputs: [],
-        provider: "gemini",
-        model: "gemini-2.0-flash",
-        swarm: false,
-    },
-};
-//# sourceMappingURL=constants.js.map

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

@@ -1,220 +0,0 @@
-import { Pool } from "pg";
-import { config } from "dotenv";
-import { resolve, dirname } from "path";
-import { fileURLToPath } from "url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-config({ path: resolve(__dirname, "../../.env") });
-const pool = new Pool({
-    connectionString: process.env.DATABASE_URL,
-});
-class QueryBuilder {
-    table;
-    operation = "select";
-    filters = [];
-    orderSpecs = [];
-    limitValue = null;
-    selectColumns = "*";
-    payload = null;
-    singleMode = "none";
-    returning = false;
-    constructor(table) {
-        this.table = table;
-    }
-    select(columns = "*") {
-        this.selectColumns = columns || "*";
-        if (this.operation !== "select")
-            this.returning = true;
-        return this;
-    }
-    insert(payload) {
-        this.operation = "insert";
-        this.payload = payload;
-        return this;
-    }
-    update(payload) {
-        this.operation = "update";
-        this.payload = payload;
-        return this;
-    }
-    delete() {
-        this.operation = "delete";
-        return this;
-    }
-    eq(column, value) {
-        this.filters.push({ op: "eq", column, value });
-        return this;
-    }
-    in(column, value) {
-        this.filters.push({ op: "in", column, value });
-        return this;
-    }
-    is(column, value) {
-        this.filters.push({ op: "is", column, value });
-        return this;
-    }
-    order(column, options) {
-        this.orderSpecs.push({ column, ...(options || {}) });
-        return this;
-    }
-    limit(limit) {
-        this.limitValue = limit;
-        return this;
-    }
-    single() {
-        this.singleMode = "single";
-        return this.execute();
-    }
-    maybeSingle() {
-        this.singleMode = "maybeSingle";
-        return this.execute();
-    }
-    then(resolve, reject) {
-        return this.execute().then(resolve, reject);
-    }
-    whereSql(params) {
-        const where = [];
-        for (const f of this.filters) {
-            if (f.op === "eq") {
-                params.push(f.value);
-                where.push(`${f.column} = $${params.length}`);
-            }
-            else if (f.op === "in") {
-                params.push(f.value);
-                where.push(`${f.column} = ANY($${params.length})`);
-            }
-            else if (f.op === "is") {
-                if (f.value === null)
-                    where.push(`${f.column} IS NULL`);
-                else {
-                    params.push(f.value);
-                    where.push(`${f.column} IS NOT DISTINCT FROM $${params.length}`);
-                }
-            }
-        }
-        return where;
-    }
-    normalizeColumns() {
-        if (!this.selectColumns || this.selectColumns.trim() === "*")
-            return "*";
-        return this.selectColumns;
-    }
-    async execute() {
-        try {
-            const params = [];
-            const where = this.whereSql(params);
-            let sql = "";
-            if (this.operation === "select") {
-                sql = `SELECT ${this.normalizeColumns()} FROM ${this.table}`;
-                if (where.length)
-                    sql += ` WHERE ${where.join(" AND ")}`;
-                if (this.orderSpecs.length) {
-                    sql +=
-                        " ORDER BY " +
-                            this.orderSpecs
-                                .map((o) => {
-                                const dir = o.ascending === false ? "DESC" : "ASC";
-                                const nulls = o.nullsFirst === true ? " NULLS FIRST" : o.nullsFirst === false ? " NULLS LAST" : "";
-                                return `${o.column} ${dir}${nulls}`;
-                            })
-                                .join(", ");
-                }
-                if (this.limitValue != null) {
-                    params.push(this.limitValue);
-                    sql += ` LIMIT $${params.length}`;
-                }
-            }
-            else if (this.operation === "insert") {
-                const rows = Array.isArray(this.payload) ? this.payload : [this.payload];
-                const cols = Object.keys(rows[0] || {});
-                const valuesSql = rows
-                    .map((row) => {
-                    const placeholders = cols.map((col) => {
-                        params.push(row[col]);
-                        return `$${params.length}`;
-                    });
-                    return `(${placeholders.join(", ")})`;
-                })
-                    .join(", ");
-                sql = `INSERT INTO ${this.table} (${cols.join(", ")}) VALUES ${valuesSql}`;
-                if (this.returning)
-                    sql += " RETURNING *";
-            }
-            else if (this.operation === "update") {
-                const cols = Object.keys(this.payload || {});
-                const setSql = cols
-                    .map((col) => {
-                    params.push(this.payload[col]);
-                    return `${col} = $${params.length}`;
-                })
-                    .join(", ");
-                sql = `UPDATE ${this.table} SET ${setSql}`;
-                if (where.length)
-                    sql += ` WHERE ${where.join(" AND ")}`;
-                if (this.returning)
-                    sql += " RETURNING *";
-            }
-            else {
-                sql = `DELETE FROM ${this.table}`;
-                if (where.length)
-                    sql += ` WHERE ${where.join(" AND ")}`;
-                if (this.returning)
-                    sql += " RETURNING *";
-            }
-            const res = await pool.query(sql, params);
-            const rows = res.rows;
-            if (this.singleMode === "single") {
-                if (!rows.length)
-                    return { data: null, error: { message: "No rows" } };
-                return { data: rows[0], error: null };
-            }
-            if (this.singleMode === "maybeSingle") {
-                return { data: rows[0] || null, error: null };
-            }
-            return { data: rows, error: null };
-        }
-        catch (error) {
-            return { data: null, error };
-        }
-    }
-}
-let db = null;
-export function getSupabase() {
-    if (db)
-        return db;
-    if (!process.env.DATABASE_URL) {
-        throw new Error("Missing DATABASE_URL for MCP server.");
-    }
-    db = {
-        from(table) {
-            return new QueryBuilder(table);
-        },
-    };
-    return db;
-}
-export async function fetchStageConfig(supabase, stage, userId) {
-    let stagePrompt = null;
-    let defaultPrompt = null;
-    const promises = [
-        supabase.from("stage_prompts").select("*").eq("stage", stage).eq("is_default", true).maybeSingle(),
-    ];
-    if (userId) {
-        promises.push(supabase.from("stage_prompts").select("*").eq("stage", stage).eq("user_id", userId).maybeSingle());
-    }
-    const results = await Promise.all(promises);
-    defaultPrompt = results[0].data;
-    if (userId) {
-        stagePrompt = results[1].data;
-    }
-    const resolvedPrompt = stagePrompt?.prompt || defaultPrompt?.prompt || null;
-    if (!resolvedPrompt) {
-        throw new Error(`No prompt found for stage "${stage}" in database (checked user and default).`);
-    }
-    return {
-        prompt: resolvedPrompt,
-        swarm: stagePrompt?.swarm ?? defaultPrompt?.swarm ?? false,
-        provider: stagePrompt?.provider || defaultPrompt?.provider,
-        model: stagePrompt?.model || defaultPrompt?.model,
-        swarm_models: stagePrompt?.swarm_models || defaultPrompt?.swarm_models,
-    };
-}
-//# sourceMappingURL=db.js.map

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

@@ -1,7 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-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

@@ -1,240 +0,0 @@
-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