@mndrk/agx 2.4.4 → 2.4.6

package/cloud-runtime/standalone/apps/local/lib/db/resolution.ts

@@ -0,0 +1,74 @@
+import { getProjectMemory, getProjectSkills, getProjectVariables } from "./projects";
+import type {
+  ExecutionProvenance,
+  MemoryProvenance,
+  ProjectMemory,
+  ProjectSkill,
+  SkillProvenance,
+} from "./types";
+
+export function resolveSkills(
+  agentSkills: Array<{ file: string; condition?: string }>,
+  projectSkills: ProjectSkill[]
+): SkillProvenance[] {
+  const result: SkillProvenance[] = [];
+  const agentFileNames = new Set<string>();
+
+  for (const skill of agentSkills) {
+    const basename = skill.file.split("/").pop() || skill.file;
+    agentFileNames.add(basename);
+    result.push({ file: skill.file, condition: skill.condition, source: "agent" });
+  }
+
+  for (const skill of projectSkills) {
+    const basename = skill.file.split("/").pop() || skill.file;
+    if (!agentFileNames.has(basename)) {
+      result.push({ file: skill.file, condition: skill.condition ?? undefined, source: "project" });
+    }
+  }
+
+  return result;
+}
+
+export function resolveMemory(
+  agentMemory: Array<{ content: string; id?: string }>,
+  projectMemory: ProjectMemory[]
+): MemoryProvenance[] {
+  const result: MemoryProvenance[] = [];
+
+  for (const mem of projectMemory) {
+    result.push({ content: mem.content, source: "project", id: mem.id });
+  }
+
+  for (const mem of agentMemory) {
+    result.push({ content: mem.content, source: "agent", id: mem.id });
+  }
+
+  return result;
+}
+
+export async function resolveVariables(
+  projectId: string
+): Promise<Array<{ key: string; value: string; source: "project" }>> {
+  const vars = await getProjectVariables(projectId);
+  return vars.map((v) => ({ key: v.key, value: v.value, source: "project" as const }));
+}
+
+export async function buildExecutionProvenance(
+  agentId: string,
+  projectId: string,
+  agentSkills: Array<{ file: string; condition?: string }>,
+  agentMemoryEntries: Array<{ content: string; id?: string }>
+): Promise<ExecutionProvenance> {
+  void agentId;
+  const projectSkills = await getProjectSkills(projectId);
+  const projectMem = await getProjectMemory(projectId);
+  const variables = await resolveVariables(projectId);
+
+  return {
+    skills: resolveSkills(agentSkills, projectSkills),
+    memory: resolveMemory(agentMemoryEntries, projectMem),
+    variables,
+  };
+}
+

package/cloud-runtime/standalone/apps/local/lib/db/shared.ts

@@ -0,0 +1,222 @@
+import { createAdminDbClient } from "../db-adapter";
+import type { SwarmModel, Task } from "./types";
+
+export function isMissingRelationError(error: any, relation: string): boolean {
+  if (!error) return false;
+  const message = typeof error.message === "string" ? error.message : "";
+  return (
+    error.code === "42P01" ||
+    error.code === "PGRST205" ||
+    message.includes(`relation "${relation}" does not exist`) ||
+    message.includes(`Could not find the table 'agx.${relation}'`) ||
+    message.includes(`Could not find the table 'public.${relation}'`)
+  );
+}
+
+export function resolveTaskConfig(
+  task: Task,
+  stageConfig?: {
+    swarm?: boolean;
+    provider?: string;
+    model?: string;
+    swarm_models?: SwarmModel[];
+  },
+  userSettings?: { default_provider?: string | null; models?: Record<string, string> | null } | null
+) {
+  const clean = (v: any): string | null => {
+    if (typeof v !== "string") return null;
+    const t = v.trim();
+    return t ? t : null;
+  };
+
+  let cliDefaultProvider: string | null = null;
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const configPath = path.join(process.env.HOME || "", ".agx", "config.json");
+    const cliConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    cliDefaultProvider = clean(cliConfig?.defaultProvider) || null;
+  } catch {
+    // ~/.agx/config.json not found or unreadable
+  }
+  const globalDefaultProvider = clean(userSettings?.default_provider) || cliDefaultProvider || "claude";
+
+  const provider =
+    clean((task as any).provider) ||
+    clean(stageConfig?.provider) ||
+    globalDefaultProvider;
+
+  const globalDefaultModel = clean(userSettings?.models?.[provider]) || null;
+
+  const model =
+    clean((task as any).model) ||
+    clean(stageConfig?.model) ||
+    globalDefaultModel ||
+    null;
+
+  const swarm = task.swarm ?? stageConfig?.swarm ?? false;
+  const swarm_models = task.swarm_models?.length ? task.swarm_models : (stageConfig?.swarm_models || []);
+
+  return {
+    provider,
+    model,
+    swarm,
+    swarm_models,
+  };
+}
+
+export function slugify(input: string): string {
+  return input
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40) || "task";
+}
+
+export async function generateUniqueSlug(base: string, db: ReturnType<typeof createAdminDbClient>): Promise<string> {
+  let slug = slugify(base);
+  for (let i = 0; i < 5; i++) {
+    const { data, error } = await db
+      .from("tasks")
+      .select("id")
+      .eq("slug", slug)
+      .limit(1);
+    if (error) throw error;
+    if (!data || data.length === 0) return slug;
+    const suffix = Math.random().toString(36).slice(2, 6);
+    slug = `${slugify(base)}-${suffix}`.slice(0, 48);
+  }
+  return `${slugify(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+}
+
+export async function generateUniqueProjectSlug(
+  base: string,
+  userId: string,
+  db: any,
+  excludeProjectId?: string
+): Promise<string> {
+  let slug = slugify(base);
+
+  for (let i = 0; i < 5; i++) {
+    let query = db
+      .from("projects")
+      .select("id")
+      .eq("slug", slug)
+      .eq("user_id", userId);
+    if (excludeProjectId) {
+      query = query.neq("id", excludeProjectId);
+    }
+    const { data, error } = await query.limit(1);
+    if (error) throw error;
+    if (!data || data.length === 0) return slug;
+    const suffix = Math.random().toString(36).slice(2, 6);
+    slug = `${slugify(base)}-${suffix}`.slice(0, 48);
+  }
+
+  return `${slugify(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+}
+
+export function getDbClient(client?: any): any {
+  return client ?? createAdminDbClient();
+}
+
+export function parseDependsOnValue(value: string): string[] {
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return parsed.map((item) => String(item || "").trim()).filter(Boolean);
+    }
+  } catch {
+    // ignore parse errors
+  }
+  return trimmed
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function normalizeDependsOnInput(input?: unknown): string[] {
+  if (!input) return [];
+  let candidates: string[];
+  if (Array.isArray(input)) {
+    candidates = input.map((item) => (typeof item === "string" ? item : item === null || item === undefined ? "" : String(item))).filter(Boolean);
+  } else if (typeof input === "string") {
+    candidates = parseDependsOnValue(input);
+  } else {
+    return [];
+  }
+  return Array.from(new Set(candidates.map((id) => id.trim()).filter(Boolean)));
+}
+
+export function parseFrontmatter(markdown: string): { frontmatter: Record<string, unknown>; body: string } {
+  const match = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: markdown };
+  }
+
+  const frontmatter: Record<string, unknown> = {};
+  const lines = match[1].split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      if (key === "depends_on") {
+        frontmatter[key] = parseDependsOnValue(value);
+        continue;
+      }
+      if (value === "true") frontmatter[key] = true;
+      else if (value === "false") frontmatter[key] = false;
+      else if (/^\d+$/.test(value)) frontmatter[key] = parseInt(value, 10);
+      else frontmatter[key] = value;
+    }
+  }
+
+  return { frontmatter, body: match[2] };
+}
+
+export async function ensureNoCircularDependency(
+  taskId: string,
+  dependsOn: string[],
+  client?: any
+): Promise<void> {
+  if (!taskId || !dependsOn?.length) return;
+  const db = getDbClient(client);
+  const visited = new Set<string>();
+  const stack = [...dependsOn];
+
+  while (stack.length) {
+    const candidate = stack.pop();
+    if (!candidate) continue;
+    if (candidate === taskId) {
+      throw new Error("Circular dependency detected");
+    }
+    if (visited.has(candidate)) continue;
+    visited.add(candidate);
+    const { data, error } = await db
+      .from("tasks")
+      .select("depends_on")
+      .eq("id", candidate)
+      .maybeSingle();
+    if (error) {
+      if (error.code === "PGRST116" || error.code === "42703") continue;
+      throw error;
+    }
+    if (!data) continue;
+    const childDeps = Array.isArray(data.depends_on) ? data.depends_on : [];
+    for (const next of childDeps) {
+      if (next && !visited.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+}
+
+export function extractTitle(markdown: string): string | undefined {
+  const { body } = parseFrontmatter(markdown);
+  const match = body.match(/^#\s+(.+)$/m);
+  return match ? match[1] : undefined;
+}
+

package/cloud-runtime/standalone/apps/local/lib/db/task-comments.ts

@@ -0,0 +1,61 @@
+import { createAdminDbClient } from "../db-adapter";
+import type { TaskComment } from "./types";
+
+export async function getTaskComments(taskId: string): Promise<TaskComment[]> {
+  const db = createAdminDbClient();
+
+  const { data, error } = await db
+    .from("task_comments")
+    .select("*")
+    .eq("task_id", taskId)
+    .is("deleted_at", null)
+    .order("created_at", { ascending: true })
+    .order("id", { ascending: true });
+
+  if (error) throw error;
+  return data || [];
+}
+
+export async function addTaskComment(
+  taskId: string,
+  content: string,
+  authorType: "user" | "agent",
+  authorId?: string
+): Promise<TaskComment> {
+  const db = createAdminDbClient();
+
+  const { data, error } = await db
+    .from("task_comments")
+    .insert({ task_id: taskId, content, author_type: authorType, author_id: authorId ?? null })
+    .select()
+    .single();
+
+  if (error) throw error;
+  return data;
+}
+
+export async function deleteTaskComment(commentId: string, userId: string): Promise<void> {
+  const db = createAdminDbClient();
+
+  const { data: comment, error: fetchError } = await db
+    .from("task_comments")
+    .select("author_id, author_type")
+    .eq("id", commentId)
+    .single();
+
+  if (fetchError) throw fetchError;
+  if (!comment) throw new Error("Comment not found");
+
+  if (comment.author_type !== "user" || comment.author_id !== userId) {
+    throw new Error("Unauthorized");
+  }
+
+  const { error } = await db
+    .from("task_comments")
+    .update({ deleted_at: new Date().toISOString() })
+    .eq("id", commentId)
+    .is("deleted_at", null);
+
+  if (error) throw error;
+}
+

package/cloud-runtime/standalone/apps/local/lib/db/task-costs.ts

@@ -0,0 +1,131 @@
+import { createAdminDbClient } from "../db-adapter";
+
+export interface TaskCostEntry {
+  id: string;
+  task_id: string;
+  stage: string;
+  provider: string | null;
+  model: string | null;
+  input_tokens: number;
+  output_tokens: number;
+  estimated_cost: string | null;
+  created_at: string;
+}
+
+export interface TaskCostStageSummary {
+  stage: string;
+  input_tokens: number;
+  output_tokens: number;
+  estimated_cost: number;
+  entries: number;
+}
+
+export interface TaskCostSummary {
+  total_input_tokens: number;
+  total_output_tokens: number;
+  total_cost: number;
+  per_stage: TaskCostStageSummary[];
+}
+
+function normalizeTokenCount(value: number | string | undefined): number {
+  const parsed = Number(value ?? 0);
+  if (!Number.isFinite(parsed)) return 0;
+  return Math.max(0, Math.round(parsed));
+}
+
+function normalizeCostValue(value: number | string | undefined): number {
+  const parsed = Number(value ?? 0);
+  if (!Number.isFinite(parsed)) return 0;
+  return Math.max(0, parsed);
+}
+
+export async function addTaskCostEntry(input: {
+  taskId: string;
+  stage: string;
+  provider?: string | null;
+  model?: string | null;
+  inputTokens?: number;
+  outputTokens?: number;
+  estimatedCost?: number;
+}): Promise<TaskCostEntry> {
+  const db = createAdminDbClient();
+
+  const payload = {
+    task_id: input.taskId,
+    stage: input.stage,
+    provider: input.provider ?? null,
+    model: input.model ?? null,
+    input_tokens: normalizeTokenCount(input.inputTokens),
+    output_tokens: normalizeTokenCount(input.outputTokens),
+    estimated_cost: normalizeCostValue(input.estimatedCost),
+  };
+
+  const { data, error } = await db
+    .from("task_costs")
+    .insert(payload)
+    .select()
+    .single();
+
+  if (error) throw error;
+  return data;
+}
+
+export async function getTaskCostEntries(taskId: string): Promise<TaskCostEntry[]> {
+  const db = createAdminDbClient();
+
+  const { data, error } = await db
+    .from("task_costs")
+    .select("*")
+    .eq("task_id", taskId)
+    .order("created_at", { ascending: true });
+
+  if (error) throw error;
+  return data || [];
+}
+
+export function summarizeTaskCosts(entries: TaskCostEntry[]): TaskCostSummary {
+  const stageMap: Record<string, TaskCostStageSummary> = {};
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCost = 0;
+
+  for (const entry of entries) {
+    const stageKey = entry.stage || "unknown";
+    const input = normalizeTokenCount(entry.input_tokens);
+    const output = normalizeTokenCount(entry.output_tokens);
+    const cost = normalizeCostValue(entry.estimated_cost ?? 0);
+
+    totalInput += input;
+    totalOutput += output;
+    totalCost += cost;
+
+    const existing = stageMap[stageKey] || {
+      stage: stageKey,
+      input_tokens: 0,
+      output_tokens: 0,
+      estimated_cost: 0,
+      entries: 0,
+    };
+
+    existing.input_tokens += input;
+    existing.output_tokens += output;
+    existing.estimated_cost += cost;
+    existing.entries += 1;
+    stageMap[stageKey] = existing;
+  }
+
+  const perStage = Object.values(stageMap).sort((a, b) => a.stage.localeCompare(b.stage));
+
+  return {
+    total_input_tokens: totalInput,
+    total_output_tokens: totalOutput,
+    total_cost: totalCost,
+    per_stage: perStage,
+  };
+}
+
+export async function getTaskCostSummary(taskId: string): Promise<TaskCostSummary> {
+  const entries = await getTaskCostEntries(taskId);
+  return summarizeTaskCosts(entries);
+}
+

package/cloud-runtime/standalone/apps/local/lib/db/task-logs.ts

@@ -0,0 +1,62 @@
+import { createAdminDbClient } from "../db-adapter";
+import type { TaskLog } from "./types";
+
+export async function getTaskLogs(
+  taskId: string,
+  options: { limit?: number; tail?: number; after?: string; nodeId?: string } = {}
+): Promise<TaskLog[]> {
+  const db = createAdminDbClient();
+
+  const limit = Math.max(1, Math.min(2000, Number(options.limit ?? options.tail ?? 500)));
+  const after = typeof options.after === "string" && options.after.trim() ? options.after.trim() : null;
+  const tail = after ? null : (options.tail === undefined ? limit : Number(options.tail));
+  const useTail = tail !== null && Number.isFinite(tail) && tail > 0;
+
+  let query = db
+    .from("task_logs")
+    .select("*")
+    .eq("task_id", taskId);
+
+  if (options.nodeId) {
+    query = query.eq("node_id", options.nodeId);
+  }
+
+  if (after) {
+    query = query
+      .gt("created_at", after)
+      .order("created_at", { ascending: true })
+      .order("id", { ascending: true })
+      .limit(limit);
+  } else if (useTail) {
+    query = query
+      .order("created_at", { ascending: false })
+      .order("id", { ascending: false })
+      .limit(limit);
+  } else {
+    query = query
+      .order("created_at", { ascending: true })
+      .order("id", { ascending: true })
+      .limit(limit);
+  }
+
+  const { data, error } = await query;
+  if (error) throw error;
+  const rows = data || [];
+  if (after) return rows;
+  if (useTail) return rows.slice().reverse();
+  return rows;
+}
+
+export async function addTaskLog(taskId: string, content: string, logType?: string, nodeId?: string): Promise<TaskLog> {
+  const db = createAdminDbClient();
+
+  const { data, error } = await db
+    .from("task_logs")
+    .insert({ task_id: taskId, content, log_type: logType, ...(nodeId ? { node_id: nodeId } : {}) })
+    .select()
+    .single();
+
+  if (error) throw error;
+  return data;
+}
+