@davidorex/pi-workflows 0.2.0 → 0.3.0

package/src/workflow-sdk.test.ts

@@ -1,238 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import {
-  filterNames, stepTypes, expressionRoots,
-  availableAgents, availableTemplates, availableSchemas,
-  extractExpressions, declaredSteps, declaredAgentRefs, declaredSchemaRefs,
-  FILTER_NAMES, STEP_TYPES,
-} from "./workflow-sdk.ts";
-import type { WorkflowSpec, StepSpec } from "./types.ts";
-
-function makeTmpDir(prefix: string): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), `sdk-${prefix}-`));
-}
-
-// ── Vocabulary ───────────────────────────────────────────────────────────────
-
-describe("vocabulary", () => {
-  it("filterNames returns current filter set", () => {
-    const names = filterNames();
-    assert.ok(names.includes("json"));
-    assert.ok(names.includes("duration"));
-    assert.ok(names.includes("currency"));
-    assert.ok(names.includes("length"));
-    assert.ok(names.includes("keys"));
-    assert.ok(names.includes("filter"));
-  });
-
-  it("filterNames length matches FILTER_NAMES export", () => {
-    assert.strictEqual(filterNames().length, FILTER_NAMES.length);
-  });
-
-  it("stepTypes returns descriptors with required fields", () => {
-    const types = stepTypes();
-    assert.ok(types.length >= 7);
-    for (const t of types) {
-      assert.ok(typeof t.name === "string");
-      assert.ok(typeof t.field === "string");
-      assert.ok(typeof t.retryable === "boolean");
-      assert.ok(typeof t.supportsInput === "boolean");
-      assert.ok(typeof t.supportsOutput === "boolean");
-    }
-  });
-
-  it("stepTypes field names match STEP_TYPES export", () => {
-    const fromFn = stepTypes().map(t => t.field).sort();
-    const fromExport = STEP_TYPES.map(t => t.field).sort();
-    assert.deepStrictEqual(fromFn, fromExport);
-  });
-
-  it("expressionRoots includes input and steps", () => {
-    const roots = expressionRoots();
-    assert.ok(roots.includes("input"));
-    assert.ok(roots.includes("steps"));
-  });
-});
-
-// ── Discovery ────────────────────────────────────────────────────────────────
-
-describe("discovery", () => {
-  it("availableAgents finds agents in .pi/agents/", (t) => {
-    const tmpDir = makeTmpDir("agents");
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const agentDir = path.join(tmpDir, ".pi", "agents");
-    fs.mkdirSync(agentDir, { recursive: true });
-    fs.writeFileSync(path.join(agentDir, "test-agent.agent.yaml"), "name: test-agent\ntools: [read]\n");
-
-    const agents = availableAgents(tmpDir, "/nonexistent"); // no builtins
-    assert.ok(agents.some(a => a.name === "test-agent"));
-  });
-
-  it("availableAgents skips malformed YAML", (t) => {
-    const tmpDir = makeTmpDir("agents-bad");
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const agentDir = path.join(tmpDir, ".pi", "agents");
-    fs.mkdirSync(agentDir, { recursive: true });
-    fs.writeFileSync(path.join(agentDir, "good.agent.yaml"), "name: good\ntools: [read]\n");
-    fs.writeFileSync(path.join(agentDir, "bad.agent.yaml"), ":::invalid yaml{{{\n");
-
-    const agents = availableAgents(tmpDir, "/nonexistent");
-    assert.ok(agents.some(a => a.name === "good"));
-    assert.ok(!agents.some(a => a.name === "bad"));
-  });
-
-  it("availableTemplates finds .md files", (t) => {
-    const tmpDir = makeTmpDir("templates");
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const tplDir = path.join(tmpDir, ".pi", "templates", "my-agent");
-    fs.mkdirSync(tplDir, { recursive: true });
-    fs.writeFileSync(path.join(tplDir, "task.md"), "# Task\n");
-
-    const templates = availableTemplates(tmpDir, "/nonexistent");
-    assert.ok(templates.includes(path.join("my-agent", "task.md")));
-  });
-
-  it("availableSchemas finds builtin schemas", (t) => {
-    const tmpDir = makeTmpDir("schemas");
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const schemasDir = path.join(tmpDir, "test-schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-    fs.writeFileSync(path.join(schemasDir, "result.schema.json"), "{}");
-
-    const schemas = availableSchemas(tmpDir, schemasDir);
-    assert.ok(schemas.some(s => s.includes("result.schema.json")));
-  });
-});
-
-// ── Introspection ────────────────────────────────────────────────────────────
-
-function makeSpec(steps: Record<string, StepSpec>, extras?: Partial<WorkflowSpec>): WorkflowSpec {
-  return {
-    name: "test",
-    description: "test",
-    steps,
-    source: "project",
-    filePath: "/tmp/test.workflow.yaml",
-    ...extras,
-  };
-}
-
-describe("introspection", () => {
-  it("extractExpressions finds step references", () => {
-    const spec = makeSpec({
-      load: { command: "echo hello" },
-      process: { agent: "coder", when: "${{ steps.load.output.ready }}" },
-    });
-    const exprs = extractExpressions(spec);
-    assert.ok(exprs.some(e => e.stepRefs.includes("load")));
-  });
-
-  it("extractExpressions finds filter names", () => {
-    const spec = makeSpec({
-      s1: { agent: "coder", input: "Data: ${{ steps.load.output | json }}" },
-    });
-    const exprs = extractExpressions(spec);
-    const jsonExpr = exprs.find(e => e.filterName === "json");
-    assert.ok(jsonExpr);
-  });
-
-  it("extractExpressions scans when, forEach, command, gate.check, completion", () => {
-    const spec = makeSpec({
-      load: { command: "echo '${{ input.x }}'" },
-      check: { gate: { check: "test '${{ steps.load.output.ok }}' = 'true'" } },
-      iter: { agent: "a", forEach: "${{ steps.load.output.items }}", as: "item" },
-      cond: { agent: "b", when: "${{ steps.check.output.passed }}" },
-    }, {
-      completion: {
-        message: "Done: ${{ steps.iter.output | json }}",
-        include: ["steps.load.output"],
-      },
-    });
-    const exprs = extractExpressions(spec);
-    const fields = exprs.map(e => e.field);
-    assert.ok(fields.some(f => f.includes("command")));
-    assert.ok(fields.some(f => f.includes("gate.check")));
-    assert.ok(fields.some(f => f.includes("forEach")));
-    assert.ok(fields.some(f => f.includes("when")));
-    assert.ok(fields.some(f => f.includes("completion.message")));
-  });
-
-  it("extractExpressions handles nested loop steps", () => {
-    const spec = makeSpec({
-      outer: {
-        loop: {
-          maxAttempts: 3,
-          steps: {
-            inner: { agent: "coder", when: "${{ steps.outer.output.retry }}" },
-          },
-        },
-      },
-    });
-    const exprs = extractExpressions(spec);
-    assert.ok(exprs.some(e => e.field.includes("loop.steps.inner")));
-  });
-
-  it("declaredSteps returns step names", () => {
-    const spec = makeSpec({ a: { command: "echo" }, b: { agent: "x" }, c: { pause: true } });
-    assert.deepStrictEqual(declaredSteps(spec), ["a", "b", "c"]);
-  });
-
-  it("declaredAgentRefs extracts agent names", () => {
-    const spec = makeSpec({
-      s1: { agent: "investigator" },
-      s2: { command: "echo" },
-      s3: { agent: "decomposer" },
-    });
-    const refs = declaredAgentRefs(spec);
-    assert.ok(refs.includes("investigator"));
-    assert.ok(refs.includes("decomposer"));
-    assert.strictEqual(refs.length, 2);
-  });
-
-  it("declaredAgentRefs finds agents in nested forEach/loop/parallel", () => {
-    const spec = makeSpec({
-      outer: {
-        agent: "outer-agent",
-        loop: {
-          maxAttempts: 2,
-          steps: {
-            inner: { agent: "inner-agent" },
-          },
-        },
-      },
-      par: {
-        parallel: {
-          a: { agent: "par-agent" },
-          b: { command: "echo" },
-        },
-      },
-    });
-    const refs = declaredAgentRefs(spec);
-    assert.ok(refs.includes("outer-agent"));
-    assert.ok(refs.includes("inner-agent"));
-    assert.ok(refs.includes("par-agent"));
-  });
-
-  it("declaredSchemaRefs extracts output.schema and artifact.schema paths", () => {
-    const spec = makeSpec({
-      s1: { agent: "a", output: { schema: "schemas/findings.schema.json" } },
-      s2: { command: "echo", output: { schema: "schemas/results.schema.json" } },
-    }, {
-      artifacts: {
-        report: { path: "./report.json", from: "steps.s1.output", schema: "schemas/report.schema.json" },
-      },
-    });
-    const refs = declaredSchemaRefs(spec);
-    assert.ok(refs.includes("schemas/findings.schema.json"));
-    assert.ok(refs.includes("schemas/results.schema.json"));
-    assert.ok(refs.includes("schemas/report.schema.json"));
-    assert.strictEqual(refs.length, 3);
-  });
-});

package/src/workflow-sdk.ts

@@ -1,262 +0,0 @@
-/**
- * Workflow SDK — single queryable surface for the workflow extension's
- * vocabulary, discovery, and spec introspection. Derives dynamically
- * from source registries and filesystem — add a filter, agent, template,
- * or schema, and it appears here automatically.
- */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { FILTER_NAMES, EXPRESSION_ROOTS } from "./expression.ts";
-import { STEP_TYPES } from "./workflow-spec.ts";
-import type { StepTypeDescriptor } from "./workflow-spec.ts";
-import { discoverWorkflows } from "./workflow-discovery.ts";
-import { parseAgentYaml } from "./agent-spec.ts";
-import type { AgentSpec, WorkflowSpec, StepSpec } from "./types.ts";
-
-// Re-export for single-import convenience
-export { FILTER_NAMES, STEP_TYPES, EXPRESSION_ROOTS };
-export type { StepTypeDescriptor };
-
-const EXPR_PATTERN = /\$\{\{\s*(.*?)\s*\}\}/g;
-
-// ── Vocabulary (derived from code registries) ────────────────────────────────
-
-export function filterNames(): string[] { return FILTER_NAMES; }
-export function stepTypes(): StepTypeDescriptor[] { return STEP_TYPES; }
-export function expressionRoots(): readonly string[] { return EXPRESSION_ROOTS; }
-
-// ── Discovery (derived from filesystem) ──────────────────────────────────────
-
-export function availableAgents(cwd: string, builtinDir?: string): AgentSpec[] {
-  const defaultBuiltinDir = builtinDir ?? path.resolve(import.meta.dirname, "..", "agents");
-  const searchDirs = [
-    path.join(cwd, ".pi", "agents"),
-    path.join(os.homedir(), ".pi", "agent", "agents"),
-    defaultBuiltinDir,
-  ];
-  const seen = new Set<string>();
-  const agents: AgentSpec[] = [];
-
-  for (const dir of searchDirs) {
-    if (!fs.existsSync(dir)) continue;
-    for (const file of fs.readdirSync(dir)) {
-      if (!file.endsWith(".agent.yaml")) continue;
-      const name = file.replace(".agent.yaml", "");
-      if (seen.has(name)) continue; // higher-priority dir already found this agent
-      seen.add(name);
-      try {
-        agents.push(parseAgentYaml(path.join(dir, file)));
-      } catch {
-        // skip malformed specs
-      }
-    }
-  }
-  return agents.sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function availableTemplates(cwd: string, builtinDir?: string): string[] {
-  const defaultBuiltinDir = builtinDir ?? path.resolve(import.meta.dirname, "..", "templates");
-  const searchDirs = [
-    path.join(cwd, ".pi", "templates"),
-    path.join(os.homedir(), ".pi", "agent", "templates"),
-    defaultBuiltinDir,
-  ];
-  const seen = new Set<string>();
-
-  for (const dir of searchDirs) {
-    if (!fs.existsSync(dir)) continue;
-    walkFiles(dir, (filePath) => {
-      if (filePath.endsWith(".md") || filePath.endsWith(".txt")) {
-        const rel = path.relative(dir, filePath);
-        if (!seen.has(rel)) seen.add(rel);
-      }
-    });
-  }
-  return Array.from(seen).sort();
-}
-
-export function availableSchemas(cwd: string, builtinDir?: string): string[] {
-  const defaultBuiltinSchemas = builtinDir ?? path.resolve(import.meta.dirname, "..", "schemas");
-  const dirs = [
-    defaultBuiltinSchemas,
-  ];
-  const schemas: string[] = [];
-
-  for (const dir of dirs) {
-    if (!fs.existsSync(dir)) continue;
-    for (const file of fs.readdirSync(dir)) {
-      if (file.endsWith(".schema.json")) {
-        schemas.push(path.join(dir, file));
-      }
-    }
-  }
-  return schemas.sort();
-}
-
-export function availableWorkflows(cwd: string): WorkflowSpec[] {
-  return discoverWorkflows(cwd);
-}
-
-// ── Introspection (derived from parsed spec) ─────────────────────────────────
-
-export interface ExpressionRef {
-  expression: string;
-  field: string;
-  stepRefs: string[];
-  filterName?: string;
-}
-
-/**
- * Extract all ${{ }} expressions from a workflow spec with their source locations.
- * Walks the entire spec tree including nested steps in loops and parallel blocks.
- */
-export function extractExpressions(spec: WorkflowSpec): ExpressionRef[] {
-  const refs: ExpressionRef[] = [];
-
-  // Walk top-level steps
-  for (const [stepName, step] of Object.entries(spec.steps)) {
-    extractFromStep(step, `steps.${stepName}`, refs);
-  }
-
-  // Walk completion
-  if (spec.completion) {
-    if (spec.completion.template) {
-      extractFromString(spec.completion.template, "completion.template", refs);
-    }
-    if (spec.completion.message) {
-      extractFromString(spec.completion.message, "completion.message", refs);
-    }
-    if (spec.completion.include) {
-      for (const inc of spec.completion.include) {
-        extractFromString(inc, "completion.include", refs);
-      }
-    }
-  }
-
-  // Walk artifacts
-  if (spec.artifacts) {
-    for (const [name, art] of Object.entries(spec.artifacts)) {
-      extractFromString(art.path, `artifacts.${name}.path`, refs);
-      extractFromString(art.from, `artifacts.${name}.from`, refs);
-    }
-  }
-
-  return refs;
-}
-
-function extractFromStep(step: StepSpec, prefix: string, refs: ExpressionRef[]): void {
-  if (step.when) extractFromString(step.when, `${prefix}.when`, refs);
-  if (step.forEach) extractFromString(step.forEach, `${prefix}.forEach`, refs);
-  if (step.input) extractFromString(step.input as string, `${prefix}.input`, refs);
-  if (step.command) extractFromString(step.command, `${prefix}.command`, refs);
-
-  // Gate check
-  if (step.gate?.check) extractFromString(step.gate.check, `${prefix}.gate.check`, refs);
-
-  // Transform mapping
-  if (step.transform?.mapping) {
-    extractFromValue(step.transform.mapping, `${prefix}.transform.mapping`, refs);
-  }
-
-  // Nested loop steps
-  if (step.loop?.steps) {
-    for (const [subName, subStep] of Object.entries(step.loop.steps)) {
-      extractFromStep(subStep, `${prefix}.loop.steps.${subName}`, refs);
-    }
-  }
-
-  // Nested parallel steps
-  if (step.parallel) {
-    for (const [subName, subStep] of Object.entries(step.parallel)) {
-      extractFromStep(subStep, `${prefix}.parallel.${subName}`, refs);
-    }
-  }
-}
-
-function extractFromValue(value: unknown, field: string, refs: ExpressionRef[]): void {
-  if (typeof value === "string") {
-    extractFromString(value, field, refs);
-  } else if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      extractFromValue(value[i], `${field}[${i}]`, refs);
-    }
-  } else if (value && typeof value === "object") {
-    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-      extractFromValue(val, `${field}.${key}`, refs);
-    }
-  }
-}
-
-function extractFromString(str: string, field: string, refs: ExpressionRef[]): void {
-  EXPR_PATTERN.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = EXPR_PATTERN.exec(str)) !== null) {
-    const raw = match[1].trim();
-    const pipeIdx = raw.indexOf("|");
-    const exprPart = pipeIdx >= 0 ? raw.slice(0, pipeIdx).trim() : raw;
-    const filterName = pipeIdx >= 0 ? raw.slice(pipeIdx + 1).trim() : undefined;
-
-    // Extract step references: steps.X.anything → step name is X
-    const stepRefs: string[] = [];
-    const stepRefPattern = /\bsteps\.(\w+)/g;
-    let stepMatch: RegExpExecArray | null;
-    while ((stepMatch = stepRefPattern.exec(exprPart)) !== null) {
-      if (!stepRefs.includes(stepMatch[1])) {
-        stepRefs.push(stepMatch[1]);
-      }
-    }
-
-    refs.push({ expression: raw, field, stepRefs, filterName });
-  }
-}
-
-export function declaredSteps(spec: WorkflowSpec): string[] {
-  return Object.keys(spec.steps);
-}
-
-export function declaredAgentRefs(spec: WorkflowSpec): string[] {
-  const agents: string[] = [];
-  collectAgentRefs(spec.steps, agents);
-  return [...new Set(agents)];
-}
-
-function collectAgentRefs(steps: Record<string, StepSpec>, agents: string[]): void {
-  for (const step of Object.values(steps)) {
-    if (step.agent) agents.push(step.agent);
-    if (step.loop?.steps) collectAgentRefs(step.loop.steps, agents);
-    if (step.parallel) collectAgentRefs(step.parallel, agents);
-  }
-}
-
-export function declaredSchemaRefs(spec: WorkflowSpec): string[] {
-  const schemas: string[] = [];
-  collectSchemaRefs(spec.steps, schemas);
-  if (spec.artifacts) {
-    for (const art of Object.values(spec.artifacts)) {
-      if (art.schema) schemas.push(art.schema);
-    }
-  }
-  return [...new Set(schemas)];
-}
-
-function collectSchemaRefs(steps: Record<string, StepSpec>, schemas: string[]): void {
-  for (const step of Object.values(steps)) {
-    if (step.output?.schema) schemas.push(step.output.schema);
-    if (step.loop?.steps) collectSchemaRefs(step.loop.steps, schemas);
-    if (step.parallel) collectSchemaRefs(step.parallel, schemas);
-  }
-}
-
-// ── Utility ──────────────────────────────────────────────────────────────────
-
-function walkFiles(dir: string, callback: (filePath: string) => void): void {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkFiles(full, callback);
-    } else if (entry.isFile()) {
-      callback(full);
-    }
-  }
-}