@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/api/index.ts

@@ -1,33 +1,28 @@
 import path from "node:path";
-import { mkdir, readdir, rename, stat } from "node:fs/promises";
-import { resolvePipelinePaths, getPendingSeedPath } from "../config/paths";
+import { readdir, stat } from "node:fs/promises";
+import { resolvePipelinePaths, resolveWorkspaceRoot } from "../config/paths";
 import type { PipelinePaths } from "../config/paths";
-import { getPipelineConfig } from "../core/config";
-import { deriveJobStatusFromTasks } from "../config/statuses";
-import { SEED_PATTERN } from "../core/orchestrator";
+import { submitSeed } from "../core/job-submission.ts";
+import type { SubmitResult } from "../core/job-submission.ts";
+import { normalizeJobView } from "../core/job-view";
+import type { JobView } from "../core/job-view";
+import { parseSeedFilename } from "../core/seed-naming.ts";
+import { readJobStatusResult, STATUS_FILENAME, type StatusReadResult } from "../core/status-writer";
 
-/** Result of a successful job submission. */
-export interface SubmitSuccessResult {
-  success: true;
-  jobId: string;
-  jobName: string;
-}
-
-/** Result of a failed job submission. */
-export interface SubmitFailureResult {
-  success: false;
-  message: string;
-}
-
-export type SubmitResult = SubmitSuccessResult | SubmitFailureResult;
+export type { SubmitResult, SubmitSuccessResult, SubmitFailureResult } from "../core/job-submission.ts";
 
 /** Options for submitJobWithValidation. */
 export interface SubmitJobOptions {
-  dataDir: string;
+  root?: string;
   seedObject: unknown;
 }
 
-/** Job status record returned by getStatus. */
+/**
+ * Job status record returned by getStatus.
+ *
+ * Additive optional fields (present only when the on-disk status is unreadable):
+ * `readable: false` and `error: { code, message, path }`. Absent ⇒ normal/readable.
+ */
 export interface JobStatusRecord {
   jobId: string;
   jobName: string;
@@ -40,28 +35,11 @@ export interface JobStatusRecord {
 /** Orchestrator construction options. */
 export interface OrchestratorOptions {
   autoStart: boolean;
+  root?: string;
 }
 
 // ─── Private Helpers ──────────────────────────────────────────────────────────
 
-async function atomicWriteJson(filePath: string, data: unknown): Promise<void> {
-  const tmp = `${filePath}.${Date.now()}.tmp`;
-  await Bun.write(tmp, JSON.stringify(data, null, 2));
-  await rename(tmp, filePath);
-}
-
-function assertSeedObject(value: unknown): asserts value is Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("seed must be a JSON object");
-  }
-}
-
-function assertPipelineSlug(value: unknown): asserts value is string {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error("seed.pipeline must be a non-empty string");
-  }
-}
-
 async function safeReaddir(dirPath: string): Promise<string[]> {
   try {
     return await readdir(dirPath);
@@ -71,66 +49,77 @@ async function safeReaddir(dirPath: string): Promise<string[]> {
   }
 }
 
+function locationForPath(paths: PipelinePaths, jobDir: string): "current" | "complete" {
+  if (jobDir.startsWith(paths.current + path.sep) || jobDir === paths.current) return "current";
+  return "complete";
+}
+
 async function readJsonFile<T = unknown>(filePath: string): Promise<T> {
   const text = await Bun.file(filePath).text();
   return JSON.parse(text) as T;
 }
 
-function mapStatusToRecord(data: Record<string, unknown>): JobStatusRecord {
-  const { id, name, pipeline, state, createdAt, ...rest } = data;
-  return {
-    jobId: String(id ?? ""),
-    jobName: String(name ?? id ?? ""),
-    pipeline: String(pipeline ?? ""),
-    state: String(state ?? ""),
-    createdAt: String(createdAt ?? ""),
+function toJobStatusRecord(view: JobView): JobStatusRecord {
+  const {
+    id: _id,
+    jobId: _jobId,
+    name,
+    title: _title,
+    status,
+    pipeline,
+    createdAt,
+    readable,
+    error,
+    ...rest
+  } = view;
+  const record: JobStatusRecord = {
+    jobId: view.jobId,
+    jobName: name,
+    pipeline: pipeline ?? "",
+    state: status,
+    createdAt: createdAt ?? "",
     ...rest,
   };
+  if (readable !== undefined) record["readable"] = readable;
+  if (error !== undefined) record["error"] = error;
+  return record;
 }
 
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export async function submitJobWithValidation(
-  opts: SubmitJobOptions,
-): Promise<SubmitResult> {
-  const rootDir = path.resolve(opts.dataDir);
-
-  try {
-    assertSeedObject(opts.seedObject);
-    assertPipelineSlug(opts.seedObject["pipeline"]);
-  } catch (err) {
-    return { success: false, message: (err as Error).message };
-  }
-
-  const seed = opts.seedObject as Record<string, unknown>;
-
-  if (seed["name"] !== undefined) {
-    if (typeof seed["name"] !== "string" || seed["name"].length === 0) {
-      return { success: false, message: "seed.name must be a non-empty string if provided" };
-    }
-  }
+function buildCorruptPlaceholder(jobDir: string, jobId: string): JobStatusRecord {
+  const statusPath = path.join(jobDir, STATUS_FILENAME);
+  return {
+    jobId,
+    jobName: jobId,
+    pipeline: "",
+    state: "failed",
+    createdAt: "",
+    readable: false,
+    error: {
+      code: "STATUS_CORRUPT",
+      message:
+        `Status file is unreadable (corrupt). ` +
+        `Repair or delete ${statusPath} for job "${jobId}" to recover.`,
+      path: statusPath,
+    },
+  };
+}
 
+async function readStatusForApi(jobDir: string, label: string): Promise<StatusReadResult | null> {
   try {
-    getPipelineConfig(seed["pipeline"] as string, rootDir);
+    return await readJobStatusResult(jobDir);
   } catch (err) {
-    return { success: false, message: (err as Error).message };
+    console.warn(`[api] skipping unreadable status ${label}: ${(err as Error).message}`);
+    return null;
   }
+}
 
-  const jobId = crypto.randomUUID();
-  const jobName = (typeof seed["name"] === "string" && seed["name"].length > 0)
-    ? seed["name"]
-    : jobId;
-  const pendingPath = getPendingSeedPath(rootDir, jobId);
-
-  await mkdir(path.dirname(pendingPath), { recursive: true });
-
-  try {
-    await atomicWriteJson(pendingPath, opts.seedObject);
-  } catch (err) {
-    throw new Error(`failed to write seed file for job ${jobId}: ${(err as Error).message}`);
-  }
+// ─── Public API ───────────────────────────────────────────────────────────────
 
-  return { success: true, jobId, jobName };
+export async function submitJobWithValidation(
+  opts: SubmitJobOptions,
+): Promise<SubmitResult> {
+  const rootDir = resolveWorkspaceRoot(opts.root);
+  return submitSeed({ root: rootDir, seedObject: opts.seedObject });
 }
 
 export class PipelineOrchestrator {
@@ -140,20 +129,22 @@ export class PipelineOrchestrator {
 
   constructor(opts: OrchestratorOptions) {
     this.autoStart = opts.autoStart;
-    this.root = path.resolve(process.env["PO_ROOT"] ?? process.cwd());
+    this.root = resolveWorkspaceRoot(opts.root);
     this.paths = resolvePipelinePaths(this.root);
   }
 
   async getStatus(jobName: string): Promise<JobStatusRecord> {
     // 1. Direct jobId lookup in current, then complete
     for (const dir of [this.paths.current, this.paths.complete]) {
-      const statusPath = path.join(dir, jobName, "tasks-status.json");
-      try {
-        const data = await readJsonFile<Record<string, unknown>>(statusPath);
-        return mapStatusToRecord(data);
-      } catch {
-        // not found here, continue
+      const jobDir = path.join(dir, jobName);
+      const result = await readStatusForApi(jobDir, jobName);
+      if (!result) continue;
+      if (result.ok) {
+        return toJobStatusRecord(
+          normalizeJobView(result.value, jobName, locationForPath(this.paths, jobDir)),
+        );
       }
+      if (result.reason === "corrupt") return buildCorruptPlaceholder(jobDir, jobName);
     }
 
     // 2. Name scan fallback
@@ -161,14 +152,14 @@ export class PipelineOrchestrator {
       const entries = await safeReaddir(dir);
       for (const entry of entries) {
         if (entry === ".gitkeep") continue;
-        const statusPath = path.join(dir, entry, "tasks-status.json");
-        try {
-          const data = await readJsonFile<Record<string, unknown>>(statusPath);
-          if (data["name"] === jobName) {
-            return mapStatusToRecord(data);
-          }
-        } catch {
-          // skip unreadable entries
+        const jobDir = path.join(dir, entry);
+        const result = await readStatusForApi(jobDir, entry);
+        if (!result) continue;
+        if (!result.ok) continue;
+        if (result.value["name"] === jobName) {
+          return toJobStatusRecord(
+            normalizeJobView(result.value, entry, locationForPath(this.paths, jobDir)),
+          );
         }
       }
     }
@@ -176,10 +167,8 @@ export class PipelineOrchestrator {
     // 3. Pending fallback
     const pendingFiles = await safeReaddir(this.paths.pending);
     for (const file of pendingFiles) {
-      const match = file.match(SEED_PATTERN);
-      if (!match) continue;
-      const id = match[1]!;
-      if (id !== jobName) continue;
+      const id = parseSeedFilename(file);
+      if (id === null || id !== jobName) continue;
 
       const filePath = path.join(this.paths.pending, file);
       const seed = await readJsonFile<Record<string, unknown>>(filePath);
@@ -202,9 +191,8 @@ export class PipelineOrchestrator {
     // Pending jobs
     const pendingFiles = await safeReaddir(this.paths.pending);
     for (const file of pendingFiles) {
-      const match = file.match(SEED_PATTERN);
-      if (!match) continue;
-      const id = match[1]!;
+      const id = parseSeedFilename(file);
+      if (id === null) continue;
       const filePath = path.join(this.paths.pending, file);
       try {
         const seed = await readJsonFile<Record<string, unknown>>(filePath);
@@ -225,35 +213,28 @@ export class PipelineOrchestrator {
     const currentEntries = await safeReaddir(this.paths.current);
     for (const entry of currentEntries) {
       if (entry === ".gitkeep") continue;
-      const statusPath = path.join(this.paths.current, entry, "tasks-status.json");
-      try {
-        const data = await readJsonFile<Record<string, unknown>>(statusPath);
-        const tasks = data["tasks"];
-        const taskArray = tasks && typeof tasks === "object" && !Array.isArray(tasks)
-          ? Object.values(tasks as Record<string, { state: unknown }>)
-          : [];
-        const state = deriveJobStatusFromTasks(taskArray);
-        const record = mapStatusToRecord(data);
-        record.state = state;
-        results.push(record);
-      } catch (err) {
-        console.warn(`[api] skipping unreadable current job ${entry}: ${(err as Error).message}`);
+      const jobDir = path.join(this.paths.current, entry);
+      const result = await readStatusForApi(jobDir, entry);
+      if (!result) continue;
+      if (!result.ok) {
+        if (result.reason === "corrupt") results.push(buildCorruptPlaceholder(jobDir, entry));
+        continue;
       }
+      results.push(toJobStatusRecord(normalizeJobView(result.value, entry, "current")));
     }
 
     // Complete jobs
     const completeEntries = await safeReaddir(this.paths.complete);
     for (const entry of completeEntries) {
       if (entry === ".gitkeep") continue;
-      const statusPath = path.join(this.paths.complete, entry, "tasks-status.json");
-      try {
-        const data = await readJsonFile<Record<string, unknown>>(statusPath);
-        const record = mapStatusToRecord(data);
-        record.state = "complete";
-        results.push(record);
-      } catch (err) {
-        console.warn(`[api] skipping unreadable complete job ${entry}: ${(err as Error).message}`);
+      const jobDir = path.join(this.paths.complete, entry);
+      const result = await readStatusForApi(jobDir, entry);
+      if (!result) continue;
+      if (!result.ok) {
+        if (result.reason === "corrupt") results.push(buildCorruptPlaceholder(jobDir, entry));
+        continue;
       }
+      results.push(toJobStatusRecord(normalizeJobView(result.value, entry, "complete")));
     }
 
     return results;

package/src/cli/__tests__/analyze-task.test.ts

@@ -1,7 +1,43 @@
-import { describe, it, expect, beforeEach, afterEach, spyOn } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach, spyOn, mock } from "bun:test";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { ChatResponse, ProviderAvailability } from "../../providers/types.ts";
+
+// Mock the gateway boundary so the analyzer produces a deterministic, valid
+// result without a real LLM call. (See task-analysis/__tests__/analyzer.test.ts.)
+const availability: ProviderAvailability = {
+  openai: false,
+  deepseek: true,
+  anthropic: false,
+  gemini: false,
+  zai: false,
+  zhipu: false,
+  claudecode: false,
+  moonshot: false,
+  alibaba: false,
+  opencode: false,
+  mock: false,
+};
+
+const VALID_ANALYSIS = {
+  summary: "Ingests raw data and writes a processed artifact.",
+  stages: [{ name: "ingestion", purpose: "Reads raw input and normalizes it." }],
+  artifacts: {
+    reads: [{ fileName: "seed.json", role: "raw input" }],
+    writes: [{ fileName: "processed.json", role: "normalized output" }],
+  },
+  models: [{ provider: "deepseek", method: "chat", stage: "ingestion" }],
+};
+
+mock.module("../../llm/index.ts", () => ({
+  chat: (): Promise<ChatResponse> =>
+    Promise.resolve({
+      content: VALID_ANALYSIS,
+      usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2, source: "reported" },
+    }),
+  getAvailableProviders: () => availability,
+}));
 
 describe("analyzeTaskFile", () => {
   let tmpDir: string;
@@ -22,11 +58,11 @@ describe("analyzeTaskFile", () => {
     stdoutSpy.mockRestore();
   });
 
-  it("outputs JSON result for a valid task file", async () => {
+  it("prints a status-tagged analysis as JSON for a sample file", async () => {
     const taskFile = join(tmpDir, "task.ts");
     await writeFile(
       taskFile,
-      'export async function ingestion({ io, llm }) { await io.readArtifact("seed.json"); await llm.openai.complete({ prompt: "json" }); }',
+      'export async function ingestion({ io, llm }) { await io.readArtifact("seed.json"); }',
     );
 
     const { analyzeTaskFile } = await import("../analyze-task.ts");
@@ -35,10 +71,7 @@ describe("analyzeTaskFile", () => {
     expect(stdoutSpy).toHaveBeenCalledTimes(1);
     const written = (stdoutSpy.mock.calls[0] as [string])[0];
     const parsed = JSON.parse(written);
-    expect(parsed.taskFilePath).toBe(taskFile);
-    expect(parsed.stages).toEqual([{ name: "ingestion", order: 1, isAsync: true }]);
-    expect(parsed.artifacts.reads).toEqual([{ fileName: "seed.json", stage: "ingestion", required: true }]);
-    expect(parsed.models).toEqual([{ provider: "openai", method: "complete", stage: "ingestion" }]);
+    expect(parsed.analysisStatus).toBe("ok");
   });
 
   it("calls process.exit(1) for a non-existent file", async () => {