agentic-forge 0.0.0

package/tests/parser.test.ts

@@ -0,0 +1,290 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { WorkflowParseError, WorkflowParser } from "../src/parser.js";
+
+// --- Fixtures ---
+
+const sampleWorkflowYaml = `
+name: test-workflow
+version: "1.0"
+description: A test workflow
+steps:
+  - name: test-step
+    type: prompt
+    prompt: "Test prompt"
+`;
+
+const sampleParallelWorkflowYaml = `
+name: parallel-workflow
+version: "1.0"
+description: A workflow with parallel steps
+steps:
+  - name: parallel-step
+    type: parallel
+    steps:
+      - name: branch-a
+        type: serial
+        steps:
+          - name: task-a1
+            type: prompt
+            prompt: "Task A1"
+      - name: branch-b
+        type: serial
+        steps:
+          - name: task-b1
+            type: prompt
+            prompt: "Task B1"
+`;
+
+const sampleConditionalWorkflowYaml = `
+name: conditional-workflow
+version: "1.0"
+description: A workflow with conditional steps
+variables:
+  - name: run_tests
+    type: boolean
+    default: true
+steps:
+  - name: check-tests
+    type: conditional
+    condition: "variables.run_tests"
+    then:
+      - name: run-tests
+        type: prompt
+        prompt: "Run tests"
+    else:
+      - name: skip-tests
+        type: prompt
+        prompt: "Tests skipped"
+`;
+
+function makeTempDir(): string {
+	const dir = path.join(
+		tmpdir(),
+		`agentic-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+describe("WorkflowParser", () => {
+	let tempDir: string;
+
+	beforeEach(() => {
+		tempDir = makeTempDir();
+	});
+
+	it("should parse a minimal workflow from file", () => {
+		const filePath = path.join(tempDir, "workflow.yaml");
+		writeFileSync(filePath, sampleWorkflowYaml);
+
+		const parser = new WorkflowParser();
+		const workflow = parser.parseFile(filePath);
+
+		expect(workflow.name).toBe("test-workflow");
+		expect(workflow.version).toBe("1.0");
+		expect(workflow.description).toBe("A test workflow");
+		expect(workflow.steps).toHaveLength(1);
+		expect(workflow.steps[0].name).toBe("test-step");
+		expect(workflow.steps[0].type).toBe("prompt");
+		expect(workflow.steps[0].prompt).toBe("Test prompt");
+	});
+
+	it("should parse workflow from string", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(sampleWorkflowYaml);
+
+		expect(workflow.name).toBe("test-workflow");
+		expect(workflow.steps).toHaveLength(1);
+	});
+
+	it("should throw on missing name field", () => {
+		const filePath = path.join(tempDir, "workflow.yaml");
+		writeFileSync(filePath, "steps: []");
+
+		const parser = new WorkflowParser();
+		expect(() => parser.parseFile(filePath)).toThrow(WorkflowParseError);
+		expect(() => parser.parseFile(filePath)).toThrow("Missing required field: name");
+	});
+
+	it("should throw on invalid YAML syntax", () => {
+		const filePath = path.join(tempDir, "workflow.yaml");
+		writeFileSync(filePath, "name: [invalid yaml");
+
+		const parser = new WorkflowParser();
+		expect(() => parser.parseFile(filePath)).toThrow(WorkflowParseError);
+		expect(() => parser.parseFile(filePath)).toThrow("Invalid YAML");
+	});
+
+	it("should throw on nonexistent file", () => {
+		const filePath = path.join(tempDir, "nonexistent.yaml");
+
+		const parser = new WorkflowParser();
+		expect(() => parser.parseFile(filePath)).toThrow(WorkflowParseError);
+		expect(() => parser.parseFile(filePath)).toThrow("Workflow file not found");
+	});
+
+	it("should throw on invalid step type", () => {
+		const filePath = path.join(tempDir, "workflow.yaml");
+		writeFileSync(
+			filePath,
+			`
+name: test
+steps:
+  - name: bad-step
+    type: invalid-type
+`,
+		);
+
+		const parser = new WorkflowParser();
+		expect(() => parser.parseFile(filePath)).toThrow(WorkflowParseError);
+		expect(() => parser.parseFile(filePath)).toThrow("Invalid step type");
+	});
+
+	it("should parse workflow with parallel steps", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(sampleParallelWorkflowYaml);
+
+		expect(workflow.name).toBe("parallel-workflow");
+		expect(workflow.steps).toHaveLength(1);
+
+		const parallelStep = workflow.steps[0];
+		expect(parallelStep.type).toBe("parallel");
+		expect(parallelStep.steps).toHaveLength(2);
+		expect(parallelStep.steps[0].name).toBe("branch-a");
+		expect(parallelStep.steps[0].type).toBe("serial");
+	});
+
+	it("should parse workflow with conditional steps", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(sampleConditionalWorkflowYaml);
+
+		expect(workflow.name).toBe("conditional-workflow");
+		expect(workflow.variables).toHaveLength(1);
+		expect(workflow.variables[0].name).toBe("run_tests");
+		expect(workflow.variables[0].type).toBe("boolean");
+		expect(workflow.variables[0].default).toBe(true);
+
+		const conditionalStep = workflow.steps[0];
+		expect(conditionalStep.type).toBe("conditional");
+		expect(conditionalStep.condition).toBe("variables.run_tests");
+		expect(conditionalStep.thenSteps).toHaveLength(1);
+		expect(conditionalStep.elseSteps).toHaveLength(1);
+	});
+
+	it("should throw on non-dict workflow", () => {
+		const parser = new WorkflowParser();
+		expect(() => parser.parseString("- item1\n- item2")).toThrow("must be a dictionary");
+	});
+
+	it("should throw on nested parallel steps", () => {
+		const filePath = path.join(tempDir, "workflow.yaml");
+		writeFileSync(
+			filePath,
+			`
+name: nested-parallel
+steps:
+  - name: outer-parallel
+    type: parallel
+    steps:
+      - name: inner-parallel
+        type: parallel
+        steps: []
+`,
+		);
+
+		const parser = new WorkflowParser();
+		expect(() => parser.parseFile(filePath)).toThrow("Nested parallel steps");
+	});
+});
+
+describe("WorkflowParser settings", () => {
+	it("should apply default settings", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString("name: test\nsteps: []");
+
+		expect(workflow.settings.maxRetry).toBe(3);
+		expect(workflow.settings.timeoutMinutes).toBe(60);
+		expect(workflow.settings.trackProgress).toBe(true);
+		expect(workflow.settings.git.enabled).toBe(false);
+	});
+
+	it("should parse custom settings", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(`
+name: test
+settings:
+  max-retry: 5
+  timeout-minutes: 120
+  track-progress: false
+  git:
+    enabled: true
+    worktree: true
+    branch-prefix: custom
+steps: []
+`);
+
+		expect(workflow.settings.maxRetry).toBe(5);
+		expect(workflow.settings.timeoutMinutes).toBe(120);
+		expect(workflow.settings.trackProgress).toBe(false);
+		expect(workflow.settings.git.enabled).toBe(true);
+		expect(workflow.settings.git.worktree).toBe(true);
+		expect(workflow.settings.git.branchPrefix).toBe("custom");
+	});
+
+	it("should parse workflow-level model setting", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(`
+name: test
+settings:
+  model: opus
+steps: []
+`);
+
+		expect(workflow.settings.model).toBe("opus");
+	});
+
+	it("should default model to null when not specified", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString("name: test\nsteps: []");
+
+		expect(workflow.settings.model).toBeNull();
+	});
+});
+
+describe("WorkflowParser outputs", () => {
+	it("should parse workflow outputs", () => {
+		const parser = new WorkflowParser();
+		const workflow = parser.parseString(`
+name: test
+steps: []
+outputs:
+  - name: summary
+    template: summary.md.j2
+    path: output/summary.md
+    when: completed
+`);
+
+		expect(workflow.outputs).toHaveLength(1);
+		const output = workflow.outputs[0];
+		expect(output.name).toBe("summary");
+		expect(output.template).toBe("summary.md.j2");
+		expect(output.path).toBe("output/summary.md");
+		expect(output.when).toBe("completed");
+	});
+
+	it("should throw on missing required output fields", () => {
+		const parser = new WorkflowParser();
+		expect(() =>
+			parser.parseString(`
+name: test
+steps: []
+outputs:
+  - name: summary
+    template: summary.md.j2
+`),
+		).toThrow("Missing required field");
+	});
+});

package/tests/progress.test.ts

@@ -0,0 +1,345 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	STEP_STATUS,
+	WORKFLOW_STATUS,
+	createProgress,
+	dictToProgress,
+	generateWorkflowId,
+	getProgressPath,
+	loadProgress,
+	prepareForResume,
+	progressToDict,
+	saveProgress,
+	updateStepCompleted,
+	updateStepFailed,
+	updateStepSkipped,
+	updateStepStarted,
+} from "../src/progress.js";
+import type { StepProgress, WorkflowProgress } from "../src/types.js";
+
+function makeTempDir(): string {
+	const dir = path.join(
+		tmpdir(),
+		`agentic-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+describe("WorkflowStatus constants", () => {
+	it("should have all expected values", () => {
+		expect(WORKFLOW_STATUS.PENDING).toBe("pending");
+		expect(WORKFLOW_STATUS.RUNNING).toBe("running");
+		expect(WORKFLOW_STATUS.COMPLETED).toBe("completed");
+		expect(WORKFLOW_STATUS.FAILED).toBe("failed");
+		expect(WORKFLOW_STATUS.PAUSED).toBe("paused");
+		expect(WORKFLOW_STATUS.CANCELED).toBe("canceled");
+	});
+});
+
+describe("StepStatus constants", () => {
+	it("should have all expected values", () => {
+		expect(STEP_STATUS.PENDING).toBe("pending");
+		expect(STEP_STATUS.RUNNING).toBe("running");
+		expect(STEP_STATUS.COMPLETED).toBe("completed");
+		expect(STEP_STATUS.FAILED).toBe("failed");
+		expect(STEP_STATUS.SKIPPED).toBe("skipped");
+	});
+});
+
+describe("generateWorkflowId", () => {
+	it("should follow expected format", () => {
+		const id = generateWorkflowId("test-workflow");
+		const parts = id.split("-");
+		expect(parts.length).toBeGreaterThanOrEqual(4);
+		expect(parts[0]).toHaveLength(8); // Date
+		expect(parts[1]).toHaveLength(6); // Time
+		expect(id).toContain("test");
+		expect(id).toContain("workflow");
+	});
+
+	it("should sanitize spaces", () => {
+		const id = generateWorkflowId("my test workflow");
+		expect(id).not.toContain(" ");
+		expect(id).toContain("my-test-workflow");
+	});
+
+	it("should sanitize underscores", () => {
+		const id = generateWorkflowId("my_test_workflow");
+		expect(id).not.toContain("_");
+		expect(id).toContain("my-test-workflow");
+	});
+
+	it("should remove special characters", () => {
+		const id = generateWorkflowId("test@workflow#name!");
+		expect(id).not.toContain("@");
+		expect(id).not.toContain("#");
+		expect(id).not.toContain("!");
+	});
+
+	it("should produce valid IDs ending with workflow name", () => {
+		const id1 = generateWorkflowId("test");
+		const id2 = generateWorkflowId("test");
+		expect(id1).toMatch(/-test$/);
+		expect(id2).toMatch(/-test$/);
+	});
+});
+
+describe("getProgressPath", () => {
+	it("should return correct path", () => {
+		const tempDir = makeTempDir();
+		const p = getProgressPath("20260111-143052-test-workflow", tempDir);
+		const expected = path.join(
+			tempDir,
+			"agentic",
+			"outputs",
+			"20260111-143052-test-workflow",
+			"progress.json",
+		);
+		expect(p).toBe(expected);
+	});
+
+	it("should use cwd when no root specified", () => {
+		const p = getProgressPath("test-workflow");
+		expect(p).toContain("test-workflow");
+		expect(p).toMatch(/progress\.json$/);
+	});
+});
+
+describe("createProgress", () => {
+	it("should create basic progress document", () => {
+		const progress = createProgress("test-id", "test-workflow", ["step1", "step2", "step3"], {
+			var1: "value1",
+		});
+
+		expect(progress.workflowId).toBe("test-id");
+		expect(progress.workflowName).toBe("test-workflow");
+		expect(progress.status).toBe(WORKFLOW_STATUS.RUNNING);
+		expect(progress.pendingSteps).toEqual(["step1", "step2", "step3"]);
+		expect(progress.variables).toEqual({ var1: "value1" });
+		expect(progress.startedAt).toBeTruthy();
+		expect(progress.completedSteps).toEqual([]);
+		expect(progress.runningSteps).toEqual([]);
+	});
+
+	it("should make copies of lists and objects", () => {
+		const stepNames = ["step1", "step2"];
+		const variables = { key: "value" };
+
+		const progress = createProgress("id", "name", stepNames, variables);
+
+		stepNames.push("step3");
+		(variables as Record<string, string>).newKey = "new_value";
+
+		expect(progress.pendingSteps).toEqual(["step1", "step2"]);
+		expect(progress.variables).toEqual({ key: "value" });
+	});
+});
+
+describe("saveProgress and loadProgress", () => {
+	it("should round-trip save and load", () => {
+		const tempDir = makeTempDir();
+		const progress = createProgress("test-save-load", "test-workflow", ["step1"], { var: "value" });
+
+		saveProgress(progress, tempDir);
+		const loaded = loadProgress("test-save-load", tempDir);
+
+		expect(loaded).not.toBeNull();
+		expect(loaded?.workflowId).toBe(progress.workflowId);
+		expect(loaded?.workflowName).toBe(progress.workflowName);
+		expect(loaded?.status).toBe(progress.status);
+		expect(loaded?.variables).toEqual(progress.variables);
+	});
+
+	it("should return null for nonexistent progress", () => {
+		const tempDir = makeTempDir();
+		const loaded = loadProgress("nonexistent-workflow", tempDir);
+		expect(loaded).toBeNull();
+	});
+
+	it("should create directories when saving", () => {
+		const tempDir = makeTempDir();
+		const progress = createProgress("new-workflow", "test", [], {});
+		saveProgress(progress, tempDir);
+
+		const expectedPath = path.join(tempDir, "agentic", "outputs", "new-workflow", "progress.json");
+		expect(existsSync(expectedPath)).toBe(true);
+	});
+
+	it("should write valid JSON", () => {
+		const tempDir = makeTempDir();
+		const progress = createProgress("json-test", "test", ["step1"], {
+			var: "value",
+		});
+		saveProgress(progress, tempDir);
+
+		const progressPath = getProgressPath("json-test", tempDir);
+		const data = JSON.parse(readFileSync(progressPath, "utf-8"));
+
+		expect(data.workflow_id).toBe("json-test");
+		expect(Array.isArray(data.pending_steps)).toBe(true);
+	});
+});
+
+describe("Step updates", () => {
+	it("should mark a step as started", () => {
+		const progress = createProgress("test", "workflow", ["step1", "step2"], {});
+		updateStepStarted(progress, "step1");
+
+		expect(progress.pendingSteps).not.toContain("step1");
+		expect(progress.runningSteps).toContain("step1");
+		expect(progress.currentStep).not.toBeNull();
+		expect(progress.currentStep?.name).toBe("step1");
+	});
+
+	it("should mark a step as completed", () => {
+		const progress = createProgress("test", "workflow", ["step1"], {});
+		updateStepStarted(progress, "step1");
+		updateStepCompleted(progress, "step1", "Done", { result: "success" });
+
+		expect(progress.runningSteps).not.toContain("step1");
+		expect(progress.completedSteps).toHaveLength(1);
+		expect(progress.completedSteps[0].name).toBe("step1");
+		expect(progress.completedSteps[0].status).toBe(STEP_STATUS.COMPLETED);
+		expect(progress.completedSteps[0].outputSummary).toBe("Done");
+		expect(progress.stepOutputs.step1).toEqual({ result: "success" });
+		expect(progress.currentStep).toBeNull();
+	});
+
+	it("should mark a step as failed", () => {
+		const progress = createProgress("test", "workflow", ["step1"], {});
+		updateStepStarted(progress, "step1");
+		updateStepFailed(progress, "step1", "Something went wrong");
+
+		expect(progress.runningSteps).not.toContain("step1");
+		expect(progress.completedSteps).toHaveLength(1);
+		expect(progress.completedSteps[0].status).toBe(STEP_STATUS.FAILED);
+		expect(progress.completedSteps[0].error).toBe("Something went wrong");
+		expect(progress.errors).toHaveLength(1);
+		expect(progress.errors[0].step).toBe("step1");
+	});
+
+	it("should mark a step as skipped", () => {
+		const progress = createProgress("test", "workflow", ["step1", "step2"], {});
+		updateStepSkipped(progress, "step2");
+
+		expect(progress.pendingSteps).not.toContain("step2");
+		expect(progress.completedSteps).toHaveLength(1);
+		expect(progress.completedSteps[0].status).toBe(STEP_STATUS.SKIPPED);
+	});
+
+	it("should preserve retry count", () => {
+		const progress = createProgress("test", "workflow", ["step1"], {});
+		updateStepStarted(progress, "step1");
+		(progress.currentStep as Record<string, unknown>).retry_count = 3;
+
+		updateStepCompleted(progress, "step1");
+
+		expect(progress.completedSteps[0].retryCount).toBe(3);
+	});
+});
+
+describe("Progress conversion", () => {
+	it("should round-trip through dict", () => {
+		const progress: WorkflowProgress = {
+			schemaVersion: "1.0",
+			workflowId: "test-id",
+			workflowName: "test-workflow",
+			status: "running",
+			startedAt: "2026-01-11T14:30:00Z",
+			completedAt: null,
+			currentStep: null,
+			completedSteps: [
+				{
+					name: "step1",
+					status: "completed",
+					startedAt: "2026-01-11T14:30:00Z",
+					completedAt: "2026-01-11T14:31:00Z",
+					retryCount: 0,
+					outputSummary: "",
+					error: null,
+					humanInput: null,
+				},
+			],
+			pendingSteps: ["step2"],
+			runningSteps: [],
+			parallelBranches: [],
+			errors: [],
+			variables: { var: "value" },
+			stepOutputs: { step1: { result: "ok" } },
+			workflowFile: "",
+		};
+
+		const data = progressToDict(progress);
+		const restored = dictToProgress(data);
+
+		expect(restored.workflowId).toBe(progress.workflowId);
+		expect(restored.workflowName).toBe(progress.workflowName);
+		expect(restored.status).toBe(progress.status);
+		expect(restored.completedSteps).toHaveLength(1);
+		expect(restored.completedSteps[0].name).toBe("step1");
+		expect(restored.stepOutputs).toEqual(progress.stepOutputs);
+	});
+
+	it("should handle minimal dict", () => {
+		const data = {
+			workflow_id: "minimal",
+			workflow_name: "test",
+		};
+		const progress = dictToProgress(data);
+
+		expect(progress.workflowId).toBe("minimal");
+		expect(progress.workflowName).toBe("test");
+		expect(progress.status).toBe("pending");
+		expect(progress.completedSteps).toEqual([]);
+		expect(progress.pendingSteps).toEqual([]);
+	});
+});
+
+describe("StepProgress defaults", () => {
+	it("should use correct defaults when created via createProgress flow", () => {
+		const progress = createProgress("test", "workflow", ["test"], {});
+		updateStepStarted(progress, "test");
+		updateStepCompleted(progress, "test");
+
+		const step = progress.completedSteps[0];
+		expect(step.name).toBe("test");
+		expect(step.status).toBe("completed");
+		expect(step.startedAt).toBeTruthy();
+		expect(step.completedAt).toBeTruthy();
+		expect(step.retryCount).toBe(0);
+		expect(step.outputSummary).toBe("");
+		expect(step.error).toBeNull();
+		expect(step.humanInput).toBeNull();
+	});
+});
+
+describe("prepareForResume", () => {
+	it("should move running steps to pending", () => {
+		const progress = createProgress("test", "workflow", ["step1", "step2"], {});
+		updateStepStarted(progress, "step1");
+
+		prepareForResume(progress);
+
+		expect(progress.runningSteps).toEqual([]);
+		expect(progress.pendingSteps).toContain("step1");
+		expect(progress.currentStep).toBeNull();
+		expect(progress.status).toBe(WORKFLOW_STATUS.RUNNING);
+		expect(progress.completedAt).toBeNull();
+	});
+
+	it("should move current step to front of pending", () => {
+		const progress = createProgress("test", "workflow", ["step1", "step2"], {});
+		updateStepStarted(progress, "step1");
+		// Manually clear running (simulate partial state)
+		progress.runningSteps = [];
+
+		prepareForResume(progress);
+
+		expect(progress.pendingSteps[0]).toBe("step1");
+		expect(progress.currentStep).toBeNull();
+	});
+});