@agent-native/core 0.132.2 → 0.133.0

package/corpus/templates/factory/server/connectors/slack.ts

@@ -0,0 +1,129 @@
+export type Workspace = "primary" | "secondary";
+
+export type SlackTokenResolver = (workspace: Workspace) => Promise<string>;
+
+export interface SlackMessage {
+  type: string;
+  user?: string;
+  bot_id?: string;
+  username?: string;
+  text: string;
+  ts: string;
+  thread_ts?: string;
+  reply_count?: number;
+  permalink?: string;
+}
+
+export interface SlackTeamInfo {
+  id: string;
+  name: string;
+  domain: string;
+}
+
+export interface ChannelHistoryResult {
+  messages: SlackMessage[];
+  has_more: boolean;
+  next_cursor?: string;
+}
+
+const cache = new Map<string, { value: unknown; expiresAt: number }>();
+const cacheTtlMs = 120_000;
+
+async function getToken(
+  workspace: Workspace,
+  tokenResolver?: SlackTokenResolver,
+): Promise<string> {
+  if (tokenResolver) return tokenResolver(workspace);
+  throw new Error(
+    `A workspace Slack credential resolver is required for the ${workspace} connection.`,
+  );
+}
+
+async function slackApi<T>(
+  workspace: Workspace,
+  method: string,
+  params: Record<string, string> | undefined,
+  tokenResolver?: SlackTokenResolver,
+): Promise<T> {
+  const cacheKey = `${workspace}:${method}:${JSON.stringify(params ?? {})}`;
+  const cached = cache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) return cached.value as T;
+  const token = await getToken(workspace, tokenResolver);
+  const url = new URL(`https://slack.com/api/${method}`);
+  for (const [key, value] of Object.entries(params ?? {}))
+    url.searchParams.set(key, value);
+  const response = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!response.ok)
+    throw new Error(
+      `Slack API error ${response.status}: ${await response.text()}`,
+    );
+  const data = (await response.json()) as T & { ok?: boolean; error?: string };
+  if (data.ok === false)
+    throw new Error(`Slack API error: ${data.error ?? "unknown_error"}`);
+  cache.set(cacheKey, { value: data, expiresAt: Date.now() + cacheTtlMs });
+  return data;
+}
+
+export async function getChannelHistory(
+  workspace: Workspace,
+  channelId: string,
+  limit = 100,
+  cursor?: string,
+  tokenResolver?: SlackTokenResolver,
+): Promise<ChannelHistoryResult> {
+  const params: Record<string, string> = {
+    channel: channelId,
+    limit: String(Math.min(limit, 200)),
+  };
+  if (cursor) params.latest = cursor;
+  try {
+    const data = await slackApi<{
+      messages?: SlackMessage[];
+      has_more?: boolean;
+    }>(workspace, "conversations.history", params, tokenResolver);
+    const messages = data.messages ?? [];
+    return {
+      messages,
+      has_more: Boolean(data.has_more),
+      next_cursor: messages[messages.length - 1]?.ts,
+    };
+  } catch (error) {
+    if (!String(error).includes("not_in_channel")) throw error;
+    const token = await getToken(workspace, tokenResolver);
+    const joined = await fetch("https://slack.com/api/conversations.join", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ channel: channelId }),
+    });
+    const joinedData = (await joined.json()) as { ok?: boolean };
+    if (!joinedData.ok) throw error;
+    const data = await slackApi<{
+      messages?: SlackMessage[];
+      has_more?: boolean;
+    }>(workspace, "conversations.history", params, tokenResolver);
+    const messages = data.messages ?? [];
+    return {
+      messages,
+      has_more: Boolean(data.has_more),
+      next_cursor: messages[messages.length - 1]?.ts,
+    };
+  }
+}
+
+export async function getTeamInfo(
+  workspace: Workspace,
+  tokenResolver?: SlackTokenResolver,
+): Promise<SlackTeamInfo> {
+  const data = await slackApi<{ team?: SlackTeamInfo; team_id?: string }>(
+    workspace,
+    "team.info",
+    undefined,
+    tokenResolver,
+  );
+  return data.team ?? { id: data.team_id ?? "", name: workspace, domain: "" };
+}

package/corpus/templates/factory/server/db/index.ts

@@ -0,0 +1,6 @@
+import { createGetDb } from "@agent-native/core/db";
+
+import * as schema from "./schema.js";
+
+export const getDb = createGetDb(schema);
+export { schema };

package/corpus/templates/factory/server/db/schema.ts

@@ -0,0 +1,193 @@
+import {
+  index,
+  integer,
+  now,
+  table,
+  text,
+  uniqueIndex,
+} from "@agent-native/core/db/schema";
+
+export const triageItems = table(
+  "factory_items",
+  {
+    id: text("id").primaryKey(),
+    source: text("source").notNull(),
+    externalId: text("external_id").notNull(),
+    sourceUrl: text("source_url"),
+    title: text("title").notNull(),
+    summary: text("summary"),
+    status: text("status").notNull().default("received"),
+    risk: text("risk").notNull().default("unknown"),
+    channelId: text("channel_id"),
+    threadTs: text("thread_ts"),
+    repository: text("repository"),
+    pullRequestNumber: integer("pull_request_number"),
+    headSha: text("head_sha"),
+    coverage: text("coverage").notNull().default("unknown"),
+    dedupeKey: text("dedupe_key").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    lastSeenAt: text("last_seen_at"),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+  },
+  (item) => ({
+    orgDedupeUnique: uniqueIndex("factory_items_org_dedupe_idx").on(
+      item.orgId,
+      item.dedupeKey,
+    ),
+    orgStatusIdx: index("factory_items_org_status_idx").on(
+      item.orgId,
+      item.status,
+      item.updatedAt,
+    ),
+  }),
+);
+
+export const triageRules = table("factory_rules", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  description: text("description").notNull(),
+  promptText: text("prompt_text").notNull(),
+  mode: text("mode").notNull().default("shadow"),
+  enabled: integer("enabled").notNull().default(1),
+  guardsJson: text("guards_json").notNull().default("{}"),
+  promptVersion: integer("prompt_version").notNull().default(1),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+});
+
+export const triageDecisions = table("factory_decisions", {
+  id: text("id").primaryKey(),
+  itemId: text("item_id").notNull(),
+  ruleId: text("rule_id"),
+  mode: text("mode").notNull().default("shadow"),
+  outcome: text("outcome").notNull(),
+  reason: text("reason").notNull(),
+  guardResultsJson: text("guard_results_json").notNull().default("[]"),
+  model: text("model"),
+  promptVersion: integer("prompt_version"),
+  createdAt: text("created_at").notNull().default(now()),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+});
+
+export const triageRuns = table("factory_runs", {
+  id: text("id").primaryKey(),
+  itemId: text("item_id").notNull(),
+  source: text("source").notNull(),
+  provider: text("provider"),
+  providerTaskId: text("provider_task_id"),
+  dedupeKey: text("dedupe_key"),
+  approvalEmail: text("approval_email"),
+  status: text("status").notNull().default("received"),
+  progressLogJson: text("progress_log_json").notNull().default("[]"),
+  dispatchAttempts: integer("dispatch_attempts").notNull().default(0),
+  needsContinuation: integer("needs_continuation").notNull().default(0),
+  startedAt: text("started_at").notNull().default(now()),
+  heartbeatAt: text("heartbeat_at"),
+  completedAt: text("completed_at"),
+  error: text("error"),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+});
+
+export const triageFeedback = table("factory_feedback", {
+  id: text("id").primaryKey(),
+  decisionId: text("decision_id").notNull(),
+  verdict: text("verdict").notNull(),
+  note: text("note"),
+  createdAt: text("created_at").notNull().default(now()),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+});
+
+export const triageConfig = table("factory_config", {
+  id: text("id").primaryKey(),
+  slackWorkspace: text("slack_workspace").notNull().default("primary"),
+  slackChannelId: text("slack_channel_id"),
+  slackChannelName: text("slack_channel_name"),
+  pollingEnabled: integer("polling_enabled").notNull().default(0),
+  lastSlackTs: text("last_slack_ts"),
+  slackHistoryCursor: text("slack_history_cursor"),
+  repository: text("repository"),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+});
+
+export const factoryDefinitions = table(
+  "factory_definitions",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    prompt: text("prompt").notNull().default(""),
+    graphVersion: integer("graph_version").notNull().default(1),
+    graphJson: text("graph_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+  },
+  (factory) => ({
+    orgUpdatedIdx: index("factory_definitions_org_updated_idx").on(
+      factory.orgId,
+      factory.updatedAt,
+    ),
+  }),
+);
+
+export const factoryGraphVersions = table(
+  "factory_graph_versions",
+  {
+    id: text("id").primaryKey(),
+    factoryId: text("factory_id").notNull(),
+    version: integer("version").notNull(),
+    graphJson: text("graph_json").notNull(),
+    source: text("source").notNull().default("manual"),
+    changeSummary: text("change_summary").notNull().default(""),
+    createdAt: text("created_at").notNull().default(now()),
+    createdBy: text("created_by").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+  },
+  (version) => ({
+    factoryVersionUnique: uniqueIndex("factory_graph_versions_unique_idx").on(
+      version.orgId,
+      version.factoryId,
+      version.version,
+    ),
+    factoryCreatedIdx: index("factory_graph_versions_created_idx").on(
+      version.orgId,
+      version.factoryId,
+      version.createdAt,
+    ),
+  }),
+);
+
+export const factoryComments = table(
+  "factory_comments",
+  {
+    id: text("id").primaryKey(),
+    factoryId: text("factory_id").notNull(),
+    graphVersion: integer("graph_version").notNull(),
+    targetType: text("target_type").notNull().default("canvas"),
+    targetId: text("target_id"),
+    body: text("body").notNull(),
+    createdAt: text("created_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+  },
+  (comment) => ({
+    factoryCreatedIdx: index("factory_comments_created_idx").on(
+      comment.orgId,
+      comment.factoryId,
+      comment.createdAt,
+    ),
+  }),
+);

package/corpus/templates/factory/server/factory-graph/contracts.ts

@@ -0,0 +1,212 @@
+import { z } from "zod";
+
+export const factoryNodeKindSchema = z.enum([
+  "source",
+  "transform",
+  "decision",
+  "gate",
+  "agent",
+  "system",
+  "terminal",
+]);
+export type FactoryNodeKind = z.infer<typeof factoryNodeKindSchema>;
+
+export const factoryProviderSchema = z.enum([
+  "slack",
+  "github",
+  "builder",
+  "claude",
+  "codex",
+  "human",
+  "factory",
+]);
+export type FactoryProvider = z.infer<typeof factoryProviderSchema>;
+
+export const factoryGraphNodeSchema = z.object({
+  id: z.string().min(1).max(120),
+  label: z.string().trim().min(1).max(120),
+  description: z.string().trim().max(500).default(""),
+  kind: factoryNodeKindSchema,
+  provider: factoryProviderSchema.optional(),
+  agent: z.string().trim().max(120).optional(),
+  metricsKey: z.string().trim().max(120).optional(),
+  position: z.object({
+    x: z.number().finite().min(0).max(4000),
+    y: z.number().finite().min(0).max(2400),
+  }),
+});
+export type FactoryGraphNode = z.infer<typeof factoryGraphNodeSchema>;
+
+export const factoryGraphEdgeSchema = z.object({
+  id: z.string().min(1).max(120),
+  source: z.string().min(1).max(120),
+  target: z.string().min(1).max(120),
+  label: z.string().trim().max(160).default(""),
+  condition: z.string().trim().max(500).default(""),
+});
+export type FactoryGraphEdge = z.infer<typeof factoryGraphEdgeSchema>;
+
+export const factoryGraphSchema = z.object({
+  version: z.number().int().positive(),
+  name: z.string().trim().min(1).max(120),
+  description: z.string().trim().max(500).default(""),
+  executionMode: z.literal("blueprint").default("blueprint"),
+  nodes: z.array(factoryGraphNodeSchema).max(100),
+  edges: z.array(factoryGraphEdgeSchema).max(200),
+});
+export type FactoryGraph = z.infer<typeof factoryGraphSchema>;
+
+export function normalizeFactoryGraph(value: unknown): FactoryGraph {
+  const graph = factoryGraphSchema.parse(value);
+  const nodeIds = new Set<string>();
+  for (const node of graph.nodes) {
+    if (nodeIds.has(node.id)) {
+      throw new Error(`Factory graph contains duplicate node id: ${node.id}`);
+    }
+    nodeIds.add(node.id);
+  }
+
+  const edgeIds = new Set<string>();
+  for (const edge of graph.edges) {
+    if (edgeIds.has(edge.id)) {
+      throw new Error(`Factory graph contains duplicate edge id: ${edge.id}`);
+    }
+    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+      throw new Error(
+        `Factory graph edge ${edge.id} references a missing node.`,
+      );
+    }
+    if (edge.source === edge.target) {
+      throw new Error(`Factory graph edge ${edge.id} cannot self-reference.`);
+    }
+    edgeIds.add(edge.id);
+  }
+
+  return {
+    ...graph,
+    nodes: graph.nodes.map((node) => ({ ...node })),
+    edges: graph.edges.map((edge) => ({ ...edge })),
+  };
+}
+
+export function defaultFactoryGraph(): FactoryGraph {
+  return {
+    version: 1,
+    name: "Product feedback to shipped change",
+    description:
+      "Observe product signals, classify them safely, and keep a human in the loop before work starts.",
+    executionMode: "blueprint",
+    nodes: [
+      {
+        id: "slack-feedback",
+        label: "Product feedback",
+        description: "Watch the configured feedback channel.",
+        kind: "source",
+        provider: "slack",
+        metricsKey: "slack",
+        position: { x: 48, y: 170 },
+      },
+      {
+        id: "github-evidence",
+        label: "Pull request evidence",
+        description: "Read PR metadata, checks, and review state.",
+        kind: "source",
+        provider: "github",
+        metricsKey: "github",
+        position: { x: 48, y: 420 },
+      },
+      {
+        id: "normalize-context",
+        label: "Normalize context",
+        description: "Deduplicate and preserve source links and coverage.",
+        kind: "transform",
+        provider: "factory",
+        metricsKey: "items",
+        position: { x: 310, y: 290 },
+      },
+      {
+        id: "ai-triage",
+        label: "Enabled rules (parallel)",
+        description:
+          "Evaluate each enabled rule against the same evidence with structured guards.",
+        kind: "decision",
+        provider: "factory",
+        agent: "Factory agent",
+        metricsKey: "decisions",
+        position: { x: 570, y: 290 },
+      },
+      {
+        id: "human-gate",
+        label: "Human review",
+        description: "Review shadow decisions and approve a bounded run.",
+        kind: "gate",
+        provider: "human",
+        metricsKey: "needs_manual",
+        position: { x: 830, y: 155 },
+      },
+      {
+        id: "builder-agent",
+        label: "Approved coding run",
+        description: "Start approved work through the configured executor.",
+        kind: "agent",
+        provider: "builder",
+        agent: "Builder",
+        metricsKey: "runs",
+        position: { x: 830, y: 420 },
+      },
+      {
+        id: "shipped-change",
+        label: "PR and delivery",
+        description: "Reconcile callbacks and preserve the terminal outcome.",
+        kind: "terminal",
+        provider: "github",
+        metricsKey: "completed",
+        position: { x: 1090, y: 420 },
+      },
+    ],
+    edges: [
+      {
+        id: "slack-to-normalize",
+        source: "slack-feedback",
+        target: "normalize-context",
+        label: "feedback",
+        condition: "",
+      },
+      {
+        id: "github-to-normalize",
+        source: "github-evidence",
+        target: "normalize-context",
+        label: "evidence",
+        condition: "",
+      },
+      {
+        id: "normalize-to-triage",
+        source: "normalize-context",
+        target: "ai-triage",
+        label: "complete or partial context",
+        condition: "",
+      },
+      {
+        id: "triage-to-human",
+        source: "ai-triage",
+        target: "human-gate",
+        label: "shadow decision",
+        condition: "always review until a rule is explicitly promoted",
+      },
+      {
+        id: "human-to-agent",
+        source: "human-gate",
+        target: "builder-agent",
+        label: "approved proposal",
+        condition: "guard checks pass and a person approves",
+      },
+      {
+        id: "agent-to-shipped",
+        source: "builder-agent",
+        target: "shipped-change",
+        label: "callback and reconciliation",
+        condition: "",
+      },
+    ],
+  };
+}

package/corpus/templates/factory/server/factory-graph/store.ts

@@ -0,0 +1,121 @@
+import { and, count, desc, eq, type SQL } from "drizzle-orm";
+
+import { getDb } from "../db/index.js";
+import {
+  factoryDefinitions,
+  triageDecisions,
+  triageItems,
+  triageRuns,
+} from "../db/schema.js";
+import {
+  defaultFactoryGraph,
+  normalizeFactoryGraph,
+  type FactoryGraph,
+} from "./contracts.js";
+
+export const DEFAULT_FACTORY_ID = "product-feedback";
+
+export interface FactoryMetricSummary {
+  totalItems: number;
+  slackItems: number;
+  githubItems: number;
+  decisions: number;
+  manualItems: number;
+  runs: number;
+  completedRuns: number;
+}
+
+export function parseFactoryGraph(value: string): FactoryGraph {
+  try {
+    return normalizeFactoryGraph(JSON.parse(value));
+  } catch (error) {
+    throw new Error(
+      `Factory graph is unreadable: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export async function listFactoryDefinitions(orgId: string) {
+  return getDb()
+    .select({
+      id: factoryDefinitions.id,
+      name: factoryDefinitions.name,
+      description: factoryDefinitions.description,
+      prompt: factoryDefinitions.prompt,
+      graphVersion: factoryDefinitions.graphVersion,
+      updatedAt: factoryDefinitions.updatedAt,
+    })
+    .from(factoryDefinitions)
+    .where(eq(factoryDefinitions.orgId, orgId))
+    .orderBy(desc(factoryDefinitions.updatedAt));
+}
+
+export async function readFactoryDefinition(orgId: string, factoryId: string) {
+  return (
+    await getDb()
+      .select()
+      .from(factoryDefinitions)
+      .where(eq(factoryDefinitions.id, factoryId))
+      .limit(1)
+  ).find((row) => row.orgId === orgId);
+}
+
+export async function readFactoryMetrics(
+  orgId: string,
+): Promise<FactoryMetricSummary> {
+  const db = getDb();
+  const [
+    totalItems,
+    slackItems,
+    githubItems,
+    decisions,
+    manualItems,
+    runs,
+    completedRuns,
+  ] = await Promise.all([
+    countRows(triageItems, orgId),
+    countRows(triageItems, orgId, eq(triageItems.source, "slack")),
+    countRows(triageItems, orgId, eq(triageItems.source, "github")),
+    countRows(triageDecisions, orgId),
+    countRows(triageItems, orgId, eq(triageItems.status, "needs_manual")),
+    countRows(triageRuns, orgId),
+    countRows(triageRuns, orgId, eq(triageRuns.status, "completed")),
+  ]);
+
+  return {
+    totalItems,
+    slackItems,
+    githubItems,
+    decisions,
+    manualItems,
+    runs,
+    completedRuns,
+  };
+}
+
+async function countRows(
+  table: typeof triageItems | typeof triageDecisions | typeof triageRuns,
+  orgId: string,
+  extra?: SQL,
+) {
+  const where = extra
+    ? and(eq(table.orgId, orgId), extra)
+    : eq(table.orgId, orgId);
+  const row = (
+    await getDb().select({ value: count() }).from(table).where(where)
+  )[0];
+  return Number(row?.value ?? 0);
+}
+
+export function defaultFactoryDefinition() {
+  return {
+    id: DEFAULT_FACTORY_ID,
+    name: "Product feedback to shipped change",
+    description: defaultFactoryGraph().description,
+    prompt:
+      "Observe product feedback and pull-request evidence, classify it in shadow mode, and keep a person in the loop before coding work starts.",
+    graphVersion: 1,
+    graph: defaultFactoryGraph(),
+    virtual: true,
+  } as const;
+}