@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.5

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

@@ -1,7 +1,42 @@
-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,
+  moonshot: false,
+  alibaba: false,
+  opencode: false,
+  "claude-code": 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 +57,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 +70,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 () => {

package/src/cli/__tests__/index.test.ts

@@ -1,14 +1,44 @@
 import { describe, it, expect, vi, beforeEach, afterEach, type MockInstance } from "vitest";
+import { mock } from "bun:test";
 import { mkdtemp, rm, mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { access } from "node:fs/promises";
 
+// Module mocks for the hidden-subcommand tests. These are evaluated when
+// the dynamic imports inside the hidden handlers first run. The CLI file
+// statically imports neither target, so the mocks are inert for the
+// existing tests. Note: this file uses bun:test's mock.module (not
+// vi.mock) because vitest's mock-hoist does not intercept dynamic
+// imports under the bun runtime. scripts/test.sh isolates this file
+// because of the mock.module literal token, which is the intended seam.
+const mockStartServer = vi.fn();
+const mockStartOrchestrator = vi.fn();
+const mockRunPipelineJob = vi.fn();
+
+mock.module("../../ui/server/index.ts", () => ({
+  startServer: mockStartServer,
+}));
+
+mock.module("../../core/orchestrator.ts", () => ({
+  startOrchestrator: mockStartOrchestrator,
+}));
+
+mock.module("../../core/pipeline-runner.ts", () => ({
+  runPipelineJob: mockRunPipelineJob,
+}));
+
 import {
   handleInit,
   handleAddPipeline,
   handleAddPipelineTask,
   handleSubmit,
+  handleStart,
+  handleStartUi,
+  handleStartOrchestrator,
+  handleRunJob,
+  handleStatus,
+  buildStartChildEnv,
   parseTaskIndex,
   serializeTaskIndex,
   buildUiCorsEnv,
@@ -66,14 +96,8 @@ describe("handleInit", () => {
 
   it("writes registry.json with empty pipelines", async () => {
     await handleInit(tmpDir);
-    const reg = await readJson(join(tmpDir, "registry.json"));
-    expect(reg).toEqual({ pipelines: {} });
-  });
-
-  it("writes registry.json with trailing newline", async () => {
-    await handleInit(tmpDir);
-    const text = await Bun.file(join(tmpDir, "registry.json")).text();
-    expect(text.endsWith("\n")).toBe(true);
+    const reg = await readJson(join(tmpDir, "pipeline-config", "registry.json"));
+    expect(reg).toEqual({ version: 1, pipelines: {} });
   });
 
   it("is idempotent — can be re-run without error", async () => {
@@ -130,21 +154,13 @@ describe("handleAddPipeline", () => {
 
   it("adds entry to registry.json", async () => {
     await handleAddPipeline("my-pipeline", tmpDir);
-    const reg = await readJson(join(tmpDir, "registry.json")) as { pipelines: Record<string, unknown> };
+    const reg = await readJson(join(tmpDir, "pipeline-config", "registry.json")) as { pipelines: Record<string, unknown> };
     expect(reg.pipelines["my-pipeline"]).toBeDefined();
     const entry = reg.pipelines["my-pipeline"] as Record<string, unknown>;
     expect(entry["name"]).toBe("my-pipeline");
     expect(entry["description"]).toBe("New pipeline");
   });
 
-  it("stores .ts paths in registry entry", async () => {
-    await handleAddPipeline("my-pipeline", tmpDir);
-    const reg = await readJson(join(tmpDir, "registry.json")) as { pipelines: Record<string, unknown> };
-    const entry = reg.pipelines["my-pipeline"] as Record<string, string>;
-    expect(entry["taskRegistryPath"]).toMatch(/index\.ts$/);
-    expect(entry["pipelinePath"]).toMatch(/pipeline\.json$/);
-  });
-
   it("exits with 1 on invalid slug", async () => {
     await expect(handleAddPipeline("INVALID", tmpDir)).rejects.toThrow("process.exit(1)");
     expect(exitSpy).toHaveBeenCalledWith(1);
@@ -329,8 +345,11 @@ describe("handleSubmit", () => {
     await Bun.write(
       join(tmpDir, "pipeline-config", "registry.json"),
       JSON.stringify({
+        version: 1,
         pipelines: {
           "test-pipeline": {
+            name: "Test Pipeline",
+            description: "test pipeline",
             configDir,
             tasksDir: join(configDir, "tasks"),
           },
@@ -360,6 +379,190 @@ describe("handleSubmit", () => {
   });
 });
 
+// ─── submit --root precedence ─────────────────────────────────────────────────
+
+describe("submit --root precedence", () => {
+  let rootFlag: string;
+  let rootEnv: string;
+  let rootCwd: string;
+  let exitSpy: MockInstance;
+  let cwdSpy: MockInstance;
+  const originalPoRoot = process.env["PO_ROOT"];
+
+  async function scaffoldWorkspace(dir: string): Promise<string> {
+    const configDir = join(dir, "pipeline-config", "test-pipeline");
+    await mkdir(configDir, { recursive: true });
+    await mkdir(join(dir, "pipeline-data", "pending"), { recursive: true });
+    await Bun.write(
+      join(dir, "pipeline-config", "registry.json"),
+      JSON.stringify({
+        version: 1,
+        pipelines: {
+          "test-pipeline": {
+            name: "Test Pipeline",
+            description: "test pipeline",
+            configDir,
+            tasksDir: join(configDir, "tasks"),
+          },
+        },
+      }),
+    );
+    await Bun.write(
+      join(configDir, "pipeline.json"),
+      JSON.stringify({ name: "test-pipeline", tasks: [] }),
+    );
+    const seedPath = join(dir, "seed.json");
+    await Bun.write(seedPath, JSON.stringify({ pipeline: "test-pipeline" }));
+    return seedPath;
+  }
+
+  async function pendingSeeds(dir: string): Promise<string[]> {
+    const entries = await readdir(join(dir, "pipeline-data", "pending"));
+    return entries.filter((f) => f.endsWith("-seed.json"));
+  }
+
+  beforeEach(async () => {
+    rootFlag = await mkdtemp(join(tmpdir(), "pop-submit-flag-"));
+    rootEnv = await mkdtemp(join(tmpdir(), "pop-submit-env-"));
+    rootCwd = await mkdtemp(join(tmpdir(), "pop-submit-cwd-"));
+    delete process.env["PO_ROOT"];
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(
+      (_code?: string | number | null | undefined) => {
+        throw new Error(`process.exit(${_code})`);
+      }
+    );
+    cwdSpy = vi.spyOn(process, "cwd").mockReturnValue(rootCwd);
+  });
+
+  afterEach(async () => {
+    await rm(rootFlag, { recursive: true, force: true });
+    await rm(rootEnv, { recursive: true, force: true });
+    await rm(rootCwd, { recursive: true, force: true });
+    exitSpy.mockRestore();
+    cwdSpy.mockRestore();
+    if (originalPoRoot === undefined) {
+      delete process.env["PO_ROOT"];
+    } else {
+      process.env["PO_ROOT"] = originalPoRoot;
+    }
+    vi.clearAllMocks();
+  });
+
+  it("writes the pending seed under --root when --root, PO_ROOT, and cwd all differ (AC-2 precedence)", async () => {
+    const flagSeed = await scaffoldWorkspace(rootFlag);
+    await scaffoldWorkspace(rootEnv);
+    await scaffoldWorkspace(rootCwd);
+
+    process.env["PO_ROOT"] = rootEnv;
+
+    await handleSubmit(flagSeed, { root: rootFlag });
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(await pendingSeeds(rootFlag)).toHaveLength(1);
+    expect(await pendingSeeds(rootEnv)).toHaveLength(0);
+    expect(await pendingSeeds(rootCwd)).toHaveLength(0);
+  });
+
+  it("writes the pending seed under PO_ROOT when PO_ROOT and cwd differ and --root is absent (AC-3 headline regression)", async () => {
+    const cwdSeed = await scaffoldWorkspace(rootCwd);
+    await scaffoldWorkspace(rootEnv);
+
+    process.env["PO_ROOT"] = rootEnv;
+
+    await handleSubmit(cwdSeed);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(await pendingSeeds(rootEnv)).toHaveLength(1);
+    expect(await pendingSeeds(rootCwd)).toHaveLength(0);
+  });
+
+  it("writes the pending seed under --root when --root is set without PO_ROOT (AC-3 second half)", async () => {
+    const flagSeed = await scaffoldWorkspace(rootFlag);
+    await scaffoldWorkspace(rootCwd);
+
+    await handleSubmit(flagSeed, { root: rootFlag });
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(await pendingSeeds(rootFlag)).toHaveLength(1);
+    expect(await pendingSeeds(rootCwd)).toHaveLength(0);
+  });
+});
+
+// ─── status --root precedence ─────────────────────────────────────────────────
+
+describe("status --root precedence", () => {
+  let rootFlag: string;
+  let rootEnv: string;
+  let rootCwd: string;
+  let cwdSpy: MockInstance;
+  let tableSpy: MockInstance;
+  const originalPoRoot = process.env["PO_ROOT"];
+
+  async function scaffoldPendingSeed(dir: string, jobId: string): Promise<void> {
+    await mkdir(join(dir, "pipeline-data", "pending"), { recursive: true });
+    await Bun.write(
+      join(dir, "pipeline-data", "pending", `${jobId}-seed.json`),
+      JSON.stringify({ name: jobId, pipeline: "test-pipeline" }),
+    );
+  }
+
+  function listedJobIds(): string[] {
+    const rows = tableSpy.mock.calls[0]?.[0] as Array<{ jobId?: string }> | undefined;
+    return rows?.map((row) => row.jobId).filter((jobId): jobId is string => typeof jobId === "string") ?? [];
+  }
+
+  beforeEach(async () => {
+    rootFlag = await mkdtemp(join(tmpdir(), "pop-status-flag-"));
+    rootEnv = await mkdtemp(join(tmpdir(), "pop-status-env-"));
+    rootCwd = await mkdtemp(join(tmpdir(), "pop-status-cwd-"));
+    delete process.env["PO_ROOT"];
+    cwdSpy = vi.spyOn(process, "cwd").mockReturnValue(rootCwd);
+    tableSpy = vi.spyOn(console, "table").mockImplementation(() => undefined);
+    await scaffoldPendingSeed(rootFlag, "flag-job");
+    await scaffoldPendingSeed(rootEnv, "env-job");
+    await scaffoldPendingSeed(rootCwd, "cwd-job");
+  });
+
+  afterEach(async () => {
+    await rm(rootFlag, { recursive: true, force: true });
+    await rm(rootEnv, { recursive: true, force: true });
+    await rm(rootCwd, { recursive: true, force: true });
+    cwdSpy.mockRestore();
+    tableSpy.mockRestore();
+    if (originalPoRoot === undefined) {
+      delete process.env["PO_ROOT"];
+    } else {
+      process.env["PO_ROOT"] = originalPoRoot;
+    }
+    vi.clearAllMocks();
+  });
+
+  it("lists jobs under --root when --root, PO_ROOT, and cwd all differ", async () => {
+    process.env["PO_ROOT"] = rootEnv;
+
+    await handleStatus(undefined, { root: rootFlag });
+
+    expect(listedJobIds()).toEqual(["flag-job"]);
+    expect(process.env["PO_ROOT"]).toBe(rootEnv);
+  });
+
+  it("lists jobs under PO_ROOT when --root is absent", async () => {
+    process.env["PO_ROOT"] = rootEnv;
+
+    await handleStatus(undefined);
+
+    expect(listedJobIds()).toEqual(["env-job"]);
+    expect(process.env["PO_ROOT"]).toBe(rootEnv);
+  });
+
+  it("lists jobs under cwd when --root and PO_ROOT are absent", async () => {
+    await handleStatus(undefined);
+
+    expect(listedJobIds()).toEqual(["cwd-job"]);
+    expect(process.env["PO_ROOT"]).toBeUndefined();
+  });
+});
+
 // ─── parseTaskIndex ───────────────────────────────────────────────────────────
 
 describe("parseTaskIndex", () => {
@@ -422,6 +625,123 @@ describe("serializeTaskIndex", () => {
   });
 });
 
+// ─── start --root handoff (AC-7) ────────────────────────────────────────────
+
+describe("start --root handoff", () => {
+  const originalPoRoot = process.env["PO_ROOT"];
+
+  beforeEach(() => {
+    delete process.env["PO_ROOT"];
+    mockStartServer.mockReset();
+    mockStartOrchestrator.mockReset();
+    mockStartOrchestrator.mockResolvedValue({ stop: vi.fn() });
+    mockRunPipelineJob.mockReset();
+  });
+
+  afterEach(() => {
+    if (originalPoRoot === undefined) {
+      delete process.env["PO_ROOT"];
+    } else {
+      process.env["PO_ROOT"] = originalPoRoot;
+    }
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  describe("buildStartChildEnv", () => {
+    it("forwards absoluteRoot to PO_ROOT in both child envs and sets PORT/NODE_ENV in the UI env", () => {
+      const { uiEnv, orchEnv } = buildStartChildEnv("/A", "4000");
+
+      expect(uiEnv["PO_ROOT"]).toBe("/A");
+      expect(uiEnv["PORT"]).toBe("4000");
+      expect(uiEnv["NODE_ENV"]).toBe("production");
+      expect(orchEnv["PO_ROOT"]).toBe("/A");
+      expect(orchEnv["NODE_ENV"]).toBe("production");
+      expect(orchEnv["PORT"]).toBeUndefined();
+    });
+
+    it("layers CORS options onto the UI env alongside PO_ROOT/PORT", () => {
+      const { uiEnv } = buildStartChildEnv("/A", "4000", {
+        port: "4000",
+        corsOrigins: "https://app.example",
+        corsAllowNullOrigin: true,
+      });
+
+      expect(uiEnv["PO_ROOT"]).toBe("/A");
+      expect(uiEnv["PORT"]).toBe("4000");
+      expect(uiEnv["PO_CORS_ORIGINS"]).toBe("https://app.example");
+      expect(uiEnv["PO_CORS_ALLOW_NULL_ORIGIN"]).toBe("1");
+    });
+  });
+
+  describe("handleStart error path", () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let exitSpy: MockInstance<any>;
+
+    beforeEach(() => {
+      exitSpy = vi.spyOn(process, "exit").mockImplementation(
+        (_code?: string | number | null | undefined) => {
+          throw new Error(`process.exit(${_code})`);
+        },
+      );
+    });
+
+    it("exits 1 with the resolver message when --root and PO_ROOT are both absent", async () => {
+      await expect(handleStart(undefined, "4000")).rejects.toThrow("process.exit(1)");
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("hidden subcommand boot delegation", () => {
+    it("handleStartUi calls startServer with dataDir: undefined when PO_ROOT is unset (no cwd fallback)", async () => {
+      await handleStartUi();
+
+      expect(mockStartServer).toHaveBeenCalledTimes(1);
+      expect(mockStartServer).toHaveBeenCalledWith({
+        dataDir: undefined,
+        port: 4000,
+      });
+    });
+
+    it("handleStartUi calls startServer with the transported PO_ROOT when set", async () => {
+      process.env["PO_ROOT"] = "/transported";
+
+      await handleStartUi();
+
+      expect(mockStartServer).toHaveBeenCalledTimes(1);
+      expect(mockStartServer).toHaveBeenCalledWith({
+        dataDir: "/transported",
+        port: 4000,
+      });
+    });
+
+    it("handleStartOrchestrator calls startOrchestrator with dataDir: undefined when PO_ROOT is unset (no manual guard)", async () => {
+      await handleStartOrchestrator();
+
+      expect(mockStartOrchestrator).toHaveBeenCalledTimes(1);
+      expect(mockStartOrchestrator).toHaveBeenCalledWith({ dataDir: undefined });
+    });
+
+    it("handleStartOrchestrator calls startOrchestrator with the transported PO_ROOT when set", async () => {
+      process.env["PO_ROOT"] = "/transported";
+
+      await handleStartOrchestrator();
+
+      expect(mockStartOrchestrator).toHaveBeenCalledTimes(1);
+      expect(mockStartOrchestrator).toHaveBeenCalledWith({ dataDir: "/transported" });
+    });
+
+    it("handleRunJob calls runPipelineJob(jobId) without reading env", async () => {
+      await handleRunJob("job-123");
+
+      expect(mockRunPipelineJob).toHaveBeenCalledTimes(1);
+      expect(mockRunPipelineJob).toHaveBeenCalledWith("job-123");
+    });
+  });
+});
+
 // ─── buildUiCorsEnv ─────────────────────────────────────────────────────────
 
 describe("buildUiCorsEnv", () => {

package/src/cli/__tests__/types.test.ts

@@ -1,29 +1,11 @@
 import { describe, it, expect } from "vitest";
 import type {
-  Registry,
-  PipelineRegistryEntry,
   PipelineConfig,
   ReexecArgs,
   TaskIndex,
 } from "../types.js";
 
 describe("CLI types", () => {
-  it("Registry with empty pipelines is valid", () => {
-    const registry: Registry = { pipelines: {} };
-    expect(registry.pipelines).toEqual({});
-  });
-
-  it("Registry with pipeline entries is valid", () => {
-    const entry: PipelineRegistryEntry = {
-      name: "my-pipeline",
-      description: "A test pipeline",
-      pipelinePath: "./pipeline-config/my-pipeline/pipeline.json",
-      taskRegistryPath: "./pipeline-config/my-pipeline/tasks/index.ts",
-    };
-    const registry: Registry = { pipelines: { "my-pipeline": entry } };
-    expect(registry.pipelines["my-pipeline"]).toBe(entry);
-  });
-
   it("PipelineConfig with all required fields is valid", () => {
     const config: PipelineConfig = {
       name: "my-pipeline",

package/src/cli/__tests__/update-pipeline-json.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, mkdir, rm } from "node:fs/promises";
+import { mkdtemp, mkdir, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { JsonFileError } from "../../core/json-file.ts";
 import { updatePipelineJson } from "../update-pipeline-json.ts";
 
 describe("updatePipelineJson", () => {
@@ -18,7 +19,7 @@ describe("updatePipelineJson", () => {
     await rm(tmpDir, { recursive: true, force: true });
   });
 
-  it("appends a task slug to existing tasks", async () => {
+  it("appends a task slug, preserving name/version/description and existing tasks", async () => {
     const filePath = join(pipelineDir, "pipeline.json");
     await Bun.write(
       filePath,
@@ -32,6 +33,9 @@ describe("updatePipelineJson", () => {
     await updatePipelineJson(tmpDir, "test-pipeline", "b");
 
     const result = JSON.parse(await Bun.file(filePath).text());
+    expect(result.name).toBe("test");
+    expect(result.version).toBe("1.0.0");
+    expect(result.description).toBe("Test");
     expect(result.tasks).toEqual(["a", "b"]);
   });
 
@@ -53,15 +57,21 @@ describe("updatePipelineJson", () => {
     expect(result.tasks).toEqual(["a", "b"]);
   });
 
-  it("creates a minimal config with the task when pipeline.json is missing", async () => {
+  it("throws and leaves the file unchanged when pipeline.json is malformed", async () => {
     const filePath = join(pipelineDir, "pipeline.json");
+    const original = "{ not valid json ";
+    await Bun.write(filePath, original);
 
-    await updatePipelineJson(tmpDir, "test-pipeline", "b");
+    await expect(updatePipelineJson(tmpDir, "test-pipeline", "b")).rejects.toBeInstanceOf(
+      JsonFileError
+    );
 
-    const result = JSON.parse(await Bun.file(filePath).text());
-    expect(result.name).toBe("test-pipeline");
-    expect(result.version).toBe("1.0.0");
-    expect(result.description).toBe("New pipeline");
-    expect(result.tasks).toEqual(["b"]);
+    expect(await readFile(filePath, "utf8")).toBe(original);
+  });
+
+  it("throws when pipeline.json is missing", async () => {
+    await expect(updatePipelineJson(tmpDir, "test-pipeline", "b")).rejects.toBeInstanceOf(
+      JsonFileError
+    );
   });
 });

package/src/cli/analyze-task.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { analyzeTask } from "../task-analysis/index.ts";
+import { analyzeTask } from "../task-analysis/analyzer.ts";
 
 export async function analyzeTaskFile(taskPath: string): Promise<void> {
   const absolutePath = path.resolve(taskPath);
@@ -17,17 +17,6 @@ export async function analyzeTaskFile(taskPath: string): Promise<void> {
     throw err;
   }
 
-  try {
-    const result = analyzeTask(code, absolutePath);
-    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
-  } catch (err) {
-    const isDev =
-      process.env.NODE_ENV === "development" || process.env.DEBUG_TASK_ANALYSIS === "1";
-    if (isDev && err instanceof Error && err.stack) {
-      console.error(err.stack);
-    } else {
-      console.error(err instanceof Error ? err.message : String(err));
-    }
-    process.exit(1);
-  }
+  const result = await analyzeTask(code);
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
 }