@vimhead.dev/norn-cli 0.1.0-tip.35359392805.1 → 0.1.0-tip.35436871363.1

package/assets/examples/worktree-development-loop/workflows/implementation/execute.ts

@@ -1,38 +1,40 @@
-import type { NornRunNext, NornRun } from "@vimhead.dev/norn";
-import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { reviewWorkflow } from "../review/execute.ts";
+import type { WorkflowResult } from "@vimhead.dev/norn";
+import { developmentLoopScope } from "../../scope.ts";
+import { implementationArgsSchema } from "./schema.ts";
 import { ensureCommandSucceeded } from "../../shared/commands.ts";
-import { implementationAgentResponseSchema, type ImplementationParams } from "./schema.ts";
+import { implementationAgentResponseSchema } from "./schema.ts";
 
-export async function executeImplementationWorkflow(
-	run: NornRun,
-	params: ImplementationParams,
-): Promise<NornRunNext> {
-	const repositoryPath = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.repositoryPath);
-	const planArtifact = await run.state.get(worktreeDevelopmentLoopManifest.states.planning.planArtifact);
-	const plan = await run.artifacts.read(planArtifact);
-	const previousReviewArtifact = await run.state.getOptional(worktreeDevelopmentLoopManifest.states.review.reviewArtifact);
-	const previousReview = previousReviewArtifact ? await run.artifacts.read(previousReviewArtifact) : undefined;
-	const implementation = await run.agents.prompt({
-		label: `implementation-${params.iteration}`,
-		cwd: repositoryPath,
-		tools: ["read", "grep", "find", "ls", "edit", "write", "bash"],
-		prompt: buildImplementationPrompt(params.task, plan, params.iteration, previousReview),
-		response: implementationAgentResponseSchema,
-	});
-	await run.state.set(worktreeDevelopmentLoopManifest.states.implementation.implementationSummary, implementation.summary);
-	const status = await run.commands.run({
-		label: `implementation-${params.iteration}-status`,
-		cwd: repositoryPath,
-		command: "git status --short",
-	});
-	await ensureCommandSucceeded(status);
-	const statusOutput = await run.logs.read(status.stdoutLog);
-	await run.artifacts.write(`implementation/iteration-${params.iteration}-status.txt`, statusOutput);
-	return worktreeDevelopmentLoopManifest.workflows.review({
-		task: params.task,
-		iteration: params.iteration,
-	});
-}
+export const implementationWorkflow = developmentLoopScope.workflow({
+	id: "implementation",
+	isEntrypoint: false,
+	instructions: "Apply one implementation pass in the current repository.",
+	args: implementationArgsSchema,
+	async execute({ args, paths, run }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
+		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
+		const previousReview = args.previousReviewPath ? await readFile(join(paths.workspace, args.previousReviewPath), "utf8") : undefined;
+		const implementation = await run.agents.prompt({
+			label: `implementation-${args.iteration}`,
+			cwd: repositoryPath,
+			tools: ["read", "grep", "find", "ls", "edit", "write", "bash"],
+			prompt: buildImplementationPrompt(args.task, plan, args.iteration, previousReview),
+			response: implementationAgentResponseSchema,
+		});
+		const status = await run.commands.run({
+			label: `implementation-${args.iteration}-status`,
+			cwd: repositoryPath,
+			command: "git status --short",
+		});
+		await ensureCommandSucceeded(status);
+		const statusOutput = await run.logs.read(status.stdoutLog);
+		await mkdir(join(paths.workspace, "implementation"), { recursive: true });
+		await writeFile(join(paths.workspace, `implementation/iteration-${args.iteration}-status.txt`), statusOutput);
+		return reviewWorkflow({ ...args, implementationSummary: implementation.summary });
+	}
+});
 
 function buildImplementationPrompt(task: string, plan: string, iteration: number, previousReview: string | undefined): string {
 	return [

package/assets/examples/worktree-development-loop/workflows/implementation/index.ts

@@ -1,3 +1,2 @@
-export { implementationWorkflow } from "./declaration.ts";
-export { executeImplementationWorkflow } from "./execute.ts";
-export { implementationAgentResponseSchema, implementationParamsSchema, type ImplementationParams } from "./schema.ts";
+export { implementationWorkflow } from "./execute.ts";
+export { implementationAgentResponseSchema, implementationArgsSchema, type ImplementationArgs } from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/implementation/schema.ts

@@ -1,12 +1,15 @@
+import { planningArgsSchema } from "../planning/schema.ts";
 import { Type, type StaticDecode } from "typebox";
 
-export const implementationParamsSchema = Type.Object({
-	task: Type.String(),
+export const implementationArgsSchema = Type.Object({
+	...planningArgsSchema.properties,
 	iteration: Type.Integer({ minimum: 1 }),
+	planPath: Type.String(),
+	previousReviewPath: Type.Optional(Type.String()),
 });
 
 export const implementationAgentResponseSchema = Type.Object({
 	summary: Type.String(),
 });
 
-export type ImplementationParams = StaticDecode<typeof implementationParamsSchema>;
+export type ImplementationArgs = StaticDecode<typeof implementationArgsSchema>;

package/assets/examples/worktree-development-loop/workflows/planning/execute.ts

@@ -1,20 +1,31 @@
-import type { NornRunNext, NornRun } from "@vimhead.dev/norn";
-import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
-import { planningAgentResponseSchema, type PlanningParams } from "./schema.ts";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { implementationWorkflow } from "../implementation/execute.ts";
+import type { WorkflowResult } from "@vimhead.dev/norn";
+import { developmentLoopScope } from "../../scope.ts";
+import { planningArgsSchema } from "./schema.ts";
+import { planningAgentResponseSchema } from "./schema.ts";
 
-export async function executePlanningWorkflow(run: NornRun, params: PlanningParams): Promise<NornRunNext> {
-	const repositoryPath = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.repositoryPath);
-	const planning = await run.agents.prompt({
-		label: "planning",
-		cwd: repositoryPath,
-		tools: ["read", "grep", "find", "ls"],
-		prompt: buildPlanningPrompt(params.task),
-		response: planningAgentResponseSchema,
-	});
-	const planArtifact = await run.artifacts.write("planning/plan.md", planning.plan);
-	await run.state.set(worktreeDevelopmentLoopManifest.states.planning.planArtifact, planArtifact);
-	return worktreeDevelopmentLoopManifest.workflows.implementation({ task: params.task, iteration: 1 });
-}
+export const planningWorkflow = developmentLoopScope.workflow({
+	id: "planning",
+	isEntrypoint: false,
+	instructions: "Create an implementation plan for a repository task.",
+	args: planningArgsSchema,
+	async execute({ args, paths, run }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
+		const planning = await run.agents.prompt({
+			label: "planning",
+			cwd: repositoryPath,
+			tools: ["read", "grep", "find", "ls"],
+			prompt: buildPlanningPrompt(args.task),
+			response: planningAgentResponseSchema,
+		});
+		const planPath = "planning/plan.md";
+		await mkdir(join(paths.workspace, "planning"), { recursive: true });
+		await writeFile(join(paths.workspace, planPath), planning.plan);
+		return implementationWorkflow({ ...args, planPath, iteration: 1 });
+	}
+});
 
 function buildPlanningPrompt(task: string): string {
 	return [

package/assets/examples/worktree-development-loop/workflows/planning/index.ts

@@ -1,3 +1,2 @@
-export { planningWorkflow } from "./declaration.ts";
-export { executePlanningWorkflow } from "./execute.ts";
-export { planningAgentResponseSchema, planningParamsSchema, type PlanningParams } from "./schema.ts";
+export { planningWorkflow } from "./execute.ts";
+export { planningAgentResponseSchema, planningArgsSchema, type PlanningArgs } from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/planning/schema.ts

@@ -1,7 +1,9 @@
 import { Type, type StaticDecode } from "typebox";
 
-export const planningParamsSchema = Type.Object({
+export const planningArgsSchema = Type.Object({
 	task: Type.String(),
+	repositoryPath: Type.String(),
+	maxIterations: Type.Integer({ minimum: 1, maximum: 10 }),
 });
 
 export const planningAgentResponseSchema = Type.Object({
@@ -9,4 +11,4 @@ export const planningAgentResponseSchema = Type.Object({
 	summary: Type.String(),
 });
 
-export type PlanningParams = StaticDecode<typeof planningParamsSchema>;
+export type PlanningArgs = StaticDecode<typeof planningArgsSchema>;

package/assets/examples/worktree-development-loop/workflows/review/execute.ts

@@ -1,36 +1,48 @@
-import type { NornRunNext, NornRun } from "@vimhead.dev/norn";
-import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { reviewRouterWorkflow } from "../review-router/execute.ts";
+import type { WorkflowResult } from "@vimhead.dev/norn";
+import { developmentLoopScope } from "../../scope.ts";
+import { reviewArgsSchema } from "./schema.ts";
 import { ensureCommandSucceeded } from "../../shared/commands.ts";
-import { reviewAgentResponseSchema, type ReviewParams } from "./schema.ts";
+import { reviewAgentResponseSchema } from "./schema.ts";
 
-export async function executeReviewWorkflow(run: NornRun, params: ReviewParams): Promise<NornRunNext> {
-	const repositoryPath = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.repositoryPath);
-	const planArtifact = await run.state.get(worktreeDevelopmentLoopManifest.states.planning.planArtifact);
-	const implementationSummary = await run.state.get(worktreeDevelopmentLoopManifest.states.implementation.implementationSummary);
-	const plan = await run.artifacts.read(planArtifact);
-	const diff = await run.commands.run({
-		label: `review-${params.iteration}-diff`,
-		cwd: repositoryPath,
-		command: "git status --short && git diff --stat HEAD -- . && git diff HEAD -- .",
-	});
-	await ensureCommandSucceeded(diff);
-	const diffOutput = await run.logs.read(diff.stdoutLog);
-	await run.artifacts.write(`review/iteration-${params.iteration}-diff.txt`, diffOutput);
-	const review = await run.agents.prompt({
-		label: `review-${params.iteration}`,
-		cwd: repositoryPath,
-		tools: ["read", "grep", "find", "ls", "bash"],
-		prompt: buildReviewPrompt(params.task, plan, implementationSummary, diffOutput),
-		response: reviewAgentResponseSchema,
-	});
-	const automatedReviewArtifact = await run.artifacts.write(`review/iteration-${params.iteration}-automated.json`, JSON.stringify(review, null, 2));
-	return worktreeDevelopmentLoopManifest.workflows.reviewRouter({
-		iteration: params.iteration,
-		decision: review.decision,
-		summary: review.summary,
-		automatedReviewArtifact,
-	});
-}
+export const reviewWorkflow = developmentLoopScope.workflow({
+	id: "review",
+	isEntrypoint: false,
+	instructions: "Review the current repository boundary changes.",
+	args: reviewArgsSchema,
+	async execute({ args, paths, run }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
+		const implementationSummary = args.implementationSummary;
+		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
+		const diff = await run.commands.run({
+			label: `review-${args.iteration}-diff`,
+			cwd: repositoryPath,
+			command: "git status --short && git diff --stat HEAD -- . && git diff HEAD -- .",
+		});
+		await ensureCommandSucceeded(diff);
+		const diffOutput = await run.logs.read(diff.stdoutLog);
+		await mkdir(join(paths.workspace, "review"), { recursive: true });
+		await writeFile(join(paths.workspace, `review/iteration-${args.iteration}-diff.txt`), diffOutput);
+		const review = await run.agents.prompt({
+			label: `review-${args.iteration}`,
+			cwd: repositoryPath,
+			tools: ["read", "grep", "find", "ls", "bash"],
+			prompt: buildReviewPrompt(args.task, plan, implementationSummary, diffOutput),
+			response: reviewAgentResponseSchema,
+		});
+		const automatedReviewPath = `review/iteration-${args.iteration}-automated.json`;
+		await writeFile(join(paths.workspace, automatedReviewPath), JSON.stringify(review, null, 2));
+		return reviewRouterWorkflow({
+			...args,
+			iteration: args.iteration,
+			decision: review.decision,
+			summary: review.summary,
+			automatedReviewPath,
+		});
+	}
+});
 
 function buildReviewPrompt(task: string, plan: string, implementationSummary: string, diff: string): string {
 	return [

package/assets/examples/worktree-development-loop/workflows/review/index.ts

@@ -1,10 +1,9 @@
-export { reviewWorkflow } from "./declaration.ts";
-export { executeReviewWorkflow } from "./execute.ts";
+export { reviewWorkflow } from "./execute.ts";
 export {
 	reviewAgentResponseSchema,
 	reviewDecisionSchema,
-	reviewParamsSchema,
+	reviewArgsSchema,
 	storedReviewSchema,
-	type ReviewParams,
+	type ReviewArgs,
 	type StoredReview,
 } from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/review/schema.ts

@@ -1,11 +1,11 @@
-import { artifactRefSchema } from "@vimhead.dev/norn";
+import { implementationArgsSchema } from "../implementation/schema.ts";
 import { Type, type StaticDecode } from "typebox";
 
 export const reviewDecisionSchema = Type.Enum(["accept", "revise", "blocked"]);
 
-export const reviewParamsSchema = Type.Object({
-	task: Type.String(),
-	iteration: Type.Integer({ minimum: 1 }),
+export const reviewArgsSchema = Type.Object({
+	...implementationArgsSchema.properties,
+	implementationSummary: Type.String(),
 });
 
 export const reviewAgentResponseSchema = Type.Object({
@@ -16,8 +16,8 @@ export const reviewAgentResponseSchema = Type.Object({
 export const storedReviewSchema = Type.Object({
 	decision: reviewDecisionSchema,
 	summary: Type.String(),
-	reviewArtifact: artifactRefSchema,
+	reviewPath: Type.String(),
 });
 
-export type ReviewParams = StaticDecode<typeof reviewParamsSchema>;
+export type ReviewArgs = StaticDecode<typeof reviewArgsSchema>;
 export type StoredReview = StaticDecode<typeof storedReviewSchema>;

package/assets/examples/worktree-development-loop/workflows/review-router/execute.ts

@@ -1,51 +1,57 @@
-import type { NornWorkflowExecutionResult, NornRun } from "@vimhead.dev/norn";
-import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { implementationWorkflow } from "../implementation/execute.ts";
+import type { WorkflowResult } from "@vimhead.dev/norn";
+import { developmentLoopScope } from "../../scope.ts";
+import { reviewRouterArgsSchema } from "./schema.ts";
 import type { StoredReview } from "../review/schema.ts";
-import type { ReviewRouterParams } from "./schema.ts";
 
-export async function executeReviewRouterWorkflow(
-	run: NornRun,
-	params: ReviewRouterParams,
-): Promise<NornWorkflowExecutionResult> {
-	const repositoryPath = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.repositoryPath);
-	const planArtifact = await run.state.get(worktreeDevelopmentLoopManifest.states.planning.planArtifact);
-	const currentIteration = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.currentIteration);
-	const maxIterations = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.maxIterations);
-	const task = await run.state.get(worktreeDevelopmentLoopManifest.states.developmentLoop.task);
-	const reviewArtifact = await run.artifacts.write(
-		`review/iteration-${params.iteration}-decision.json`,
-		JSON.stringify({ decision: params.decision, summary: params.summary, automatedReviewArtifact: params.automatedReviewArtifact }, null, 2),
-	);
-	const lastReview: StoredReview = { decision: params.decision, summary: params.summary, reviewArtifact };
+export const reviewRouterWorkflow = developmentLoopScope.workflow({
+	id: "reviewRouter",
+	isEntrypoint: false,
+	instructions: "Route implementation and review iterations based on the latest review decision.",
+	gate: {
+		enabled: true,
+		describe: ({ args }) => `Review iteration ${args.iteration}. Confirm or edit the automated decision before continuing. Plan: ${args.planPath}.`,
+		fields: ["decision", "summary"] as const,
+	},
+	args: reviewRouterArgsSchema,
+	async execute({ args, paths, run }): Promise<WorkflowResult> {
+		const repositoryPath = args.repositoryPath;
+		const planPath = args.planPath;
+		const currentIteration = args.iteration;
+		const maxIterations = args.maxIterations;
+		const task = args.task;
+		const reviewPath = `review/iteration-${args.iteration}-decision.json`;
+		await mkdir(join(paths.workspace, "review"), { recursive: true });
+		await writeFile(
+			join(paths.workspace, reviewPath),
+			JSON.stringify({ decision: args.decision, summary: args.summary, automatedReviewPath: args.automatedReviewPath }, null, 2),
+		);
+		const lastReview: StoredReview = { decision: args.decision, summary: args.summary, reviewPath };
 
-	await run.state.set(worktreeDevelopmentLoopManifest.states.review.reviewDecision, params.decision);
-	await run.state.set(worktreeDevelopmentLoopManifest.states.review.reviewArtifact, reviewArtifact);
+		if (args.decision === "accept") {
+			return run.complete({
+				summary: `Implementation accepted after ${currentIteration} iteration(s).`,
+				data: { status: "done", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
+			});
+		}
 
-	if (params.decision === "accept") {
-		return run.complete({
-			summary: `Implementation accepted after ${currentIteration} iteration(s).`,
-			artifacts: { plan: planArtifact, review: reviewArtifact },
-			data: { status: "done", repositoryPath, iterations: currentIteration, lastReview },
-		});
-	}
+		if (args.decision === "blocked") {
+			return run.fail({
+				summary: args.summary,
+				data: { status: "blocked", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
+			});
+		}
 
-	if (params.decision === "blocked") {
-		return run.fail({
-			summary: params.summary,
-			artifacts: { plan: planArtifact, review: reviewArtifact },
-			data: { status: "blocked", repositoryPath, iterations: currentIteration, lastReview },
-		});
-	}
+		if (currentIteration >= maxIterations) {
+			return run.fail({
+				summary: `Maximum iteration count reached after ${currentIteration} iteration(s).`,
+				data: { status: "needs-attention", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
+			});
+		}
 
-	if (currentIteration >= maxIterations) {
-		return run.fail({
-			summary: `Maximum iteration count reached after ${currentIteration} iteration(s).`,
-			artifacts: { plan: planArtifact, review: reviewArtifact },
-			data: { status: "needs-attention", repositoryPath, iterations: currentIteration, lastReview },
-		});
+		const nextIteration = currentIteration + 1;
+		return implementationWorkflow({ task, repositoryPath, maxIterations, planPath, iteration: nextIteration, previousReviewPath: reviewPath });
 	}
-
-	const nextIteration = currentIteration + 1;
-	await run.state.set(worktreeDevelopmentLoopManifest.states.developmentLoop.currentIteration, nextIteration);
-	return worktreeDevelopmentLoopManifest.workflows.implementation({ task, iteration: nextIteration });
-}
+});

package/assets/examples/worktree-development-loop/workflows/review-router/index.ts

@@ -1,3 +1,2 @@
-export { reviewRouterWorkflow } from "./declaration.ts";
-export { executeReviewRouterWorkflow } from "./execute.ts";
-export { reviewRouterParamsSchema, type ReviewRouterParams } from "./schema.ts";
+export { reviewRouterWorkflow } from "./execute.ts";
+export { reviewRouterArgsSchema, type ReviewRouterArgs } from "./schema.ts";

package/assets/examples/worktree-development-loop/workflows/review-router/schema.ts

@@ -1,12 +1,12 @@
-import { artifactRefSchema } from "@vimhead.dev/norn";
+import { implementationArgsSchema } from "../implementation/schema.ts";
 import { Type, type StaticDecode } from "typebox";
 import { reviewDecisionSchema } from "../review/schema.ts";
 
-export const reviewRouterParamsSchema = Type.Object({
-	iteration: Type.Integer({ minimum: 1 }),
+export const reviewRouterArgsSchema = Type.Object({
+	...implementationArgsSchema.properties,
 	decision: reviewDecisionSchema,
 	summary: Type.String(),
-	automatedReviewArtifact: artifactRefSchema,
+	automatedReviewPath: Type.String(),
 });
 
-export type ReviewRouterParams = StaticDecode<typeof reviewRouterParamsSchema>;
+export type ReviewRouterArgs = StaticDecode<typeof reviewRouterArgsSchema>;

package/assets/package.json

@@ -1 +1 @@
-{"version":"0.1.0-tip.35359392805.1"}
+{"version":"0.1.0-tip.35436871363.1"}