@agent-native/core 0.132.2 → 0.133.0

package/corpus/templates/factory/actions/save-triage-config.ts

@@ -0,0 +1,67 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { triageConfig } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+const workspaceSchema = z.enum(["primary", "secondary"]);
+
+export default defineAction({
+  description:
+    "Save Factory observation settings. This controls read-only Slack polling and repository metadata; it never starts an executor or changes a provider.",
+  schema: z.object({
+    slackWorkspace: workspaceSchema.default("primary"),
+    slackChannelId: z.string().trim().min(1).max(128).optional(),
+    slackChannelName: z.string().trim().max(200).optional(),
+    pollingEnabled: z.boolean().default(false),
+    repository: z.string().trim().max(256).optional(),
+  }),
+  http: { method: "POST" },
+  run: async (
+    {
+      slackWorkspace,
+      slackChannelId,
+      slackChannelName,
+      pollingEnabled,
+      repository,
+    },
+    context,
+  ) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const now = new Date().toISOString();
+    const db = getDb();
+    await db
+      .insert(triageConfig)
+      .values({
+        id: orgId,
+        slackWorkspace,
+        slackChannelId: slackChannelId ?? null,
+        slackChannelName: slackChannelName ?? null,
+        pollingEnabled: pollingEnabled ? 1 : 0,
+        repository: repository ?? null,
+        createdAt: now,
+        updatedAt: now,
+        ownerEmail: userEmail,
+        orgId,
+      })
+      .onConflictDoUpdate({
+        target: triageConfig.id,
+        set: {
+          slackWorkspace,
+          slackChannelId: slackChannelId ?? null,
+          slackChannelName: slackChannelName ?? null,
+          pollingEnabled: pollingEnabled ? 1 : 0,
+          repository: repository ?? null,
+          updatedAt: now,
+          ownerEmail: userEmail,
+        },
+      });
+    return { ok: true, pollingEnabled, slackChannelId: slackChannelId ?? null };
+  },
+});

package/corpus/templates/factory/actions/save-triage-rule.ts

@@ -0,0 +1,89 @@
+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 { triageRules } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import {
+  defaultTriagePolicyGuards,
+  normalizeTriagePolicyGuards,
+  triagePolicyGuardsSchema,
+  triageRuleModeSchema,
+} from "../server/triage/contracts.js";
+import { stableId } from "../server/triage/ids.js";
+
+export default defineAction({
+  description:
+    "Create or update a Factory rule. Disabled and shadow modes are accepted; execution still requires an explicit approval action.",
+  schema: z.object({
+    id: z.string().min(1).optional(),
+    name: z.string().trim().min(1).max(120),
+    description: z.string().trim().max(500).default(""),
+    promptText: z.string().trim().min(1).max(10_000),
+    mode: triageRuleModeSchema.default("shadow"),
+    enabled: z.boolean().default(true),
+    guards: triagePolicyGuardsSchema.optional(),
+  }),
+  http: { method: "POST" },
+  run: async (
+    { id, name, description, promptText, mode, enabled, guards },
+    context,
+  ) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const now = new Date().toISOString();
+    const ruleId = id ?? stableId("rule", orgId, name);
+    const existing = (
+      await getDb()
+        .select({ promptVersion: triageRules.promptVersion })
+        .from(triageRules)
+        .where(and(eq(triageRules.id, ruleId), eq(triageRules.orgId, orgId)))
+        .limit(1)
+    )[0];
+    if (id && !existing) {
+      throw new Error("Triage rule not found in the active workspace.");
+    }
+    const nextPromptVersion = (existing?.promptVersion ?? 0) + 1;
+    const policy = normalizeTriagePolicyGuards(
+      guards ?? defaultTriagePolicyGuards(),
+    );
+
+    await getDb()
+      .insert(triageRules)
+      .values({
+        id: ruleId,
+        name,
+        description,
+        promptText,
+        mode,
+        enabled: enabled ? 1 : 0,
+        guardsJson: JSON.stringify(policy),
+        promptVersion: nextPromptVersion,
+        createdAt: now,
+        updatedAt: now,
+        ownerEmail: userEmail,
+        orgId,
+      })
+      .onConflictDoUpdate({
+        target: triageRules.id,
+        set: {
+          name,
+          description,
+          promptText,
+          mode,
+          enabled: enabled ? 1 : 0,
+          guardsJson: JSON.stringify(policy),
+          promptVersion: nextPromptVersion,
+          updatedAt: now,
+          ownerEmail: userEmail,
+        },
+      });
+
+    return { ok: true, id: ruleId, mode, promptVersion: nextPromptVersion };
+  },
+});

package/corpus/templates/factory/actions/suggest-factory-rules.ts

@@ -0,0 +1,70 @@
+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 { triageDecisions, triageFeedback } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "Mine human feedback on Factory decisions into inspectable rule proposals. This never edits a rule or enables execution.",
+  schema: z.object({
+    limit: z.coerce.number().int().min(1).max(50).default(10),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ limit }, context) => {
+    const { orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+    const decisions = await db
+      .select()
+      .from(triageDecisions)
+      .where(eq(triageDecisions.orgId, orgId))
+      .orderBy(desc(triageDecisions.createdAt))
+      .limit(500);
+    const feedback = await db
+      .select()
+      .from(triageFeedback)
+      .where(eq(triageFeedback.orgId, orgId))
+      .orderBy(desc(triageFeedback.createdAt))
+      .limit(500);
+    const decisionsById = new Map(
+      decisions.map((decision) => [decision.id, decision]),
+    );
+    const groups = new Map<
+      string,
+      { notes: string[]; correct: number; incorrect: number; uncertain: number }
+    >();
+    for (const entry of feedback) {
+      const decision = decisionsById.get(entry.decisionId);
+      if (!decision) continue;
+      const key = `${decision.ruleId ?? "unscoped"}:${decision.outcome}`;
+      const group = groups.get(key) ?? {
+        notes: [],
+        correct: 0,
+        incorrect: 0,
+        uncertain: 0,
+      };
+      if (entry.verdict === "correct") group.correct += 1;
+      if (entry.verdict === "incorrect") group.incorrect += 1;
+      if (entry.verdict === "uncertain") group.uncertain += 1;
+      if (entry.note?.trim()) group.notes.push(entry.note.trim());
+      groups.set(key, group);
+    }
+    return [...groups.entries()].slice(0, limit).map(([key, value]) => ({
+      proposalKey: key,
+      recommendation:
+        value.incorrect > value.correct
+          ? "Review the rule prompt and tighten its guards before enabling it."
+          : "Keep collecting feedback; this rule is not yet decisively wrong.",
+      feedback: value,
+      mode: "shadow",
+    }));
+  },
+});

package/corpus/templates/factory/actions/view-screen.ts

@@ -0,0 +1,73 @@
+/**
+ * See what the user is currently looking at on screen.
+ *
+ * Reads and returns the current navigation state from application state.
+ *
+ * Usage:
+ *   pnpm action view-screen
+ */
+
+import { defineAction } from "@agent-native/core/action";
+import { readAppState } from "@agent-native/core/application-state";
+import { z } from "zod";
+
+import {
+  defaultFactoryDefinition,
+  DEFAULT_FACTORY_ID,
+  parseFactoryGraph,
+  readFactoryDefinition,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "See what the user is currently looking at on screen. Returns the current navigation state for chat or Factory. Always call this first when the visible selection matters.",
+  schema: z.object({}),
+  http: false,
+  readOnly: true,
+  run: async (_, context) => {
+    const navigation = await readAppState("navigation");
+
+    const screen: Record<string, unknown> = {};
+    if (navigation) screen.navigation = navigation;
+
+    if (
+      navigation &&
+      typeof navigation === "object" &&
+      "view" in navigation &&
+      navigation.view === "factory"
+    ) {
+      const { orgId } = await requireWorkspaceMember(
+        workspaceMemberIdentityFromContext(context),
+      );
+      const state = navigation as Record<string, unknown>;
+      const factoryId =
+        typeof state.factoryId === "string" && state.factoryId.trim()
+          ? state.factoryId
+          : DEFAULT_FACTORY_ID;
+      const row = await readFactoryDefinition(orgId, factoryId);
+      const fallback = defaultFactoryDefinition();
+      const graph = row ? parseFactoryGraph(row.graphJson) : fallback.graph;
+      const selectedNodeId =
+        typeof state.factoryNodeId === "string" ? state.factoryNodeId : null;
+      const selectedEdgeId =
+        typeof state.factoryEdgeId === "string" ? state.factoryEdgeId : null;
+
+      screen.factory = {
+        id: factoryId,
+        name: row?.name ?? fallback.name,
+        graphVersion: row?.graphVersion ?? graph.version,
+        selectedNode: graph.nodes.find((node) => node.id === selectedNodeId),
+        selectedEdge: graph.edges.find((edge) => edge.id === selectedEdgeId),
+      };
+    }
+
+    if (Object.keys(screen).length === 0) {
+      return "No application state found. Is the app running?";
+    }
+    return screen;
+  },
+});