@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/task-analysis/__tests__/enrichers-schema-deducer.test.ts

@@ -1,10 +1,16 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
 import type { ChatResponse } from "../../providers/types.ts";
 
 mock.module("../../llm/index.ts", () => ({
   chat: mock(),
 }));
 
+const internalLlm = { internalProvider: "deepseek", internalModel: "deepseek-v4-flash" };
+
+mock.module("../../core/config.ts", () => ({
+  getConfig: () => ({ llm: internalLlm }),
+}));
+
 import { chat } from "../../llm/index.ts";
 import { deduceArtifactSchema } from "../enrichers/schema-deducer.ts";
 
@@ -35,14 +41,21 @@ const VALID_EXAMPLE = { id: "abc", value: 42 };
 function makeResponse(content: Record<string, unknown>): Promise<ChatResponse> {
   return Promise.resolve({
     content,
-    usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+    usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30, source: "reported" },
   });
 }
 
+const DEFAULT_INTERNAL_LLM = { ...internalLlm };
+
 beforeEach(() => {
   mockedChat.mockClear();
 });
 
+afterEach(() => {
+  internalLlm.internalProvider = DEFAULT_INTERNAL_LLM.internalProvider;
+  internalLlm.internalModel = DEFAULT_INTERNAL_LLM.internalModel;
+});
+
 describe("deduceArtifactSchema", () => {
   it("returns DeducedSchema on valid LLM response", async () => {
     mockedChat.mockReturnValue(
@@ -60,6 +73,25 @@ describe("deduceArtifactSchema", () => {
     expect(result.reasoning).toBe("The artifact stores processed pipeline data.");
   });
 
+  it("resolves provider and model from the internal config", async () => {
+    internalLlm.internalProvider = "zai";
+    internalLlm.internalModel = "glm-4";
+    mockedChat.mockReturnValue(
+      makeResponse({
+        schema: VALID_SCHEMA,
+        example: VALID_EXAMPLE,
+        reasoning: "uses configured model",
+      }),
+    );
+
+    await deduceArtifactSchema(TASK_CODE, ARTIFACT);
+
+    expect(mockedChat.mock.calls[0]?.[0]).toMatchObject({
+      provider: "zhipu",
+      model: "glm-4",
+    });
+  });
+
   it("throws when schema field is missing", async () => {
     mockedChat.mockReturnValue(
       makeResponse({

package/src/task-analysis/__tests__/no-ast-imports.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SRC_DIR = path.resolve(fileURLToPath(new URL("../../", import.meta.url)));
+const SELF = fileURLToPath(import.meta.url);
+
+// The deterministic AST pipeline (step 10 / AC-11) is deleted. No source file may
+// import the removed modules or the Babel toolchain that backed them.
+const FORBIDDEN_PATTERNS: RegExp[] = [
+  /task-analysis\/parser/,
+  /task-analysis\/extractors/,
+  /task-analysis\/utils\/ast/,
+  /task-analysis\/enrichers\/artifact-resolver/,
+  /task-analysis\/enrichers\/analysis-writer/,
+  /@babel\//,
+];
+
+async function collectSourceFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules") continue;
+      files.push(...(await collectSourceFiles(full)));
+    } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+describe("deleted AST pipeline", () => {
+  it("is not imported anywhere in src/", async () => {
+    const files = await collectSourceFiles(SRC_DIR);
+    const offenders: { file: string; pattern: string }[] = [];
+
+    for (const file of files) {
+      if (file === SELF) continue;
+      const text = await readFile(file, "utf8");
+      for (const pattern of FORBIDDEN_PATTERNS) {
+        if (pattern.test(text)) {
+          offenders.push({ file: path.relative(SRC_DIR, file), pattern: String(pattern) });
+        }
+      }
+    }
+
+    expect(offenders).toEqual([]);
+  });
+});

package/src/task-analysis/__tests__/repository.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { TaskAnalysisRepository } from "../repository.ts";
+import type { PersistedTaskAnalysis } from "../types.ts";
+
+const ANALYSIS: PersistedTaskAnalysis = {
+  summary: "Fetches and summarizes source data.",
+  stages: [{ name: "fetch", purpose: "Retrieve the input document." }],
+  artifacts: {
+    reads: [{ fileName: "input.json", role: "source data" }],
+    writes: [{ fileName: "output.json", role: "summary" }],
+  },
+  models: [{ provider: "openai", method: "chat", stage: "fetch" }],
+  analyzedAt: "2026-06-22T00:00:00.000Z",
+  analysisStatus: "ok",
+};
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(path.join(os.tmpdir(), "task-analysis-repo-"));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("TaskAnalysisRepository.analysisPath", () => {
+  it("resolves the canonical pipeline-config tasks path", () => {
+    const result = TaskAnalysisRepository.analysisPath("/data", "my-pipe", "research");
+
+    expect(result).toBe(
+      path.join("/data", "pipeline-config", "my-pipe", "tasks", "research.analysis.json"),
+    );
+  });
+});
+
+describe("TaskAnalysisRepository.read", () => {
+  it("returns null when no analysis file exists", async () => {
+    const result = await TaskAnalysisRepository.read(tmpDir, "my-pipe", "research");
+
+    expect(result).toBeNull();
+  });
+});
+
+describe("TaskAnalysisRepository.write then read", () => {
+  it("round-trips the persisted analysis", async () => {
+    await TaskAnalysisRepository.write(tmpDir, "my-pipe", "research", ANALYSIS);
+
+    const result = await TaskAnalysisRepository.read(tmpDir, "my-pipe", "research");
+
+    expect(result).toEqual(ANALYSIS);
+  });
+
+  it("writes atomically, leaving no temp file behind", async () => {
+    await TaskAnalysisRepository.write(tmpDir, "my-pipe", "research", ANALYSIS);
+
+    const tasksDir = path.join(tmpDir, "pipeline-config", "my-pipe", "tasks");
+    const entries = await readdir(tasksDir);
+
+    expect(entries).toEqual(["research.analysis.json"]);
+  });
+});

package/src/task-analysis/__tests__/types.test.ts

@@ -1,165 +1,98 @@
 import { describe, it, expect } from "vitest";
+import { TaskAnalysisSchema } from "../types.ts";
 import type {
-  SourceLocation,
-  Stage,
-  ArtifactRead,
-  ArtifactWrite,
-  UnresolvedRead,
-  UnresolvedWrite,
-  ModelCall,
-  ArtifactData,
+  AnalysisStatus,
   TaskAnalysis,
   PersistedTaskAnalysis,
   DeducedSchema,
-  ArtifactResolution,
   ArtifactDescriptor,
-  UnresolvedArtifactDescriptor,
-} from "../types.js";
-
-describe("task-analysis types", () => {
-  it("SourceLocation accepts line and column", () => {
-    const loc: SourceLocation = { line: 1, column: 5 };
-    expect(loc.line).toBe(1);
-    expect(loc.column).toBe(5);
-  });
+} from "../types.ts";
 
-  it("Stage accepts name, order, and isAsync", () => {
-    const stage: Stage = { name: "ingestion", order: 10, isAsync: true };
-    expect(stage.name).toBe("ingestion");
-    expect(stage.isAsync).toBe(true);
-  });
+function wellFormedAnalysis(): TaskAnalysis {
+  return {
+    summary: "Ingests data and refines it into a report.",
+    stages: [
+      { name: "ingestion", purpose: "Read raw input" },
+      { name: "refine", purpose: "Produce the report" },
+    ],
+    artifacts: {
+      reads: [{ fileName: "input.json", role: "raw source data" }],
+      writes: [{ fileName: "report.json", role: "final report" }],
+    },
+    models: [{ provider: "deepseek", method: "chat", stage: "refine" }],
+  };
+}
 
-  it("ArtifactRead accepts fileName, stage, and required", () => {
-    const read: ArtifactRead = { fileName: "data.json", stage: "parse", required: true };
-    expect(read.fileName).toBe("data.json");
-    expect(read.required).toBe(true);
-  });
+describe("TaskAnalysisSchema validator", () => {
+  it("accepts a well-formed analysis", () => {
+    const result = TaskAnalysisSchema.safeParse(wellFormedAnalysis());
 
-  it("ArtifactWrite accepts fileName and stage", () => {
-    const write: ArtifactWrite = { fileName: "output.json", stage: "refine" };
-    expect(write.fileName).toBe("output.json");
-    expect(write.stage).toBe("refine");
+    expect(result.success).toBe(true);
   });
 
-  it("UnresolvedRead accepts all fields including location", () => {
-    const loc: SourceLocation = { line: 3, column: 2 };
-    const unresolved: UnresolvedRead = {
-      expression: "dynamicName",
-      codeContext: "io.readArtifact(dynamicName)",
-      stage: "parse",
-      required: false,
-      location: loc,
-    };
-    expect(unresolved.expression).toBe("dynamicName");
-    expect(unresolved.required).toBe(false);
-    expect(unresolved.location.line).toBe(3);
-  });
+  it("rejects an analysis missing summary", () => {
+    const { summary, ...rest } = wellFormedAnalysis();
 
-  it("UnresolvedWrite accepts all fields including location", () => {
-    const loc: SourceLocation = { line: 7, column: 0 };
-    const unresolved: UnresolvedWrite = {
-      expression: "outputVar",
-      codeContext: "io.writeArtifact(outputVar)",
-      stage: "write",
-      location: loc,
-    };
-    expect(unresolved.stage).toBe("write");
-    expect(unresolved.location.column).toBe(0);
+    const result = TaskAnalysisSchema.safeParse(rest);
+
+    expect(result.success).toBe(false);
   });
 
-  it("ModelCall accepts provider, method, and stage", () => {
-    const call: ModelCall = { provider: "deepseek", method: "chat", stage: "analyze" };
-    expect(call.provider).toBe("deepseek");
-    expect(call.method).toBe("chat");
+  it("rejects a stage missing purpose", () => {
+    const analysis = wellFormedAnalysis();
+    analysis.stages[0] = { name: "ingestion" } as never;
+
+    const result = TaskAnalysisSchema.safeParse(analysis);
+
+    expect(result.success).toBe(false);
   });
 
-  it("ArtifactData requires all four arrays", () => {
-    const data: ArtifactData = {
-      reads: [],
-      writes: [],
-      unresolvedReads: [],
-      unresolvedWrites: [],
-    };
-    expect(Array.isArray(data.reads)).toBe(true);
-    expect(Array.isArray(data.writes)).toBe(true);
-    expect(Array.isArray(data.unresolvedReads)).toBe(true);
-    expect(Array.isArray(data.unresolvedWrites)).toBe(true);
+  it("rejects a read artifact missing role", () => {
+    const analysis = wellFormedAnalysis();
+    analysis.artifacts.reads[0] = { fileName: "input.json" } as never;
+
+    const result = TaskAnalysisSchema.safeParse(analysis);
+
+    expect(result.success).toBe(false);
   });
 
-  it("TaskAnalysis accepts taskFilePath as null", () => {
-    const analysis: TaskAnalysis = {
-      taskFilePath: null,
-      stages: [],
-      artifacts: { reads: [], writes: [], unresolvedReads: [], unresolvedWrites: [] },
-      models: [],
-    };
-    expect(analysis.taskFilePath).toBeNull();
+  it("rejects models that are not an array", () => {
+    const analysis = { ...wellFormedAnalysis(), models: "deepseek" };
+
+    const result = TaskAnalysisSchema.safeParse(analysis);
+
+    expect(result.success).toBe(false);
   });
+});
 
-  it("TaskAnalysis accepts taskFilePath as a string", () => {
-    const analysis: TaskAnalysis = {
-      taskFilePath: "/path/to/task.js",
-      stages: [],
-      artifacts: { reads: [], writes: [], unresolvedReads: [], unresolvedWrites: [] },
-      models: [],
-    };
-    expect(analysis.taskFilePath).toBe("/path/to/task.js");
+describe("doc-oriented analysis types", () => {
+  it("AnalysisStatus enumerates ok, unconfigured, and error", () => {
+    const statuses: AnalysisStatus[] = ["ok", "unconfigured", "error"];
+
+    expect(statuses).toEqual(["ok", "unconfigured", "error"]);
   });
 
-  it("PersistedTaskAnalysis extends TaskAnalysis with analyzedAt", () => {
+  it("PersistedTaskAnalysis adds analyzedAt, analysisStatus, and optional analysisError", () => {
     const persisted: PersistedTaskAnalysis = {
-      taskFilePath: "/task.js",
-      stages: [],
-      artifacts: { reads: [], writes: [], unresolvedReads: [], unresolvedWrites: [] },
-      models: [],
+      ...wellFormedAnalysis(),
       analyzedAt: "2026-03-02T00:00:00.000Z",
+      analysisStatus: "error",
+      analysisError: "LLM call failed",
     };
-    expect(persisted.analyzedAt).toBe("2026-03-02T00:00:00.000Z");
-    expect(persisted.taskFilePath).toBe("/task.js");
+
+    expect(persisted.analysisStatus).toBe("error");
+    expect(persisted.analysisError).toBe("LLM call failed");
   });
 
-  it("DeducedSchema accepts schema, example, and reasoning", () => {
+  it("keeps DeducedSchema and ArtifactDescriptor", () => {
     const deduced: DeducedSchema = {
-      schema: { type: "object", properties: {} },
+      schema: { type: "object" },
       example: { name: "test" },
       reasoning: "Inferred from usage",
     };
-    expect(deduced.reasoning).toBe("Inferred from usage");
-    expect(deduced.example).toEqual({ name: "test" });
-  });
-
-  it("ArtifactResolution accepts resolvedFileName as null", () => {
-    const resolution: ArtifactResolution = {
-      resolvedFileName: null,
-      confidence: 0,
-      reasoning: "Could not resolve",
-    };
-    expect(resolution.resolvedFileName).toBeNull();
-    expect(resolution.confidence).toBe(0);
-  });
-
-  it("ArtifactResolution accepts resolvedFileName as a string", () => {
-    const resolution: ArtifactResolution = {
-      resolvedFileName: "data.json",
-      confidence: 0.9,
-      reasoning: "High confidence match",
-    };
-    expect(resolution.resolvedFileName).toBe("data.json");
-  });
-
-  it("ArtifactDescriptor accepts fileName and stage", () => {
     const descriptor: ArtifactDescriptor = { fileName: "report.json", stage: "generate" };
-    expect(descriptor.fileName).toBe("report.json");
-    expect(descriptor.stage).toBe("generate");
-  });
 
-  it("UnresolvedArtifactDescriptor accepts expression, codeContext, and stage", () => {
-    const descriptor: UnresolvedArtifactDescriptor = {
-      expression: "fileName",
-      codeContext: "io.readArtifact(fileName)",
-      stage: "process",
-    };
-    expect(descriptor.expression).toBe("fileName");
-    expect(descriptor.codeContext).toBe("io.readArtifact(fileName)");
+    expect(deduced.reasoning).toBe("Inferred from usage");
+    expect(descriptor.stage).toBe("generate");
   });
 });

package/src/task-analysis/analyzer.ts

@@ -0,0 +1,91 @@
+// ── src/task-analysis/analyzer.ts ──
+// LLM-only task analyzer: never throws, returns a status-tagged doc-oriented analysis.
+
+import { chat, getAvailableProviders } from "../llm/index.ts";
+import { getConfig } from "../core/config.ts";
+import type { ChatMessage, ProviderName } from "../providers/types.ts";
+import { TaskAnalysisSchema, type TaskAnalysis, type AnalysisStatus } from "./types.ts";
+
+export type AnalysisResult = TaskAnalysis & {
+  analysisStatus: AnalysisStatus;
+  analysisError?: string;
+};
+
+/** Maps a config provider key to its gateway provider name. */
+function toGatewayProvider(configName: string): ProviderName {
+  if (configName === "zai") return "zhipu";
+  if (configName === "claude-code") return "claudecode";
+  return configName as ProviderName;
+}
+
+/** Empty doc-shaped placeholder used for non-`ok` results. */
+function emptyAnalysis(): TaskAnalysis {
+  return {
+    summary: "",
+    stages: [],
+    artifacts: { reads: [], writes: [] },
+    models: [],
+  };
+}
+
+function buildMessages(code: string): ChatMessage[] {
+  return [
+    {
+      role: "system",
+      content:
+        "You document prompt-orchestration pipeline tasks. Read the task source and produce a concise, " +
+        "approximate reference. Respond with a single JSON object only, no prose or code fences.",
+    },
+    {
+      role: "user",
+      content:
+        "Analyze this pipeline task source and return a JSON object with these fields:\n" +
+        "- summary: one sentence describing what the task does\n" +
+        "- stages: array of { name: stage/function name, purpose: one sentence on its role }\n" +
+        "- artifacts.reads: array of { fileName, role } for artifacts the task reads\n" +
+        "- artifacts.writes: array of { fileName, role } for artifacts the task writes\n" +
+        "- models: array of { provider, method, stage } for LLM calls the task makes\n\n" +
+        "Use empty arrays when a section does not apply.\n\n" +
+        "Task source:\n```\n" +
+        code +
+        "\n```",
+    },
+  ];
+}
+
+export async function analyzeTask(
+  code: string,
+  opts?: { provider?: string; model?: string },
+): Promise<AnalysisResult> {
+  try {
+    const llm = getConfig().llm;
+    const configProvider = opts?.provider ?? llm.internalProvider;
+    const model = opts?.model ?? llm.internalModel;
+    const provider = toGatewayProvider(configProvider);
+
+    if (!getAvailableProviders()[provider]) {
+      return {
+        ...emptyAnalysis(),
+        analysisStatus: "unconfigured",
+        analysisError: `No API key configured for the internal analysis provider "${configProvider}". Set the provider's API key or configure PO_INTERNAL_LLM_PROVIDER.`,
+      };
+    }
+
+    const response = await chat({
+      provider,
+      model,
+      messages: buildMessages(code),
+      temperature: 0,
+      responseFormat: { type: "json_object" },
+    });
+
+    const analysis = TaskAnalysisSchema.parse(response.content);
+    return { ...analysis, analysisStatus: "ok" };
+  } catch (err) {
+    return {
+      ...emptyAnalysis(),
+      analysisStatus: "error",
+      analysisError: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/src/task-analysis/enrichers/schema-deducer.ts

@@ -4,10 +4,19 @@
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import { chat } from "../../llm/index.ts";
+import { getConfig } from "../../core/config.ts";
+import type { ProviderName } from "../../providers/types.ts";
 import type { ArtifactDescriptor, DeducedSchema } from "../types.ts";
 
 const ajv = addFormats(new Ajv());
 
+/** Maps a config provider key to its gateway provider name. */
+function toGatewayProvider(configName: string): ProviderName {
+  if (configName === "zai") return "zhipu";
+  if (configName === "claude-code") return "claudecode";
+  return configName as ProviderName;
+}
+
 export async function deduceArtifactSchema(
   taskCode: string,
   artifact: ArtifactDescriptor,
@@ -34,9 +43,11 @@ Respond with a JSON object with these fields:
     },
   ];
 
+  const llm = getConfig().llm;
+
   const response = await chat({
-    provider: "deepseek",
-    model: "deepseek-chat",
+    provider: toGatewayProvider(llm.internalProvider),
+    model: llm.internalModel,
     messages,
     temperature: 0,
     responseFormat: { type: "json_object" },

package/src/task-analysis/index.ts

@@ -1,40 +1,6 @@
-import { parseTaskSource } from "./parser.ts";
-import { extractStages } from "./extractors/stages.ts";
-import { extractArtifactReads, extractArtifactWrites } from "./extractors/artifacts.ts";
-import { extractLLMCalls } from "./extractors/llm-calls.ts";
-import type { TaskAnalysis } from "./types.ts";
-
-export function analyzeTask(
-  code: string,
-  taskFilePath?: string | null
-): TaskAnalysis {
-  const ast = parseTaskSource(code);
-  const stages = extractStages(ast);
-  const { reads, unresolvedReads } = extractArtifactReads(ast, code);
-  const { writes, unresolvedWrites } = extractArtifactWrites(ast, code);
-  const models = extractLLMCalls(ast);
-
-  return {
-    taskFilePath: taskFilePath ?? null,
-    stages,
-    artifacts: { reads, writes, unresolvedReads, unresolvedWrites },
-    models,
-  };
-}
-
-export { parseTaskSource } from "./parser.ts";
-export { extractStages } from "./extractors/stages.ts";
-export {
-  extractArtifactReads,
-  extractArtifactWrites,
-  extractCodeContext,
-} from "./extractors/artifacts.ts";
-export { extractLLMCalls } from "./extractors/llm-calls.ts";
-export { isInsideTryCatch, getStageName } from "./utils/ast.ts";
-
+export { analyzeTask } from "./analyzer.ts";
+export { TaskAnalysisRepository } from "./repository.ts";
 export { deduceArtifactSchema } from "./enrichers/schema-deducer.ts";
-export { resolveArtifactReference } from "./enrichers/artifact-resolver.ts";
 export { writeSchemaFiles } from "./enrichers/schema-writer.ts";
-export { writeAnalysisFile } from "./enrichers/analysis-writer.ts";
 
 export type * from "./types.ts";

package/src/task-analysis/repository.ts

@@ -0,0 +1,45 @@
+import { mkdir, rename } from "node:fs/promises";
+import { dirname } from "node:path";
+import path from "node:path";
+import type { PersistedTaskAnalysis } from "./types.ts";
+
+export const TaskAnalysisRepository = {
+  analysisPath(root: string, slug: string, taskName: string): string {
+    return path.join(root, "pipeline-config", slug, "tasks", `${taskName}.analysis.json`);
+  },
+
+  async write(
+    root: string,
+    slug: string,
+    taskName: string,
+    data: PersistedTaskAnalysis,
+  ): Promise<void> {
+    const filePath = this.analysisPath(root, slug, taskName);
+    await mkdir(dirname(filePath), { recursive: true });
+
+    const tmpPath = `${filePath}.tmp`;
+    await Bun.write(tmpPath, JSON.stringify(data, null, 2));
+    await rename(tmpPath, filePath);
+  },
+
+  async read(
+    root: string,
+    slug: string,
+    taskName: string,
+  ): Promise<PersistedTaskAnalysis | null> {
+    const filePath = this.analysisPath(root, slug, taskName);
+    const file = Bun.file(filePath);
+
+    if (!(await file.exists())) return null;
+
+    return (await file.json()) as PersistedTaskAnalysis;
+  },
+
+  async readFromPath(validatedPath: string): Promise<PersistedTaskAnalysis | null> {
+    const file = Bun.file(validatedPath);
+
+    if (!(await file.exists())) return null;
+
+    return (await file.json()) as PersistedTaskAnalysis;
+  },
+} as const;