@mndrk/agx 2.0.38 → 2.0.39

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

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

@@ -0,0 +1,312 @@
+import { z } from "zod";
+import { getSupabase, fetchStageConfig } from "../db.js";
+import { parseFrontmatter, buildContent, getNextStage, } from "../types.js";
+import { buildTaskContext } from "../task-context.js";
+import { signTask } from "../security.js";
+// ============ SCHEMAS ============
+export const queuePullSchema = z.object({
+    userId: z.string().uuid().describe("User ID to pull tasks for"),
+    engine: z.string().optional().describe("Filter by AI engine (e.g. claude, gemini)"),
+});
+export const queueCompleteSchema = z.object({
+    taskId: z.string().uuid().describe("Task ID"),
+    log: z.string().optional().describe("Optional agent comment from completion run"),
+    final_result: z.string().optional().describe("Final result message from aggregator"),
+    decision: z.enum(["done", "blocked", "not_done", "failed"]).optional().describe("Aggregator decision"),
+    explanation: z.string().optional().describe("Aggregator explanation for decision"),
+});
+export const queueFailSchema = z.object({
+    taskId: z.string().uuid().describe("Task ID"),
+    error: z.string().describe("Error message"),
+    log: z.string().optional().describe("Additional error context/log"),
+});
+function isMissingStageDecisionsError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = "code" in error ? String(error.code) : "";
+    const message = "message" in error ? String(error.message).toLowerCase() : "";
+    return (code === "PGRST204" || code === "42703") && message.includes("stage_decisions");
+}
+// ============ HANDLERS ============
+export async function queuePull(args) {
+    const supabase = getSupabase();
+    let query = supabase
+        .from("tasks")
+        .select("*")
+        .eq("user_id", args.userId)
+        .eq("status", "queued")
+        .order("priority", { ascending: true, nullsFirst: false })
+        .order("created_at", { ascending: true })
+        .limit(1);
+    if (args.engine) {
+        query = query.eq("engine", args.engine);
+    }
+    const { data: tasks, error } = await query;
+    if (error)
+        throw new Error(`Failed to pull from queue: ${error.message}`);
+    const task = tasks?.[0];
+    if (!task) {
+        return { task: null, message: "No tasks in queue" };
+    }
+    // Mark task as in_progress
+    const { frontmatter, body } = parseFrontmatter(task.content);
+    frontmatter.status = "in_progress";
+    const updatedContent = buildContent(frontmatter, body);
+    const { data: updatedTask, error: updateError } = await supabase
+        .from("tasks")
+        .update({
+        content: updatedContent,
+        status: "in_progress",
+        updated_at: new Date().toISOString(),
+    })
+        .eq("id", task.id)
+        .select()
+        .single();
+    if (updateError)
+        throw new Error(`Failed to update task status: ${updateError.message}`);
+    const context = await buildTaskContext(updatedTask);
+    const { comments_digest: commentsDigest } = context;
+    let signature = updatedTask.signature || task.signature || undefined;
+    const ownerId = updatedTask.user_id || task.user_id;
+    if (ownerId) {
+        const { data: secretData } = await supabase
+            .from("user_secrets")
+            .select("daemon_secret_hash")
+            .eq("user_id", ownerId)
+            .single();
+        if (secretData?.daemon_secret_hash) {
+            const newSignature = signTask({
+                id: updatedTask.id,
+                user_id: ownerId,
+                content: updatedTask.content,
+                stage: updatedTask.stage,
+                engine: updatedTask.engine,
+                provider: updatedTask.provider,
+                model: updatedTask.model,
+                swarm: updatedTask.swarm,
+                swarm_models: updatedTask.swarm_models,
+                created_at: updatedTask.created_at,
+                comments_digest: commentsDigest,
+            }, secretData.daemon_secret_hash);
+            if (newSignature !== signature) {
+                await supabase
+                    .from("tasks")
+                    .update({ signature: newSignature })
+                    .eq("id", updatedTask.id);
+                signature = newSignature;
+            }
+            else {
+                signature = newSignature;
+            }
+        }
+    }
+    return {
+        task: {
+            ...updatedTask,
+            signature,
+            ...context,
+        },
+        message: `Pulled task: ${task.title || task.id}`,
+    };
+}
+export async function queueComplete(args) {
+    const supabase = getSupabase();
+    // Get current task
+    const { data: task, error: getError } = await supabase
+        .from("tasks")
+        .select("*")
+        .eq("id", args.taskId)
+        .single();
+    if (getError) {
+        if (getError.code === "PGRST116") {
+            throw new Error(`Task not found: ${args.taskId}`);
+        }
+        throw new Error(`Failed to get task: ${getError.message}`);
+    }
+    const { frontmatter, body } = parseFrontmatter(task.content);
+    const currentStage = frontmatter.stage || "ideation";
+    const nextStage = getNextStage(currentStage);
+    const finalResultRaw = typeof args.final_result === "string" ? args.final_result.trim() : "";
+    const decisionRaw = typeof args.decision === "string" ? args.decision.trim() : "";
+    const explanationRaw = typeof args.explanation === "string" ? args.explanation.trim() : "";
+    const missingAggregator = !finalResultRaw || !decisionRaw || !explanationRaw;
+    const missingAggregatorMessage = "Aggregator output unavailable; manual action required.";
+    const finalResult = missingAggregator ? missingAggregatorMessage : finalResultRaw;
+    const outcome = (missingAggregator ? "blocked" : decisionRaw);
+    const explanationFinal = missingAggregator ? missingAggregatorMessage : explanationRaw;
+    const MAX_RETRIES = 3;
+    const currentRetryCount = typeof task.retry_count === "number" ? task.retry_count : 0;
+    const existingStageDecisions = task.stage_decisions && typeof task.stage_decisions === "object" ? task.stage_decisions : {};
+    const nextStageDecisions = {
+        ...existingStageDecisions,
+        [currentStage]: {
+            decision: outcome,
+            rationale: explanationFinal,
+            final_result: finalResult,
+            decided_at: new Date().toISOString(),
+        },
+    };
+    // Add agent completion comment if provided
+    if (args.log) {
+        const { error: commentError } = await supabase
+            .from("task_comments")
+            .insert({ task_id: args.taskId, content: args.log, author_type: "agent" });
+        if (commentError) {
+            console.error("Failed to add agent comment:", commentError);
+        }
+    }
+    let updatedStage = currentStage;
+    let updatedStatus = task.status ?? "queued";
+    let updatedRetryCount = currentRetryCount;
+    let errorValue = null;
+    if (outcome === "done") {
+        if (nextStage) {
+            updatedStage = nextStage;
+            updatedStatus = "queued";
+        }
+        else {
+            updatedStage = "done";
+            updatedStatus = "completed";
+        }
+        updatedRetryCount = 0;
+        const { error: completionLogError } = await supabase
+            .from("task_logs")
+            .insert({ task_id: args.taskId, content: `Stage completed: ${currentStage}`, log_type: "checkpoint" });
+        if (completionLogError)
+            throw new Error(`Failed to add completion log: ${completionLogError.message}`);
+    }
+    else if (outcome === "blocked") {
+        updatedStage = currentStage;
+        updatedStatus = "blocked";
+        const blockedMessage = explanationFinal || "Blocked: additional input required.";
+        const { error: blockedLogError } = await supabase
+            .from("task_logs")
+            .insert({ task_id: args.taskId, content: blockedMessage, log_type: "system" });
+        if (blockedLogError)
+            throw new Error(`Failed to add blocked log: ${blockedLogError.message}`);
+    }
+    else {
+        const nextRetryCount = currentRetryCount + 1;
+        if (nextRetryCount <= MAX_RETRIES) {
+            updatedStage = currentStage;
+            updatedStatus = "queued";
+            updatedRetryCount = nextRetryCount;
+            const retryMessage = `Retrying (${nextRetryCount}/${MAX_RETRIES}) for stage ${currentStage}.`;
+            const { error: retryLogError } = await supabase
+                .from("task_logs")
+                .insert({ task_id: args.taskId, content: retryMessage, log_type: "system" });
+            if (retryLogError)
+                throw new Error(`Failed to add retry log: ${retryLogError.message}`);
+        }
+        else {
+            updatedStage = currentStage;
+            updatedStatus = "failed";
+            errorValue = explanationFinal || "Task failed.";
+            const { error: failedLogError } = await supabase
+                .from("task_logs")
+                .insert({ task_id: args.taskId, content: errorValue, log_type: "error" });
+            if (failedLogError)
+                throw new Error(`Failed to add failure log: ${failedLogError.message}`);
+        }
+    }
+    frontmatter.result = finalResult;
+    frontmatter.stage = updatedStage;
+    frontmatter.status = updatedStatus;
+    if (errorValue) {
+        frontmatter.error = errorValue;
+    }
+    else if ("error" in frontmatter) {
+        delete frontmatter.error;
+    }
+    const updatedContent = buildContent(frontmatter, body);
+    const taskUpdatePayload = {
+        content: updatedContent,
+        stage: updatedStage,
+        status: updatedStatus,
+        retry_count: updatedRetryCount,
+        error: errorValue,
+        updated_at: new Date().toISOString(),
+    };
+    let { data: updatedTask, error: updateError } = await supabase
+        .from("tasks")
+        .update({
+        ...taskUpdatePayload,
+        stage_decisions: nextStageDecisions,
+    })
+        .eq("id", args.taskId)
+        .select()
+        .single();
+    if (updateError && isMissingStageDecisionsError(updateError)) {
+        ({ data: updatedTask, error: updateError } = await supabase
+            .from("tasks")
+            .update(taskUpdatePayload)
+            .eq("id", args.taskId)
+            .select()
+            .single());
+    }
+    if (updateError)
+        throw new Error(`Failed to complete stage: ${updateError.message}`);
+    if (finalResult) {
+        const commentContent = finalResult;
+        const { error: commentError } = await supabase
+            .from("task_comments")
+            .insert({ task_id: args.taskId, content: commentContent, author_type: "agent" });
+        if (commentError)
+            throw new Error(`Failed to add agent comment: ${commentError.message}`);
+    }
+    // Fetch stage prompt for new stage (or done)
+    let stagePromptStr;
+    const stageConfig = await fetchStageConfig(supabase, updatedStage, updatedTask.user_id);
+    stagePromptStr = stageConfig?.prompt || undefined;
+    return {
+        task: { ...updatedTask, stage_prompt: stagePromptStr },
+        previousStage: currentStage,
+        newStage: updatedStage,
+        completed: updatedStage === "done" && updatedStatus === "completed",
+    };
+}
+export async function queueFail(args) {
+    const supabase = getSupabase();
+    // Get current task
+    const { data: task, error: getError } = await supabase
+        .from("tasks")
+        .select("*")
+        .eq("id", args.taskId)
+        .single();
+    if (getError) {
+        if (getError.code === "PGRST116") {
+            throw new Error(`Task not found: ${args.taskId}`);
+        }
+        throw new Error(`Failed to get task: ${getError.message}`);
+    }
+    // Add error log
+    const logContent = args.log
+        ? `ERROR: ${args.error}\n\n${args.log}`
+        : `ERROR: ${args.error}`;
+    const { error: logError } = await supabase
+        .from("task_logs")
+        .insert({ task_id: args.taskId, content: logContent });
+    if (logError) {
+        console.error("Failed to add error log:", logError);
+    }
+    // Update task status
+    const { frontmatter, body } = parseFrontmatter(task.content);
+    frontmatter.status = "failed";
+    frontmatter.error = args.error;
+    const updatedContent = buildContent(frontmatter, body);
+    const { data: updatedTask, error: updateError } = await supabase
+        .from("tasks")
+        .update({
+        content: updatedContent,
+        status: "failed",
+        error: args.error,
+        updated_at: new Date().toISOString(),
+    })
+        .eq("id", args.taskId)
+        .select()
+        .single();
+    if (updateError)
+        throw new Error(`Failed to mark task as failed: ${updateError.message}`);
+    return { task: updatedTask };
+}
+//# sourceMappingURL=queue.js.map

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

@@ -0,0 +1,244 @@
+import { z } from "zod";
+import { getSupabase } from "../db.js";
+import { buildTaskContext } from "../task-context.js";
+import { signTask } from "../security.js";
+import { STAGE_ORDER, parseFrontmatter, buildContent, resolveTaskConfig, } from "../types.js";
+// ============ SCHEMAS ============
+export const tasksListSchema = z.object({
+    userId: z.string().uuid().optional().describe("Filter by user ID"),
+    project: z.string().optional().describe("Filter by project name"),
+    status: z.enum(["queued", "in_progress", "blocked", "completed", "failed"])
+        .optional().describe("Filter by status"),
+    stage: z.enum(STAGE_ORDER).optional().describe("Filter by SDLC stage"),
+    limit: z.number().int().min(1).max(100).default(50).describe("Max results"),
+});
+export const tasksGetSchema = z.object({
+    id: z.string().uuid().describe("Task ID"),
+    includeLogs: z.boolean().default(false).describe("Include task logs"),
+});
+export const tasksCreateSchema = z.object({
+    title: z.string().min(1).describe("Task title"),
+    description: z.string().optional().describe("Task description"),
+    project: z.string().optional().describe("Project name"),
+    priority: z.number().int().min(1).max(5).default(3).describe("Priority (1=highest, 5=lowest)"),
+    engine: z.enum(["claude", "gemini", "ollama"]).default("claude").describe("AI engine to use"),
+    provider: z.string().optional().describe("Provider/runtime to use (e.g. cao, claude_code)"),
+    model: z.string().optional().describe("Model to use (e.g. claude-3-5-sonnet)"),
+    swarm: z.boolean().optional().describe("Route task to swarm/CAO runtime"),
+    stage: z.enum(STAGE_ORDER).default("ideation").describe("Initial SDLC stage"),
+    userId: z.string().uuid().optional().describe("Owner user ID"),
+});
+export const tasksUpdateSchema = z.object({
+    id: z.string().uuid().describe("Task ID"),
+    status: z.enum(["queued", "in_progress", "blocked", "completed", "failed"]).optional(),
+    stage: z.enum(STAGE_ORDER).optional(),
+    priority: z.number().int().min(1).max(5).optional(),
+    project: z.string().optional(),
+    progress: z.number().int().min(0).max(100).optional().describe("Progress percentage (0-100)"),
+    result: z.string().optional().describe("Result/output summary"),
+    swarm: z.boolean().optional(),
+});
+export const tasksLogSchema = z.object({
+    taskId: z.string().uuid().describe("Task ID"),
+    content: z.string().min(1).describe("Log content"),
+});
+// ============ HANDLERS ============
+export async function tasksList(args) {
+    const supabase = getSupabase();
+    const activeQueueStatuses = ["queued", "in_progress"];
+    let query = supabase
+        .from("tasks")
+        .select("*")
+        .order("priority", { ascending: true, nullsFirst: false })
+        .order("created_at", { ascending: false })
+        .limit(args.limit);
+    if (args.userId)
+        query = query.eq("user_id", args.userId);
+    if (args.project)
+        query = query.eq("project", args.project);
+    if (args.status)
+        query = query.eq("status", args.status);
+    if (args.stage && !args.status)
+        query = query.in("status", activeQueueStatuses);
+    if (args.stage)
+        query = query.eq("stage", args.stage);
+    const { data, error } = await query;
+    if (error)
+        throw new Error(`Failed to list tasks: ${error.message}`);
+    return {
+        tasks: data || [],
+        count: data?.length || 0,
+    };
+}
+export async function tasksGet(args) {
+    const supabase = getSupabase();
+    const { data: task, error } = await supabase
+        .from("tasks")
+        .select("*")
+        .eq("id", args.id)
+        .single();
+    if (error) {
+        if (error.code === "PGRST116") {
+            throw new Error(`Task not found: ${args.id}`);
+        }
+        throw new Error(`Failed to get task: ${error.message}`);
+    }
+    // Fetch stage prompt
+    const context = await buildTaskContext(task);
+    const { comments_digest: commentsDigest, stage_config } = context;
+    // Resolve configuration (Task > Stage)
+    const resolvedConfig = resolveTaskConfig(task, stage_config);
+    let signature = task.signature;
+    if (task.user_id) {
+        const { data: secretData } = await supabase
+            .from("user_secrets")
+            .select("daemon_secret_hash")
+            .eq("user_id", task.user_id)
+            .single();
+        if (secretData?.daemon_secret_hash) {
+            const newSignature = signTask({
+                id: task.id,
+                user_id: task.user_id,
+                content: task.content,
+                stage: task.stage || "ideation",
+                engine: task.engine || "claude",
+                provider: resolvedConfig.provider,
+                model: resolvedConfig.model,
+                swarm: resolvedConfig.swarm,
+                swarm_models: resolvedConfig.swarm_models,
+                created_at: task.created_at,
+                comments_digest: commentsDigest,
+            }, secretData.daemon_secret_hash);
+            if (newSignature !== signature) {
+                await supabase
+                    .from("tasks")
+                    .update({ signature: newSignature })
+                    .eq("id", task.id);
+            }
+            signature = newSignature;
+        }
+    }
+    const result = {
+        task: { ...task, ...resolvedConfig, signature, ...context },
+    };
+    if (args.includeLogs) {
+        const { data: logs, error: logsError } = await supabase
+            .from("task_logs")
+            .select("*")
+            .eq("task_id", args.id)
+            .order("created_at", { ascending: true });
+        if (logsError) {
+            throw new Error(`Failed to get task logs: ${logsError.message}`);
+        }
+        result.logs = logs || [];
+    }
+    return result;
+}
+export async function tasksCreate(args) {
+    const supabase = getSupabase();
+    // Build markdown content with frontmatter
+    const frontmatter = {
+        status: "queued",
+        stage: args.stage,
+        engine: args.engine,
+        priority: args.priority,
+    };
+    if (args.provider)
+        frontmatter.provider = args.provider;
+    if (args.model)
+        frontmatter.model = args.model;
+    if (typeof args.swarm === "boolean")
+        frontmatter.swarm = args.swarm;
+    if (args.project)
+        frontmatter.project = args.project;
+    const body = `# ${args.title}\n\n${args.description || ""}`;
+    const content = buildContent(frontmatter, body);
+    const { data, error } = await supabase
+        .from("tasks")
+        .insert({
+        content,
+        title: args.title,
+        status: "queued",
+        stage: args.stage,
+        project: args.project,
+        priority: args.priority,
+        engine: args.engine,
+        provider: args.provider,
+        model: args.model,
+        swarm: args.swarm,
+        user_id: args.userId,
+    })
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to create task: ${error.message}`);
+    return { task: data };
+}
+export async function tasksUpdate(args) {
+    const supabase = getSupabase();
+    // Get current task
+    const { data: task, error: getError } = await supabase
+        .from("tasks")
+        .select("*")
+        .eq("id", args.id)
+        .single();
+    if (getError) {
+        if (getError.code === "PGRST116") {
+            throw new Error(`Task not found: ${args.id}`);
+        }
+        throw new Error(`Failed to get task: ${getError.message}`);
+    }
+    // Parse and update frontmatter
+    const { frontmatter, body } = parseFrontmatter(task.content);
+    if (args.status !== undefined)
+        frontmatter.status = args.status;
+    if (args.stage !== undefined)
+        frontmatter.stage = args.stage;
+    if (args.priority !== undefined)
+        frontmatter.priority = args.priority;
+    if (args.project !== undefined)
+        frontmatter.project = args.project;
+    if (args.progress !== undefined)
+        frontmatter.progress = args.progress;
+    if (args.result !== undefined)
+        frontmatter.result = args.result;
+    if (args.swarm !== undefined)
+        frontmatter.swarm = args.swarm;
+    const updatedContent = buildContent(frontmatter, body);
+    // Build update object
+    const updates = {
+        content: updatedContent,
+        updated_at: new Date().toISOString(),
+    };
+    if (args.status !== undefined)
+        updates.status = args.status;
+    if (args.stage !== undefined)
+        updates.stage = args.stage;
+    if (args.priority !== undefined)
+        updates.priority = args.priority;
+    if (args.project !== undefined)
+        updates.project = args.project;
+    if (args.swarm !== undefined)
+        updates.swarm = args.swarm;
+    const { data: updatedTask, error: updateError } = await supabase
+        .from("tasks")
+        .update(updates)
+        .eq("id", args.id)
+        .select()
+        .single();
+    if (updateError)
+        throw new Error(`Failed to update task: ${updateError.message}`);
+    return { task: updatedTask };
+}
+export async function tasksLog(args) {
+    const supabase = getSupabase();
+    const { data, error } = await supabase
+        .from("task_logs")
+        .insert({ task_id: args.taskId, content: args.content })
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to add log: ${error.message}`);
+    return { log: data };
+}
+//# sourceMappingURL=tasks.js.map