@vimhead.dev/norn-cli 0.1.0-tip.0

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const implementationParamsSchema = z.object({
+	task: z.string(),
+	iteration: z.number().int().min(1),
+});
+
+export const implementationAgentResponseSchema = z.object({
+	summary: z.string(),
+});
+
+export type ImplementationParams = z.output<typeof implementationParamsSchema>;

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

@@ -0,0 +1,8 @@
+import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
+import { planningParamsSchema } from "./schema.ts";
+
+export const planningWorkflow = {
+	isEntrypoint: false,
+	instructions: "Create an implementation plan for a repository task.",
+	params: planningParamsSchema,
+} as const satisfies NornWorkflowDefinition;

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

@@ -0,0 +1,28 @@
+import type { NornRunNext, NornRun } from "@vimhead.dev/norn";
+import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
+import { planningAgentResponseSchema, type PlanningParams } 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 run.next(worktreeDevelopmentLoopManifest.workflows.implementation, { task: params.task, iteration: 1 });
+}
+
+function buildPlanningPrompt(task: string): string {
+	return [
+		"Create a concise implementation plan for this repository task.",
+		"Do not modify files in this step.",
+		"Include assumptions, planned edits, and checks in the plan.",
+		"",
+		"Task:",
+		task,
+	].join("\n");
+}

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

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

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const planningParamsSchema = z.object({
+	task: z.string(),
+});
+
+export const planningAgentResponseSchema = z.object({
+	plan: z.string(),
+	summary: z.string(),
+});
+
+export type PlanningParams = z.output<typeof planningParamsSchema>;

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

@@ -0,0 +1,8 @@
+import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
+import { reviewParamsSchema } from "./schema.ts";
+
+export const reviewWorkflow = {
+	isEntrypoint: false,
+	instructions: "Review the current repository boundary changes.",
+	params: reviewParamsSchema,
+} as const satisfies NornWorkflowDefinition;

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

@@ -0,0 +1,53 @@
+import type { NornRunNext, NornRun } from "@vimhead.dev/norn";
+import { worktreeDevelopmentLoopManifest } from "../../manifest.ts";
+import { ensureCommandSucceeded } from "../../shared/commands.ts";
+import { reviewAgentResponseSchema, type ReviewParams } 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 run.next(worktreeDevelopmentLoopManifest.workflows.reviewRouter, {
+		iteration: params.iteration,
+		decision: review.decision,
+		summary: review.summary,
+		automatedReviewArtifact,
+	});
+}
+
+function buildReviewPrompt(task: string, plan: string, implementationSummary: string, diff: string): string {
+	return [
+		"Review the current repository changes against the task and plan.",
+		"Use accept only when the work is ready. Use revise for fixable issues. Use blocked when manual input is needed. Include review details in the summary.",
+		"",
+		"Task:",
+		task,
+		"",
+		"Plan:",
+		plan,
+		"",
+		"Implementation summary:",
+		implementationSummary,
+		"",
+		"Diff:",
+		diff.slice(0, 40_000),
+	].join("\n");
+}
+

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { artifactRefSchema } from "@vimhead.dev/norn";
+
+export const reviewDecisionSchema = z.enum(["accept", "revise", "blocked"]);
+
+export const reviewParamsSchema = z.object({
+	task: z.string(),
+	iteration: z.number().int().min(1),
+});
+
+export const reviewAgentResponseSchema = z.object({
+	decision: reviewDecisionSchema,
+	summary: z.string(),
+});
+
+export const storedReviewSchema = z.object({
+	decision: reviewDecisionSchema,
+	summary: z.string(),
+	reviewArtifact: artifactRefSchema,
+});
+
+export type ReviewParams = z.output<typeof reviewParamsSchema>;
+export type StoredReview = z.output<typeof storedReviewSchema>;

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

@@ -0,0 +1,12 @@
+import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
+import { reviewRouterParamsSchema } from "./schema.ts";
+
+export const reviewRouterWorkflow = {
+	isEntrypoint: false,
+	instructions: "Route implementation and review iterations based on the latest review decision.",
+	gate: {
+		enabled: true,
+		fields: ["decision", "summary"] as const,
+	},
+	params: reviewRouterParamsSchema,
+} as const satisfies NornWorkflowDefinition;

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

@@ -0,0 +1,51 @@
+import type { NornWorkflowExecutionResult, NornRun } from "@vimhead.dev/norn";
+import { worktreeDevelopmentLoopManifest } from "../../manifest.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 };
+
+	await run.state.set(worktreeDevelopmentLoopManifest.states.review.reviewDecision, params.decision);
+	await run.state.set(worktreeDevelopmentLoopManifest.states.review.reviewArtifact, reviewArtifact);
+
+	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 (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).`,
+			artifacts: { plan: planArtifact, review: reviewArtifact },
+			data: { status: "needs-attention", repositoryPath, iterations: currentIteration, lastReview },
+		});
+	}
+
+	const nextIteration = currentIteration + 1;
+	await run.state.set(worktreeDevelopmentLoopManifest.states.developmentLoop.currentIteration, nextIteration);
+	return run.next(worktreeDevelopmentLoopManifest.workflows.implementation, { task, iteration: nextIteration });
+}

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

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

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { artifactRefSchema } from "@vimhead.dev/norn";
+import { reviewDecisionSchema } from "../review/schema.ts";
+
+export const reviewRouterParamsSchema = z.object({
+	iteration: z.number().int().min(1),
+	decision: reviewDecisionSchema,
+	summary: z.string(),
+	automatedReviewArtifact: artifactRefSchema,
+});
+
+export type ReviewRouterParams = z.output<typeof reviewRouterParamsSchema>;

package/assets/package.json

@@ -0,0 +1 @@
+{"version":"0.1.0-tip.0"}

package/assets/packages/cli/src/build-info.ts

@@ -0,0 +1,36 @@
+import { NORN_GENERATED_BUILD_INFO } from "./generated-build-info.ts";
+
+export type NornBuildInfo = NornUnknownBuildInfo | NornNpmRegistryBuildInfo | NornGithubReleaseBinaryBuildInfo;
+
+export type NornUnknownBuildInfo = {
+	readonly kind: "unknown";
+	readonly version: string;
+	readonly commit: string | null;
+	readonly upgrade: {
+		readonly supported: false;
+		readonly reason: string;
+	};
+};
+
+export type NornNpmRegistryBuildInfo = {
+	readonly kind: "npm-registry";
+	readonly version: string;
+	readonly commit: string | null;
+	readonly packageSpec: string;
+	readonly upgrade: {
+		readonly supported: false;
+		readonly reason: string;
+	};
+};
+
+export type NornGithubReleaseBinaryBuildInfo = {
+	readonly kind: "github-release-binary";
+	readonly version: string;
+	readonly commit: string | null;
+	readonly repository: string;
+	readonly releaseTag: string;
+	readonly assetName: string;
+	readonly checksumAssetName: string;
+};
+
+export const NORN_BUILD_INFO: NornBuildInfo = NORN_GENERATED_BUILD_INFO;

package/assets/packages/cli/src/bun/cli.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+import { homedir } from "node:os";
+import { resolveNornAgentDirectory } from "../internal/agent-directory.ts";
+import { materializePiAssets, resolvePiAssetsCacheRoot } from "../internal/pi-assets.ts";
+import { piAssetArchive, registerBunOAuthFlows } from "./pi-assets.generated.ts";
+import { documentationAssets } from "./documentation-assets.generated.ts";
+
+process.env.NORN_AGENT_DIR = resolveNornAgentDirectory({ home: homedir(), environment: process.env });
+process.env.PI_CODING_AGENT_DIR = process.env.NORN_AGENT_DIR;
+process.env.PI_PACKAGE_DIR = await materializePiAssets({
+	archive: piAssetArchive,
+	cacheRoot: resolvePiAssetsCacheRoot({ platform: process.platform, home: homedir(), environment: process.env }),
+});
+registerBunOAuthFlows();
+const { main } = await import("../cli.ts");
+await main(process.argv.slice(2), { kind: "embedded", bundle: documentationAssets });