@evo-dev/core 0.0.1-alpha

package/src/workflow/index.ts

@@ -0,0 +1,137 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { TaskContract } from "../task/index.ts";
+
+export type WorkflowMode = "minimal" | "standard" | "rigorous";
+
+export interface WorkflowManifest {
+  id: string;
+  version: string;
+  name: string;
+  description: string;
+  modes: WorkflowMode[];
+  steps: WorkflowStep[];
+  requiredEvidence: string[];
+  verification: {
+    policy: "fail-closed";
+    antiCriteria: string[];
+  };
+  privacy: {
+    metadataOnly: true;
+    storesRawPrompts: false;
+    storesSourceContent: false;
+    storesRawCommandOutput: false;
+    usesNetwork: false;
+  };
+}
+
+export interface WorkflowStep {
+  id: string;
+  name: string;
+  actor: "human" | "agent" | "tool" | "reviewer";
+  required: boolean;
+  evidence: string[];
+  summary: string;
+}
+
+export interface WorkflowPlan {
+  workflow: WorkflowManifest;
+  taskId?: string;
+  mode: WorkflowMode | null;
+  steps: Array<WorkflowStep & { plannedOnly: true }>;
+  requiredEvidence: string[];
+  warnings: string[];
+  blockers: string[];
+}
+
+export async function scanWorkflowManifests(workflowsDir: string): Promise<WorkflowManifest[]> {
+  const manifests: WorkflowManifest[] = [];
+  const entries = await readdir(workflowsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const manifestPath = join(workflowsDir, entry.name, "WORKFLOW.json");
+    manifests.push(parseWorkflowManifest(JSON.parse(await readFile(manifestPath, "utf8"))));
+  }
+
+  return manifests.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function parseWorkflowManifest(value: unknown): WorkflowManifest {
+  if (!isRecord(value)) throw new Error("Workflow manifest must be an object.");
+  const manifest = value as unknown as WorkflowManifest;
+  if (typeof manifest.id !== "string" || typeof manifest.version !== "string") {
+    throw new Error("Workflow manifest missing id/version.");
+  }
+  if (!Array.isArray(manifest.modes) || !Array.isArray(manifest.steps)) {
+    throw new Error(`Workflow manifest ${manifest.id} missing modes/steps.`);
+  }
+  if (
+    manifest.privacy?.metadataOnly !== true ||
+    manifest.privacy.usesNetwork !== false ||
+    manifest.privacy.storesRawPrompts !== false ||
+    manifest.privacy.storesSourceContent !== false ||
+    manifest.privacy.storesRawCommandOutput !== false
+  ) {
+    throw new Error(`Workflow manifest ${manifest.id} violates privacy requirements.`);
+  }
+  return manifest;
+}
+
+export function planWorkflow(input: {
+  workflow: WorkflowManifest;
+  contract?: TaskContract;
+}): WorkflowPlan {
+  const mode = input.contract?.route.mode ?? null;
+  const warnings: string[] = [];
+  const blockers: string[] = [];
+
+  if (mode !== null && !input.workflow.modes.includes(mode)) {
+    blockers.push(`Workflow ${input.workflow.id} does not support task mode ${mode}.`);
+  }
+
+  return {
+    workflow: input.workflow,
+    taskId: input.contract?.taskId,
+    mode,
+    steps: input.workflow.steps.map((step) => ({ ...step, plannedOnly: true })),
+    requiredEvidence: input.workflow.requiredEvidence,
+    warnings,
+    blockers,
+  };
+}
+
+export function formatWorkflowList(manifests: WorkflowManifest[]): string {
+  return [
+    "EvoDev workflows",
+    "",
+    ...manifests.map(
+      (workflow) => `- ${workflow.id} (${workflow.modes.join(", ")}): ${workflow.description}`,
+    ),
+  ].join("\n");
+}
+
+export function formatWorkflowPlan(plan: WorkflowPlan): string {
+  return [
+    "EvoDev workflow dry-run",
+    "",
+    `Workflow: ${plan.workflow.id}`,
+    `Task: ${plan.taskId ?? "none"}`,
+    `Mode: ${plan.mode ?? "not routed"}`,
+    "",
+    "Steps:",
+    ...plan.steps.map(
+      (step) =>
+        `  - ${step.id}: ${step.name} [${step.actor}] evidence=${step.evidence.join(",") || "none"}`,
+    ),
+    "",
+    "Required evidence:",
+    ...plan.requiredEvidence.map((item) => `  - ${item}`),
+    ...plan.warnings.map((warning) => `Warning: ${warning}`),
+    ...plan.blockers.map((blocker) => `Blocker: ${blocker}`),
+  ].join("\n");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}