@agent-native/core 0.132.1 → 0.133.0

package/corpus/templates/factory/actions/list-triage-items.ts

@@ -0,0 +1,85 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, desc, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageItems, triageDecisions } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { triageItemStatusSchema } from "../server/triage/contracts.js";
+
+export default defineAction({
+  description:
+    "List the Factory observation queue. Results are scoped to the active workspace and include the latest shadow decision summary.",
+  schema: z.object({
+    status: triageItemStatusSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ status, limit }, context) => {
+    const { orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+    const items = await db
+      .select()
+      .from(triageItems)
+      .where(
+        and(
+          eq(triageItems.orgId, orgId),
+          status ? eq(triageItems.status, status) : undefined,
+        ),
+      )
+      .orderBy(desc(triageItems.updatedAt))
+      .limit(limit);
+
+    const decisions = await db
+      .select()
+      .from(triageDecisions)
+      .where(eq(triageDecisions.orgId, orgId))
+      .orderBy(desc(triageDecisions.createdAt))
+      .limit(500);
+    const latestByItem = new Map<string, (typeof decisions)[number]>();
+    for (const decision of decisions) {
+      if (!latestByItem.has(decision.itemId)) {
+        latestByItem.set(decision.itemId, decision);
+      }
+    }
+
+    return items.map((item) => {
+      const latestDecision = latestByItem.get(item.id);
+      return {
+        id: item.id,
+        itemId: item.id,
+        source: item.source,
+        sourceName: item.source,
+        externalId: item.externalId,
+        sourceUrl: item.sourceUrl,
+        title: item.title,
+        summary: item.summary,
+        status: item.status,
+        risk: item.risk,
+        coverage: item.coverage,
+        repository: item.repository,
+        pullRequestNumber: item.pullRequestNumber,
+        headSha: item.headSha,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        reason: latestDecision?.reason ?? null,
+        decisionSummary: latestDecision?.reason ?? null,
+        latestDecision: latestDecision
+          ? {
+              id: latestDecision.id,
+              outcome: latestDecision.outcome,
+              reason: latestDecision.reason,
+              mode: latestDecision.mode,
+              createdAt: latestDecision.createdAt,
+            }
+          : null,
+      };
+    });
+  },
+});

package/corpus/templates/factory/actions/list-triage-rules.ts

@@ -0,0 +1,44 @@
+import { defineAction } from "@agent-native/core/action";
+import { desc, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageRules } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { normalizeTriagePolicyGuards } from "../server/triage/contracts.js";
+
+export default defineAction({
+  description:
+    "List editable Factory rules for the active workspace. Rules are disabled or shadow-only until the owner explicitly promotes them.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (_, context) => {
+    const { orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const rows = await getDb()
+      .select()
+      .from(triageRules)
+      .where(eq(triageRules.orgId, orgId))
+      .orderBy(desc(triageRules.updatedAt));
+    return rows.map((row) => ({
+      ...row,
+      enabled: row.enabled === 1,
+      guards: parseGuards(row.guardsJson),
+    }));
+  },
+});
+
+function parseGuards(value: string) {
+  try {
+    return normalizeTriagePolicyGuards(JSON.parse(value));
+  } catch (error) {
+    throw new Error(
+      `Triage rule guards are unreadable: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

package/corpus/templates/factory/actions/navigate.ts

@@ -0,0 +1,41 @@
+/**
+ * Navigate the UI to a view.
+ *
+ * Writes a navigate command to application state which the UI reads and auto-deletes.
+ *
+ * Usage:
+ *   pnpm action navigate --view=chat
+ *   pnpm action navigate --path=/some/route
+ *
+ * Options:
+ *   --view   View name to navigate to
+ *   --path   URL path to navigate to
+ *   --threadId Chat thread ID to open on the chat route
+ */
+
+import { defineAction } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { z } from "zod";
+
+export default defineAction({
+  description:
+    "Navigate the UI to a specific view or path. Writes a navigate command to application state which the UI reads and auto-deletes.",
+  schema: z.object({
+    view: z.string().optional().describe("View name to navigate to"),
+    path: z.string().optional().describe("URL path to navigate to"),
+    threadId: z.string().optional().describe("Chat thread ID to open"),
+  }),
+  http: false,
+  run: async (args) => {
+    if (!args.view && !args.path) {
+      throw new Error("At least --view or --path is required.");
+    }
+    const nav: Record<string, string> = {};
+    if (args.view) nav.view = args.view;
+    if (args.path) nav.path = args.path;
+    if (args.threadId) nav.threadId = args.threadId;
+    nav._writeId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await writeAppState("navigate", nav);
+    return `Navigating to ${args.view || args.path}`;
+  },
+});

package/corpus/templates/factory/actions/poll-slack-channel.ts

@@ -0,0 +1,118 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageConfig, triageItems } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { itemDedupeKey } from "../server/triage/ids.js";
+import { pollSlackChannel } from "../server/triage/slack-poller.js";
+
+export default defineAction({
+  description:
+    "Poll the configured Slack channel and append new messages to the Factory queue. This action only observes and never posts, replies, starts work, or changes a provider.",
+  schema: z.object({
+    channelId: z.string().trim().min(1).max(128).optional(),
+  }),
+  http: { method: "POST" },
+  run: async ({ channelId: requestedChannelId }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+    const config = (
+      await db
+        .select()
+        .from(triageConfig)
+        .where(eq(triageConfig.id, orgId))
+        .limit(1)
+    )[0];
+    const channelId = requestedChannelId ?? config?.slackChannelId;
+    if (!channelId) {
+      throw new Error("Configure a Slack channel before polling.");
+    }
+
+    const result = await pollSlackChannel({
+      workspace:
+        config?.slackWorkspace === "secondary" ? "secondary" : "primary",
+      channelId,
+      priorLastSlackTs: config?.lastSlackTs ?? "0",
+      historyCursor: config?.slackHistoryCursor,
+      ownerEmail: userEmail,
+      orgId,
+    });
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      for (const envelope of result.envelopes) {
+        const id = itemDedupeKey(envelope, orgId);
+        await tx
+          .insert(triageItems)
+          .values({
+            id,
+            source: envelope.source,
+            externalId: envelope.externalId,
+            sourceUrl: envelope.sourceUrl ?? null,
+            title: envelope.title,
+            summary: envelope.summary ?? null,
+            status: "received",
+            risk: "unknown",
+            channelId: envelope.channelId ?? null,
+            threadTs: envelope.threadTs ?? null,
+            repository: envelope.repository ?? null,
+            pullRequestNumber: envelope.pullRequestNumber ?? null,
+            headSha: envelope.headSha ?? null,
+            coverage: envelope.coverage,
+            dedupeKey: id,
+            metadataJson: JSON.stringify(envelope.metadata ?? {}),
+            lastSeenAt: now,
+            createdAt: now,
+            updatedAt: now,
+            ownerEmail: userEmail,
+            orgId,
+          })
+          .onConflictDoUpdate({
+            target: triageItems.id,
+            set: {
+              sourceUrl: envelope.sourceUrl ?? null,
+              title: envelope.title,
+              summary: envelope.summary ?? null,
+              channelId: envelope.channelId ?? null,
+              threadTs: envelope.threadTs ?? null,
+              coverage: envelope.coverage,
+              metadataJson: JSON.stringify(envelope.metadata ?? {}),
+              lastSeenAt: now,
+              updatedAt: now,
+            },
+          });
+      }
+
+      if (config) {
+        await tx
+          .update(triageConfig)
+          .set({
+            lastSlackTs: result.nextLastSlackTs,
+            slackHistoryCursor: result.nextHistoryCursor,
+            updatedAt: now,
+          })
+          .where(
+            and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)),
+          );
+      }
+    });
+
+    return {
+      ok: true,
+      source: "slack",
+      channelId,
+      observed: result.envelopes.length,
+      hasMore: result.hasMore,
+      nextLastSlackTs: result.nextLastSlackTs,
+      nextHistoryCursor: result.nextHistoryCursor,
+      coverage: result.hasMore ? "partial" : "complete",
+    };
+  },
+});

package/corpus/templates/factory/actions/reconcile-triage-run.ts

@@ -0,0 +1,179 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageItems, triageRuns } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import {
+  executorStateSchema,
+  triageSourceSchema,
+} from "../server/triage/contracts.js";
+import { stableId } from "../server/triage/ids.js";
+import {
+  reconcilePullRequestRun,
+  type PullRequestObservation,
+} from "../server/triage/pr-monitor.js";
+
+const reviewSchema = z.object({
+  author: z.string(),
+  state: z.enum(["approved", "changes_requested", "commented", "pending"]),
+  observedAt: z.string().datetime(),
+});
+const checkSchema = z.object({
+  name: z.string(),
+  state: z.enum(["queued", "in_progress", "passed", "failed", "cancelled"]),
+  observedAt: z.string().datetime(),
+});
+const observationSchema: z.ZodType<PullRequestObservation> = z.object({
+  repo: z.string(),
+  pullRequestNumber: z.number().int().positive(),
+  headSha: z.string(),
+  reviews: z.array(reviewSchema),
+  checks: z.array(checkSchema),
+  observedAt: z.string().datetime(),
+});
+
+export default defineAction({
+  description:
+    "Reconcile an observe-only pull-request monitoring run from ai-services callback and provider observations. Missing callbacks or provider reads remain typed failure states; no executor or GitHub write occurs.",
+  schema: z.object({
+    itemId: z.string().min(1),
+    runId: z.string().min(1),
+    source: triageSourceSchema.default("github"),
+    callback: z
+      .object({
+        state: executorStateSchema,
+        observedAt: z.string().datetime(),
+        terminalReason: z.string().optional(),
+      })
+      .optional(),
+    providerObservation: observationSchema.optional(),
+    heartbeatAt: z.string().datetime().optional(),
+    timeoutMs: z
+      .number()
+      .int()
+      .positive()
+      .default(15 * 60_000),
+  }),
+  http: { method: "POST" },
+  agentTool: false,
+  run: async (
+    {
+      itemId,
+      runId,
+      source,
+      callback,
+      providerObservation,
+      heartbeatAt,
+      timeoutMs,
+    },
+    context,
+  ) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const now = new Date().toISOString();
+    const databaseRunId = stableId("run", orgId, runId);
+    const result = reconcilePullRequestRun({
+      triageItemId: itemId,
+      runId,
+      callback,
+      providerObservation,
+      heartbeatAt,
+      now,
+      timeoutMs,
+    });
+    const db = getDb();
+    const existingRun = (
+      await db
+        .select({ progressLogJson: triageRuns.progressLogJson })
+        .from(triageRuns)
+        .where(
+          and(eq(triageRuns.id, databaseRunId), eq(triageRuns.orgId, orgId)),
+        )
+        .limit(1)
+    )[0];
+    const progressLog = appendProgressLog(existingRun?.progressLogJson, {
+      at: now,
+      state: result.state,
+      reason: result.reason,
+    });
+
+    await db.transaction(async (tx) => {
+      await tx
+        .insert(triageRuns)
+        .values({
+          id: databaseRunId,
+          itemId,
+          source,
+          status: result.state,
+          progressLogJson: JSON.stringify(progressLog),
+          dispatchAttempts: 0,
+          needsContinuation: result.state === "reconciliation_required" ? 1 : 0,
+          startedAt: callback?.observedAt ?? now,
+          heartbeatAt: now,
+          completedAt: result.terminalState ? now : null,
+          error:
+            result.state === "failed" ||
+            result.state === "timed_out" ||
+            result.state === "reconciliation_required"
+              ? result.reason
+              : null,
+          ownerEmail: userEmail,
+          orgId,
+        })
+        .onConflictDoUpdate({
+          target: triageRuns.id,
+          set: {
+            status: result.state,
+            progressLogJson: JSON.stringify(progressLog),
+            needsContinuation:
+              result.state === "reconciliation_required" ? 1 : 0,
+            heartbeatAt: now,
+            completedAt: result.terminalState ? now : null,
+            error:
+              result.state === "failed" ||
+              result.state === "timed_out" ||
+              result.state === "reconciliation_required"
+                ? result.reason
+                : null,
+          },
+        });
+
+      if (result.triageItemPatch) {
+        await tx
+          .update(triageItems)
+          .set(result.triageItemPatch)
+          .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+      } else if (result.state === "reconciliation_required") {
+        await tx
+          .update(triageItems)
+          .set({ status: "reconciliation_required", updatedAt: now })
+          .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+      }
+    });
+
+    return result;
+  },
+});
+
+function appendProgressLog(
+  value: string | undefined,
+  entry: { at: string; state: string; reason: string },
+) {
+  if (!value) return [entry];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("Triage run progress log is unreadable.");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("Triage run progress log is unreadable.");
+  }
+  return [...parsed, entry].slice(-100);
+}

package/corpus/templates/factory/actions/record-triage-feedback.ts

@@ -0,0 +1,58 @@
+import { randomUUID } from "node:crypto";
+
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageDecisions, triageFeedback } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+const verdictSchema = z.enum(["correct", "incorrect", "uncertain"]);
+
+export default defineAction({
+  description:
+    "Record human feedback on a Factory shadow decision. Feedback is append-only and changes no provider or executor state.",
+  schema: z.object({
+    decisionId: z.string().min(1),
+    verdict: verdictSchema,
+    note: z.string().trim().max(2_000).optional(),
+  }),
+  http: { method: "POST" },
+  run: async ({ decisionId, verdict, note }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const decision = (
+      await getDb()
+        .select({ id: triageDecisions.id })
+        .from(triageDecisions)
+        .where(
+          and(
+            eq(triageDecisions.id, decisionId),
+            eq(triageDecisions.orgId, orgId),
+          ),
+        )
+        .limit(1)
+    )[0];
+    if (!decision) throw new Error("Triage decision not found");
+
+    const createdAt = new Date().toISOString();
+    const id = randomUUID();
+    await getDb()
+      .insert(triageFeedback)
+      .values({
+        id,
+        decisionId,
+        verdict,
+        note: note ?? null,
+        createdAt,
+        ownerEmail: userEmail,
+        orgId,
+      });
+    return { ok: true, id };
+  },
+});

package/corpus/templates/factory/actions/run.ts

@@ -0,0 +1,2 @@
+import { runScript } from "@agent-native/core/scripts";
+runScript();

package/corpus/templates/factory/actions/save-factory-graph.ts

@@ -0,0 +1,129 @@
+import { defineAction } from "@agent-native/core/action";
+import { buildDeepLink } from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import {
+  factoryDefinitions,
+  factoryGraphVersions,
+} from "../server/db/schema.js";
+import {
+  factoryGraphSchema,
+  normalizeFactoryGraph,
+} from "../server/factory-graph/contracts.js";
+import {
+  DEFAULT_FACTORY_ID,
+  readFactoryDefinition,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { stableId } from "../server/triage/ids.js";
+
+export default defineAction({
+  description:
+    "Create or update a Factory's versioned visual graph. Use source=ai for an agent-proposed graph and source=manual for a direct editor save. This changes configuration only; it never starts provider work.",
+  schema: z.object({
+    factoryId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(120)
+      .regex(/^[a-z0-9][a-z0-9-]*$/)
+      .default(DEFAULT_FACTORY_ID),
+    name: z.string().trim().min(1).max(120),
+    description: z.string().trim().max(500).default(""),
+    prompt: z.string().trim().max(10_000).default(""),
+    source: z.enum(["manual", "ai", "seed"]).default("manual"),
+    changeSummary: z.string().trim().max(500).default(""),
+    graph: factoryGraphSchema,
+  }),
+  link: ({ result }) => ({
+    url: buildDeepLink({
+      app: "factory",
+      view: "factory",
+      params: { factoryId: result.factoryId },
+    }),
+    label: `Open ${result.name} in Factory`,
+  }),
+  run: async (
+    { factoryId, name, description, prompt, source, changeSummary, graph },
+    context,
+  ) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+    const existing = await readFactoryDefinition(orgId, factoryId);
+    const nextVersion = (existing?.graphVersion ?? 0) + 1;
+    const normalizedGraph = normalizeFactoryGraph({
+      ...graph,
+      version: nextVersion,
+      name,
+      description,
+    });
+    const now = new Date().toISOString();
+    const versionId = stableId(
+      "factory-graph",
+      orgId,
+      factoryId,
+      String(nextVersion),
+    );
+
+    await db.insert(factoryGraphVersions).values({
+      id: versionId,
+      factoryId,
+      version: nextVersion,
+      graphJson: JSON.stringify(normalizedGraph),
+      source,
+      changeSummary,
+      createdAt: now,
+      createdBy: userEmail,
+      ownerEmail: userEmail,
+      orgId,
+    });
+
+    if (existing) {
+      await db
+        .update(factoryDefinitions)
+        .set({
+          name,
+          description,
+          prompt,
+          graphVersion: nextVersion,
+          graphJson: JSON.stringify(normalizedGraph),
+          updatedAt: now,
+          ownerEmail: userEmail,
+        })
+        .where(
+          and(
+            eq(factoryDefinitions.id, factoryId),
+            eq(factoryDefinitions.orgId, orgId),
+          ),
+        );
+    } else {
+      await db.insert(factoryDefinitions).values({
+        id: factoryId,
+        name,
+        description,
+        prompt,
+        graphVersion: nextVersion,
+        graphJson: JSON.stringify(normalizedGraph),
+        createdAt: now,
+        updatedAt: now,
+        ownerEmail: userEmail,
+        orgId,
+      });
+    }
+
+    return {
+      ok: true,
+      factoryId,
+      name,
+      graphVersion: nextVersion,
+      source,
+    };
+  },
+});