@vercel/dream 0.2.0

package/bin/dream.ts

@@ -0,0 +1,573 @@
+#!/usr/bin/env npx tsx
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { type OpencodeClient, createOpencode } from "@opencode-ai/sdk";
+import { program } from "commander";
+
+const STOP_WORD = "<DREAM DONE>";
+
+const SYSTEM_PROMPT = `# Dream Agent
+
+You are an autonomous agent building a project from specifications. You run in a loop until completion.
+
+## Critical: State Lives on Disk
+
+Each iteration starts with fresh context. You must:
+- Read specifications from the \`specs/\` directory in the current working directory
+- Track your progress in a \`PROGRESS.md\` file (create it on first run)
+- On each iteration, read \`PROGRESS.md\` to understand what's done and what remains
+- Update \`PROGRESS.md\` after completing each task
+
+This ensures you can resume from any point if interrupted.
+
+## Workflow
+
+1. **Read state**: Read all files in \`specs/\` and \`PROGRESS.md\` (if exists)
+2. **Plan**: If no \`PROGRESS.md\`, create it with a task breakdown from the specs
+3. **Execute**: Work on the next incomplete task
+4. **Update**: Mark the task complete in \`PROGRESS.md\`
+5. **Verify**: Check your work meets the spec requirements
+6. **Repeat or complete**: If tasks remain, continue. If all done, output completion signal.
+
+## Build Output API
+
+Your output must use [Vercel's Build Output API](https://vercel.com/docs/build-output-api/v3).
+
+### Directory Structure
+
+\`\`\`
+.vercel/output/
+├── config.json      # Required: { "version": 3 }
+└── static/          # Static files served from root (/)
+    ├── index.html
+    ├── styles.css
+    └── ...
+\`\`\`
+
+### Minimal config.json
+
+\`\`\`json
+{
+  "version": 3
+}
+\`\`\`
+
+Static files in \`.vercel/output/static/\` are served at the deployment root. Subdirectories are preserved in URLs.
+
+## PROGRESS.md Format
+
+\`\`\`markdown
+# Progress
+
+## Tasks
+- [x] Completed task
+- [ ] Pending task
+- [ ] Another pending task
+
+## Notes
+Any learnings or context for future iterations.
+\`\`\`
+
+## Completion
+
+**Only output the completion signal when ALL of the following are true:**
+- Every task in \`PROGRESS.md\` is marked complete \`[x]\`
+- All specifications in \`specs/\` are fully implemented
+- \`.vercel/output/config.json\` exists with \`"version": 3\`
+- All required static files exist in \`.vercel/output/static/\`
+
+When complete, output exactly:
+
+${STOP_WORD}
+
+Do NOT output this signal if any work remains. Continue iterating until the specs are fully met.`;
+const DEFAULT_TIMEOUT = 3600000;
+const DEFAULT_MAX_ITERATIONS = 100;
+const DEFAULT_MODEL = "vercel/anthropic/claude-opus-4.5";
+
+const dim = (s: string) => `\x1b[2m${s}\x1b[22m`;
+const bold = (s: string) => `\x1b[1m${s}\x1b[22m`;
+const green = (s: string) => `\x1b[32m${s}\x1b[39m`;
+const red = (s: string) => `\x1b[31m${s}\x1b[39m`;
+const cyan = (s: string) => `\x1b[36m${s}\x1b[39m`;
+const log = console.log;
+
+program
+	.name("dream")
+	.description("Run OpenCode in a loop until specs are complete")
+	.version("0.1.0")
+	.option("-d, --dir <directory>", "Working directory", ".");
+
+program
+	.command("init")
+	.description("Initialize a new dream project")
+	.action(() => {
+		const workDir = path.resolve(program.opts().dir);
+		const specsDir = path.join(workDir, "specs");
+		const packageJsonPath = path.join(workDir, "package.json");
+
+		log(`\n  ${bold("▲ dream")} ${dim("· init")}\n`);
+
+		if (!fs.existsSync(workDir)) {
+			fs.mkdirSync(workDir, { recursive: true });
+		}
+
+		if (!fs.existsSync(specsDir)) {
+			fs.mkdirSync(specsDir);
+			fs.writeFileSync(
+				path.join(specsDir, "sample.md"),
+				"# Sample Spec\n\n## Context\n\nDescribe what you want to build here.\n\n## Tasks\n\n- [ ] First task\n- [ ] Second task\n",
+			);
+			log(`  ${green("+")} specs/sample.md`);
+		} else {
+			log(`  ${dim("·")} specs/ ${dim("already exists")}`);
+		}
+
+		if (!fs.existsSync(packageJsonPath)) {
+			const pkg = {
+				name: path.basename(workDir),
+				version: "0.1.0",
+				private: true,
+				scripts: { build: "dream" },
+				dependencies: { "@vercel/dream": "^0.1.0" },
+			};
+			fs.writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, "\t")}\n`);
+			log(`  ${green("+")} package.json`);
+		} else {
+			log(`  ${dim("·")} package.json ${dim("already exists")}`);
+		}
+
+		log(`\n  Run ${cyan("pnpm install")} then ${cyan("dream")} to start\n`);
+	});
+
+program
+	.command("config")
+	.description("Show project configuration and specs")
+	.action(() => {
+		const workDir = path.resolve(program.opts().dir);
+		const specsDir = path.join(workDir, "specs");
+
+		log(`\n  ${bold("▲ dream")} ${dim("· config")}\n`);
+		log(`  ${dim("dir")}         ${workDir}`);
+		log(`  ${dim("timeout")}     ${formatTime(DEFAULT_TIMEOUT)}`);
+		log(`  ${dim("max")}         ${DEFAULT_MAX_ITERATIONS} iterations`);
+
+		if (!fs.existsSync(specsDir)) {
+			log(`\n  ${red("✗")} specs/ not found\n`);
+			return;
+		}
+
+		const specFiles = fs.readdirSync(specsDir).filter((f) => f.endsWith(".md"));
+		log(`\n  ${dim("specs")} ${dim(`(${specFiles.length})`)}`);
+		for (const file of specFiles) {
+			log(`    ${dim("·")} ${file}`);
+		}
+		log("");
+	});
+
+program
+	.command("models")
+	.description("List available models and check provider auth")
+	.action(async () => {
+		log(`\n  ${bold("▲ dream")} ${dim("· models")}\n`);
+		log(`  ${dim("◌")} Starting OpenCode...`);
+		const { client, server } = await createOpencode({
+			port: 0,
+			config: { enabled_providers: ["vercel"] },
+		});
+
+		try {
+			const res = await client.provider.list();
+			if (res.error) {
+				log(`  ${red("✗")} Failed to list providers\n`);
+				return;
+			}
+
+			const { all, connected } = res.data;
+			for (const provider of all) {
+				const isConnected = connected.includes(provider.id);
+				const icon = isConnected ? green("●") : red("○");
+				const npm = provider.npm ? dim(` npm:${provider.npm}`) : "";
+				log(
+					`  ${icon} ${bold(provider.name)} ${dim(`(${provider.id})`)}${npm}`,
+				);
+
+				const models = Object.entries(provider.models);
+				for (const [id, model] of models) {
+					const name = (model as { name?: string }).name ?? id;
+					log(`    ${dim("·")} ${provider.id}/${id} ${dim(name)}`);
+				}
+				if (models.length === 0) {
+					log(`    ${dim("no models")}`);
+				}
+				log("");
+			}
+
+			log(
+				`  ${dim("connected")}   ${connected.length ? connected.join(", ") : "none"}\n`,
+			);
+		} finally {
+			server.close();
+			process.exit(0);
+		}
+	});
+
+program
+	.option("-m, --model <model>", "Model to use (provider/model format)")
+	.option("-t, --timeout <ms>", "Timeout in milliseconds")
+	.option("-i, --max-iterations <n>", "Maximum iterations")
+	.option("-v, --verbose", "Verbose output")
+	.action(async (opts) => {
+		const workDir = path.resolve(opts.dir);
+		const specsDir = path.join(workDir, "specs");
+
+		if (!fs.existsSync(specsDir)) {
+			log(`\n  ${red("✗")} specs/ not found in ${workDir}\n`);
+			process.exit(1);
+		}
+
+		const timeout = opts.timeout
+			? Number.parseInt(opts.timeout, 10)
+			: DEFAULT_TIMEOUT;
+		const maxIterations = opts.maxIterations
+			? Number.parseInt(opts.maxIterations, 10)
+			: DEFAULT_MAX_ITERATIONS;
+		const verbose = opts.verbose ?? false;
+		const model = opts.model ?? process.env.DREAM_MODEL ?? DEFAULT_MODEL;
+		const title = path.basename(workDir);
+
+		log(`\n  ${bold("▲ dream")} ${dim("·")} ${title}\n`);
+		log(`  ${dim("dir")}         ${workDir}`);
+		log(`  ${dim("model")}       ${model || dim("default")}`);
+		log(`  ${dim("timeout")}     ${formatTime(timeout)}`);
+		log(`  ${dim("max")}         ${maxIterations} iterations\n`);
+
+		log(`  ${dim("◌")} Starting OpenCode...`);
+		const oidcToken = process.env.VERCEL_OIDC_TOKEN;
+		const { client, server } = await createOpencode({
+			port: 0,
+			config: {
+				model,
+				permission: {
+					edit: "allow",
+					bash: "allow",
+					webfetch: "allow",
+					doom_loop: "allow",
+					external_directory: "allow",
+				},
+				provider: {
+					vercel: {
+						env: ["VERCEL_API_KEY", "VERCEL_OIDC_TOKEN"],
+						...(oidcToken && {
+							options: {
+								apiKey: oidcToken,
+								headers: {
+									"ai-gateway-auth-method": "oidc",
+								},
+							},
+						}),
+					},
+				},
+				enabled_providers: ["vercel"],
+			},
+		});
+		log(`  ${green("●")} OpenCode ready`);
+
+		const providerId = model?.split("/")[0];
+		if (providerId) {
+			const providers = await client.provider.list();
+			if (providers.error) {
+				log(`  ${red("✗")} Failed to list providers\n`);
+				server.close();
+				process.exit(1);
+			}
+			const connected = providers.data.connected ?? [];
+			if (!connected.includes(providerId)) {
+				log(`  ${red("✗")} Provider ${bold(providerId)} is not connected`);
+				log(
+					`  ${dim("connected")}   ${connected.length ? connected.join(", ") : "none"}`,
+				);
+				log(
+					`\n  Run ${cyan("opencode")} and authenticate the ${bold(providerId)} provider\n`,
+				);
+				server.close();
+				process.exit(1);
+			}
+			const provider = providers.data.all.find((p) => p.id === providerId);
+			const modelId = model.split("/").slice(1).join("/");
+			if (provider && modelId && !provider.models[modelId]) {
+				log(
+					`  ${red("✗")} Model ${bold(modelId)} not found in ${bold(providerId)}`,
+				);
+				const available = Object.keys(provider.models);
+				if (available.length) {
+					log(
+						`  ${dim("available")}   ${available.slice(0, 5).join(", ")}${available.length > 5 ? ` (+${available.length - 5} more)` : ""}`,
+					);
+				}
+				log("");
+				server.close();
+				process.exit(1);
+			}
+			log(`  ${green("●")} Provider ${bold(providerId)} connected\n`);
+		}
+
+		const cleanup = () => {
+			server.close();
+			process.exit(1);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+
+		const startTime = Date.now();
+		let iteration = 0;
+
+		try {
+			while (iteration < maxIterations) {
+				const elapsed = Date.now() - startTime;
+				if (elapsed >= timeout) {
+					log(`\n  ${red("✗")} Timeout after ${formatTime(elapsed)}\n`);
+					process.exit(1);
+				}
+
+				iteration++;
+				const iterStart = Date.now();
+				log(`  ${cyan(`[${iteration}]`)} Running session...`);
+
+				const result = await runSession(client, title, SYSTEM_PROMPT, verbose);
+				const iterElapsed = Date.now() - iterStart;
+
+				if (result === "done") {
+					log(
+						`  ${cyan(`[${iteration}]`)} ${green("✓")} Done ${dim(`(${formatTime(iterElapsed)})`)}`,
+					);
+					log(
+						`\n  ${green("✓")} Completed in ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}\n`,
+					);
+					process.exit(0);
+				}
+
+				if (result === "error") {
+					log(
+						`\n  ${red("✗")} Session failed after ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}\n`,
+					);
+					process.exit(1);
+				}
+
+				log(
+					`  ${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} · continuing...`)}\n`,
+				);
+			}
+
+			log(`\n  ${red("✗")} Max iterations reached\n`);
+			process.exit(1);
+		} finally {
+			server.close();
+		}
+	});
+
+async function runSession(
+	client: OpencodeClient,
+	title: string,
+	systemPrompt: string,
+	verbose: boolean,
+): Promise<"done" | "continue" | "error"> {
+	log(`       ${dim("creating session...")}`);
+	const sessionResponse = await client.session.create({
+		body: { title: `Dream: ${title}` },
+	});
+
+	if (sessionResponse.error) {
+		throw new Error(
+			`Failed to create session: ${JSON.stringify(sessionResponse.error.errors)}`,
+		);
+	}
+
+	const sessionId = sessionResponse.data.id;
+	log(`       ${dim(`session ${sessionId.slice(0, 8)}`)}`);
+
+	log(`       ${dim("subscribing to events...")}`);
+	const events = await client.event.subscribe();
+
+	log(`       ${dim("sending prompt...")}`);
+	const promptResponse = await client.session.promptAsync({
+		path: { id: sessionId },
+		body: {
+			parts: [{ type: "text", text: systemPrompt }],
+		},
+	});
+
+	if (promptResponse.error) {
+		log(
+			`       ${red("✗")} prompt error: ${JSON.stringify(promptResponse.error)}`,
+		);
+		return "error";
+	}
+
+	let responseText = "";
+	let toolCalls = 0;
+	let totalCost = 0;
+	let totalTokensIn = 0;
+	let totalTokensOut = 0;
+	const seenTools = new Set<string>();
+	let lastOutput: "text" | "tool" | "none" = "none";
+
+	const pad = "       ";
+
+	for await (const event of events.stream) {
+		const props = event.properties as { sessionID?: string };
+
+		if (verbose) {
+			const sid = props.sessionID ? props.sessionID.slice(0, 8) : "global";
+			log(dim(`       event: ${event.type} [${sid}]`));
+			if (event.type !== "server.connected") {
+				log(
+					dim(
+						`              ${JSON.stringify(event.properties).slice(0, 200)}`,
+					),
+				);
+			}
+		}
+
+		if (props.sessionID && props.sessionID !== sessionId) {
+			continue;
+		}
+
+		if (event.type === "message.part.updated") {
+			const { part } = event.properties;
+			const delta = event.properties.delta as string | undefined;
+			if (part.type === "text" && delta) {
+				responseText += delta;
+				if (lastOutput === "tool") process.stdout.write("\n");
+				const indented = delta.replace(/\n/g, `\n${pad}`);
+				process.stdout.write(
+					lastOutput !== "text" ? `${pad}${dim(indented)}` : dim(indented),
+				);
+				lastOutput = "text";
+			}
+			if (part.type === "reasoning" && delta) {
+				if (lastOutput === "tool") process.stdout.write("\n");
+				const indented = delta.replace(/\n/g, `\n${pad}`);
+				process.stdout.write(
+					lastOutput !== "text" ? `${pad}${dim(indented)}` : dim(indented),
+				);
+				lastOutput = "text";
+			}
+			if (part.type === "tool") {
+				const callID = part.callID as string;
+				const toolName = part.tool as string;
+				const state = part.state as {
+					status: string;
+					title?: string;
+					input?: Record<string, unknown>;
+					output?: string;
+					error?: string;
+				};
+				if (state.status === "running" && !seenTools.has(callID)) {
+					seenTools.add(callID);
+					toolCalls++;
+					if (lastOutput === "text") process.stdout.write("\n\n");
+					const context = toolContext(toolName, state.input) ?? state.title;
+					log(
+						`${pad}${dim("▸")} ${toolName}${context ? dim(` ${context}`) : ""}`,
+					);
+					lastOutput = "tool";
+				}
+				if (state.status === "error") {
+					if (lastOutput === "text") process.stdout.write("\n");
+					log(`${pad}${red("✗")} ${toolName}: ${state.error}`);
+					lastOutput = "tool";
+				}
+			}
+			if (part.type === "step-finish") {
+				const step = part as {
+					cost?: number;
+					tokens?: { input: number; output: number };
+				};
+				totalCost += step.cost ?? 0;
+				totalTokensIn += step.tokens?.input ?? 0;
+				totalTokensOut += step.tokens?.output ?? 0;
+			}
+		}
+
+		if (event.type === "file.edited") {
+			const file = (event.properties as { file?: string }).file;
+			if (file) {
+				if (lastOutput === "text") process.stdout.write("\n");
+				const relative = file.replace(`${process.cwd()}/`, "");
+				log(`${pad}${green("✎")} ${relative}`);
+				lastOutput = "tool";
+			}
+		}
+
+		if (event.type === "session.error") {
+			const errProps = event.properties as {
+				error?: { name?: string; data?: { message?: string } };
+			};
+			const msg =
+				errProps.error?.data?.message ??
+				errProps.error?.name ??
+				"session error";
+			if (lastOutput === "text") process.stdout.write("\n");
+			log(`${pad}${red("✗")} ${msg}`);
+			return "error";
+		}
+
+		if (event.type === "session.idle") {
+			break;
+		}
+	}
+
+	if (lastOutput === "text") process.stdout.write("\n");
+	const tokens = `${formatTokens(totalTokensIn)}→${formatTokens(totalTokensOut)}`;
+	const cost = totalCost > 0 ? ` · $${totalCost.toFixed(2)}` : "";
+	log(`${pad}${dim(`${toolCalls} tools · ${tokens}${cost}`)}`);
+
+	if (responseText.length === 0) {
+		log(`${pad}${red("✗")} No response from model`);
+		return "error";
+	}
+
+	return responseText.includes(STOP_WORD) ? "done" : "continue";
+}
+
+function formatTime(ms: number): string {
+	if (ms < 1000) return `${ms}ms`;
+	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+	return `${(ms / 60000).toFixed(1)}m`;
+}
+
+function formatTokens(n: number): string {
+	if (n < 1000) return `${n}`;
+	if (n < 1000000) return `${(n / 1000).toFixed(1)}k`;
+	return `${(n / 1000000).toFixed(1)}M`;
+}
+
+function toolContext(
+	tool: string,
+	input?: Record<string, unknown>,
+): string | undefined {
+	if (!input) return undefined;
+	const filePath = input.filePath as string | undefined;
+	const rel = filePath?.replace(`${process.cwd()}/`, "");
+	switch (tool) {
+		case "read":
+		case "write":
+		case "edit":
+			return rel;
+		case "bash": {
+			const cmd = input.command as string | undefined;
+			if (!cmd) return undefined;
+			return cmd.length > 60 ? `${cmd.slice(0, 60)}…` : cmd;
+		}
+		case "glob":
+		case "grep":
+			return input.pattern as string | undefined;
+		case "fetch":
+			return input.url as string | undefined;
+		default:
+			return undefined;
+	}
+}
+
+await program.parseAsync();

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@vercel/dream",
+	"version": "0.2.0",
+	"description": "A CLI that runs OpenCode in a loop until specs are complete",
+	"type": "module",
+	"bin": {
+		"dream": "./bin/dream.ts"
+	},
+	"files": ["bin"],
+	"scripts": {
+		"check": "biome check .",
+		"check:fix": "biome check --write .",
+		"version": "changeset version",
+		"release": "changeset publish"
+	},
+	"dependencies": {
+		"@ai-sdk/gateway": "^3.0.39",
+		"@opencode-ai/sdk": "^1.1.0",
+		"commander": "^12.0.0",
+		"tsx": "^4.0.0"
+	},
+	"peerDependencies": {
+		"opencode-ai": ">=1.0.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.0",
+		"@changesets/cli": "^2.29.8",
+		"@types/node": "^22.0.0",
+		"lefthook": "^2.1.0",
+		"typescript": "^5.4.0"
+	},
+	"keywords": ["cli", "opencode", "ai", "automation"],
+	"author": "",
+	"license": "MIT"
+}