stonecut 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stonecut",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "CLI that drives PRD-driven development with agentic coding CLIs",
   "license": "MIT",
   "repository": {
@@ -32,9 +32,7 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
     "@clack/prompts": "^0.10.0",
-    "@openai/codex-sdk": "^0.118.0",
     "commander": "^13.1.0"
   },
   "lint-staged": {

package/src/execute.ts

@@ -11,7 +11,6 @@
 
 import { checkoutOrCreateBranch, createPr, pushBranch } from "./git";
 import { LocalSource } from "./local";
-import { slugifyBranchComponent } from "./naming";
 import { renderLocal } from "./prompt";
 import { Logger } from "./logger";
 import { defaultGitOps, formatTokens, runAfkLoop } from "./runner";
@@ -118,13 +117,13 @@ export async function executeLocal(
 	runnerName: string,
 ): Promise<void> {
 	const source = new LocalSource(name);
-	const prdIdentifier = slugifyBranchComponent(name) || "spec";
-	const logger = new Logger(prdIdentifier);
+	const logger = new Logger();
 	const runner = getRunner(runnerName, logger);
 
 	const session: Session = { logger, git: defaultGitOps, runner, runnerName };
 
 	try {
+		logger.logFile(`PRD: ${name}`);
 		checkoutOrCreateBranch(branch);
 		console.log("");
 

package/src/logger.ts

@@ -14,10 +14,11 @@ export class Logger implements LogWriter {
 	private warnedRecreated = false;
 	private warnedUnavailable = false;
 
-	constructor(prdIdentifier: string) {
-		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	constructor() {
+		const now = new Date();
+		const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}T${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}-${String(now.getSeconds()).padStart(2, "0")}`;
 		const logDir = resolve(".stonecut", "logs");
-		this.filePath = join(logDir, `${prdIdentifier}-${timestamp}.log`);
+		this.filePath = join(logDir, `${timestamp}.log`);
 		try {
 			mkdirSync(logDir, { recursive: true });
 			appendFileSync(this.filePath, "");

package/src/runners/claude.ts

@@ -1,36 +1,79 @@
 /**
- * ClaudeRunner — adapter for Claude Code via the Agent SDK.
+ * ClaudeRunner — adapter for Claude Code via CLI subprocess.
  *
- * Calls query() from @anthropic-ai/claude-agent-sdk and consumes the
- * async message stream internally. Console gets concise progress
- * (tool calls, turn boundaries, errors); the log file captures the
- * full event stream for debugging.
+ * Spawns `claude --print --output-format stream-json --verbose` and
+ * consumes stdout as newline-delimited JSON. Console gets concise
+ * progress (tool calls, errors); the log file captures the full
+ * event stream for debugging.
  */
 
-import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
-import type {
-	Query,
-	SDKAssistantMessage,
-	SDKMessage,
-	SDKPartialAssistantMessage,
-	SDKResultMessage,
-} from "@anthropic-ai/claude-agent-sdk";
-import type { LogWriter, Runner, RunResult } from "../types.js";
-
-const ALLOWED_TOOLS = ["Bash", "Edit", "Read", "Write", "Glob", "Grep"];
-
-type QueryFn = (params: { prompt: string; options?: Record<string, unknown> }) => Query;
-let queryFn: QueryFn = sdkQuery;
-
-/** @internal Replace the SDK query function. Returns a restore function. */
-export function _setQueryFn(fn: QueryFn): () => void {
-	const prev = queryFn;
-	queryFn = fn;
+import type { ChildResult, LogWriter, Runner, RunResult, SpawnFn } from "../types.js";
+
+const CLI_ARGS = [
+	"claude",
+	"--print",
+	"--output-format",
+	"stream-json",
+	"--verbose",
+	"--allowedTools",
+	"Bash,Edit,Read,Write,Glob,Grep",
+	"--permission-mode",
+	"acceptEdits",
+	"--no-session-persistence",
+];
+
+// ---------------------------------------------------------------------------
+// Subprocess spawning (injectable for tests)
+// ---------------------------------------------------------------------------
+
+async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop()!;
+			for (const line of lines) {
+				if (line.trim()) yield line;
+			}
+		}
+		if (buffer.trim()) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function defaultSpawn(cmd: string[], stdin: string): ChildResult {
+	const proc = Bun.spawn(cmd, {
+		stdin: new Blob([stdin]),
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+	return {
+		lines: readLines(proc.stdout),
+		exitCode: proc.exited,
+	};
+}
+
+let spawnFn: SpawnFn = defaultSpawn;
+
+/** @internal Replace the spawn function. Returns a restore function. */
+export function _setSpawnFn(fn: SpawnFn): () => void {
+	const prev = spawnFn;
+	spawnFn = fn;
 	return () => {
-		queryFn = prev;
+		spawnFn = prev;
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Error subtype mapping
+// ---------------------------------------------------------------------------
+
 const ERROR_MESSAGES: Record<string, string> = {
 	error_max_turns: "max turns exceeded",
 	error_max_budget_usd: "max budget exceeded",
@@ -38,34 +81,23 @@ const ERROR_MESSAGES: Record<string, string> = {
 	error_max_structured_output_retries: "max structured output retries exceeded",
 };
 
+// ---------------------------------------------------------------------------
+// Runner implementation
+// ---------------------------------------------------------------------------
+
 export class ClaudeRunner implements Runner {
 	private logger: LogWriter;
 
 	constructor(logger: LogWriter) {
 		this.logger = logger;
-		const configDir = process.env.CLAUDE_CONFIG_DIR || "~/.claude (default)";
-		logger.log(`Claude config: ${configDir}`);
 	}
 
 	async run(prompt: string): Promise<RunResult> {
 		const start = performance.now();
-		let result: SDKResultMessage | undefined;
+		let child: ChildResult;
 
 		try {
-			const stream = queryFn({
-				prompt,
-				options: {
-					allowedTools: ALLOWED_TOOLS,
-					permissionMode: "acceptEdits",
-				},
-			});
-
-			for await (const message of stream) {
-				this.handleMessage(message);
-				if (message.type === "result") {
-					result = message;
-				}
-			}
+			child = spawnFn(CLI_ARGS, prompt);
 		} catch (error: unknown) {
 			const durationSeconds = (performance.now() - start) / 1000;
 			const msg = error instanceof Error ? error.message : String(error);
@@ -76,16 +108,46 @@ export class ClaudeRunner implements Runner {
 			return { success: false, durationSeconds, error: msg };
 		}
 
+		let result: Record<string, unknown> | undefined;
+
+		try {
+			for await (const line of child.lines) {
+				let parsed: Record<string, unknown>;
+				try {
+					parsed = JSON.parse(line);
+				} catch {
+					this.logger.logFile(`[claude] Malformed JSON line: ${line}`);
+					continue;
+				}
+
+				this.handleMessage(parsed);
+
+				if (parsed.type === "result") {
+					result = parsed;
+				}
+			}
+		} catch (error: unknown) {
+			const durationSeconds = (performance.now() - start) / 1000;
+			const msg = error instanceof Error ? error.message : String(error);
+			return { success: false, durationSeconds, error: msg };
+		}
+
+		const exitCode = await child.exitCode;
 		const durationSeconds = (performance.now() - start) / 1000;
 
+		if (exitCode !== 0) {
+			return { success: false, durationSeconds, error: `claude exited with code ${exitCode}` };
+		}
+
 		if (!result) {
 			return { success: false, durationSeconds, error: "no result message received" };
 		}
 
-		const sessionId = result.session_id;
-		const turns = result.num_turns;
-		const inputTokens = result.usage.input_tokens;
-		const outputTokens = result.usage.output_tokens;
+		const sessionId = result.session_id as string | undefined;
+		const turns = result.num_turns as number | undefined;
+		const usage = result.usage as { input_tokens?: number; output_tokens?: number } | undefined;
+		const inputTokens = usage?.input_tokens;
+		const outputTokens = usage?.output_tokens;
 
 		this.logger.logFile(
 			`[claude] Result: ${result.subtype}, turns=${turns}, input=${inputTokens}, output=${outputTokens}`,
@@ -95,7 +157,7 @@ export class ClaudeRunner implements Runner {
 			return {
 				success: true,
 				durationSeconds,
-				output: result.result,
+				output: result.result as string | undefined,
 				turns,
 				inputTokens,
 				outputTokens,
@@ -103,8 +165,10 @@ export class ClaudeRunner implements Runner {
 			};
 		}
 
-		const error = ERROR_MESSAGES[result.subtype] ?? `failed (${result.subtype})`;
-		const detail = result.errors?.length ? `: ${result.errors.join("; ")}` : "";
+		const subtype = result.subtype as string;
+		const error = ERROR_MESSAGES[subtype] ?? `failed (${subtype})`;
+		const errors = result.errors as string[] | undefined;
+		const detail = errors?.length ? `: ${errors.join("; ")}` : "";
 		return {
 			success: false,
 			durationSeconds,
@@ -116,13 +180,19 @@ export class ClaudeRunner implements Runner {
 		};
 	}
 
-	private handleMessage(message: SDKMessage): void {
+	// -----------------------------------------------------------------------
+	// Message routing
+	// -----------------------------------------------------------------------
+
+	private handleMessage(message: Record<string, unknown>): void {
 		switch (message.type) {
 			case "assistant":
 				this.logAssistant(message);
 				break;
-			case "stream_event":
-				this.logStreamEvent(message);
+			case "system":
+			case "user":
+			case "rate_limit_event":
+				this.logger.logFile(`[claude] ${message.type}: ${JSON.stringify(message)}`);
 				break;
 			case "result":
 				break;
@@ -132,32 +202,25 @@ export class ClaudeRunner implements Runner {
 		}
 	}
 
-	private logAssistant(message: SDKAssistantMessage): void {
-		if (message.error) {
-			this.logger.log(`[claude] Error: ${message.error}`);
-		}
+	private logAssistant(message: Record<string, unknown>): void {
+		const msgBody = message.message as { content?: unknown[] } | undefined;
+		const content = msgBody?.content;
 
-		for (const block of message.message.content) {
-			if (typeof block === "string") continue;
-			if (block.type === "tool_use") {
-				const target = this.toolTarget(block.name, block.input as Record<string, unknown>);
-				this.logger.log(`[claude] ${block.name}${target ? `: ${target}` : ""}`);
-			}
+		if (!Array.isArray(content)) {
+			this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(message)}`);
+			return;
 		}
 
-		this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(message.message.content)}`);
-	}
-
-	private logStreamEvent(message: SDKPartialAssistantMessage): void {
-		const event = message.event;
-		if (event.type === "content_block_delta") {
-			const delta = event.delta;
-			if ("text" in delta && typeof delta.text === "string") {
-				this.logger.logFile(`[claude] text: ${delta.text}`);
-			} else if ("thinking" in delta && typeof delta.thinking === "string") {
-				this.logger.logFile(`[claude] thinking: ${delta.thinking}`);
+		for (const block of content) {
+			if (typeof block === "string" || block === null || typeof block !== "object") continue;
+			const b = block as Record<string, unknown>;
+			if (b.type === "tool_use") {
+				const target = this.toolTarget(b.name as string, b.input as Record<string, unknown>);
+				this.logger.log(`[claude] ${b.name}${target ? `: ${target}` : ""}`);
 			}
 		}
+
+		this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(content)}`);
 	}
 
 	private toolTarget(name: string, input: Record<string, unknown>): string | undefined {

package/src/runners/codex.ts

@@ -1,27 +1,68 @@
 /**
- * CodexRunner — adapter for OpenAI Codex via the Agent SDK.
+ * CodexRunner — adapter for Codex via CLI subprocess.
  *
- * Creates a Codex client and thread per run(), consumes the async event
- * stream internally. Console gets concise progress (tool calls, file
- * changes, turn boundaries, errors); the log file captures the full
- * event stream for debugging.
+ * Spawns `codex exec --json --dangerously-bypass-approvals-and-sandbox` and
+ * consumes stdout as newline-delimited JSON. Console gets concise
+ * progress (tool calls, file changes, turn boundaries, errors); the log
+ * file captures the full event stream for debugging.
  */
 
-import { Codex, type ThreadEvent, type ThreadItem } from "@openai/codex-sdk";
-import type { LogWriter, Runner, RunResult } from "../types.js";
+import type { ChildResult, LogWriter, Runner, RunResult, SpawnFn } from "../types.js";
+
+const CLI_ARGS = ["codex", "exec", "--json", "--dangerously-bypass-approvals-and-sandbox"];
+
+// ---------------------------------------------------------------------------
+// Subprocess spawning (injectable for tests)
+// ---------------------------------------------------------------------------
+
+async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop()!;
+			for (const line of lines) {
+				if (line.trim()) yield line;
+			}
+		}
+		if (buffer.trim()) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function defaultSpawn(cmd: string[], stdin: string): ChildResult {
+	const proc = Bun.spawn(cmd, {
+		stdin: new Blob([stdin]),
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+	return {
+		lines: readLines(proc.stdout),
+		exitCode: proc.exited,
+	};
+}
 
-type CodexFactory = (...args: ConstructorParameters<typeof Codex>) => InstanceType<typeof Codex>;
-let createCodex: CodexFactory = (...args) => new Codex(...args);
+let spawnFn: SpawnFn = defaultSpawn;
 
-/** @internal Replace the Codex factory. Returns a restore function. */
-export function _setCodexFactory(fn: CodexFactory): () => void {
-	const prev = createCodex;
-	createCodex = fn;
+/** @internal Replace the spawn function. Returns a restore function. */
+export function _setSpawnFn(fn: SpawnFn): () => void {
+	const prev = spawnFn;
+	spawnFn = fn;
 	return () => {
-		createCodex = prev;
+		spawnFn = prev;
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Runner implementation
+// ---------------------------------------------------------------------------
+
 export class CodexRunner implements Runner {
 	private logger: LogWriter;
 
@@ -31,6 +72,19 @@ export class CodexRunner implements Runner {
 
 	async run(prompt: string): Promise<RunResult> {
 		const start = performance.now();
+		let child: ChildResult;
+
+		try {
+			child = spawnFn(CLI_ARGS, prompt);
+		} catch (error: unknown) {
+			const durationSeconds = (performance.now() - start) / 1000;
+			const msg = error instanceof Error ? error.message : String(error);
+
+			if (msg.includes("ENOENT") || (error as NodeJS.ErrnoException)?.code === "ENOENT") {
+				return { success: false, durationSeconds, error: "codex binary not found in PATH" };
+			}
+			return { success: false, durationSeconds, error: msg };
+		}
 
 		let threadId: string | undefined;
 		let turns = 0;
@@ -41,58 +95,68 @@ export class CodexRunner implements Runner {
 		let errorMessage: string | undefined;
 
 		try {
-			const codex = createCodex();
-			const thread = codex.startThread({
-				approvalPolicy: "never",
-				sandboxMode: "danger-full-access",
-			});
-
-			const { events } = await thread.runStreamed(prompt);
+			for await (const line of child.lines) {
+				let parsed: Record<string, unknown>;
+				try {
+					parsed = JSON.parse(line);
+				} catch {
+					this.logger.logFile(`[codex] Malformed JSON line: ${line}`);
+					continue;
+				}
 
-			for await (const event of events) {
-				this.handleEvent(event);
+				this.logger.logFile(`[codex] ${parsed.type}: ${JSON.stringify(parsed)}`);
 
-				switch (event.type) {
+				switch (parsed.type) {
 					case "thread.started":
-						threadId = event.thread_id;
+						threadId = parsed.thread_id as string;
 						break;
 					case "turn.started":
 						turns++;
+						completed = false;
 						break;
 					case "turn.completed":
 						completed = true;
 						this.logger.log(`[codex] Turn ${turns} completed`);
-						inputTokens += event.usage.input_tokens;
-						outputTokens += event.usage.output_tokens;
+						{
+							const usage = parsed.usage as
+								| { input_tokens?: number; output_tokens?: number }
+								| undefined;
+							inputTokens += usage?.input_tokens ?? 0;
+							outputTokens += usage?.output_tokens ?? 0;
+						}
 						break;
 					case "turn.failed":
 						failed = true;
-						errorMessage = event.error.message;
+						{
+							const err = parsed.error as { message?: string } | undefined;
+							errorMessage = err?.message ?? "codex turn failed";
+						}
 						this.logger.log(`[codex] Error: ${errorMessage}`);
 						break;
 					case "error":
 						failed = true;
-						errorMessage = event.message;
+						errorMessage = parsed.message as string;
 						this.logger.log(`[codex] Error: ${errorMessage}`);
 						break;
 					case "item.started":
 					case "item.completed":
-						this.logItem(event.type, event.item);
+						this.logItem(parsed.type, parsed.item as Record<string, unknown>);
 						break;
 				}
 			}
 		} catch (error: unknown) {
 			const durationSeconds = (performance.now() - start) / 1000;
 			const msg = error instanceof Error ? error.message : String(error);
-
-			if (msg.includes("ENOENT") || msg.includes("not found") || msg.includes("spawn")) {
-				return { success: false, durationSeconds, error: "codex binary not found in PATH" };
-			}
 			return { success: false, durationSeconds, error: msg };
 		}
 
+		const exitCode = await child.exitCode;
 		const durationSeconds = (performance.now() - start) / 1000;
 
+		if (exitCode !== 0) {
+			return { success: false, durationSeconds, error: `codex exited with code ${exitCode}` };
+		}
+
 		const status = failed ? "failed" : completed ? "success" : "incomplete";
 		this.logger.logFile(
 			`[codex] Result: ${status}, turns=${turns}, input=${inputTokens}, output=${outputTokens}`,
@@ -132,21 +196,19 @@ export class CodexRunner implements Runner {
 		};
 	}
 
-	private handleEvent(event: ThreadEvent): void {
-		this.logger.logFile(`[codex] ${event.type}: ${JSON.stringify(event)}`);
-	}
-
-	private logItem(phase: "item.started" | "item.completed", item: ThreadItem): void {
+	private logItem(phase: string, item: Record<string, unknown>): void {
 		switch (item.type) {
 			case "command_execution":
-				if (phase === "item.started") {
+				if (phase === "item.started" && typeof item.command === "string") {
 					this.logger.log(`[codex] Bash: ${item.command.slice(0, 80)}`);
 				}
 				break;
 			case "file_change":
-				if (phase === "item.completed") {
+				if (phase === "item.completed" && Array.isArray(item.changes)) {
 					for (const change of item.changes) {
-						this.logger.log(`[codex] Edit: ${change.path}`);
+						if (typeof change?.path === "string") {
+							this.logger.log(`[codex] Edit: ${change.path}`);
+						}
 					}
 				}
 				break;

package/src/types.ts

@@ -2,6 +2,15 @@
  * Core types and interfaces shared across the Stonecut CLI.
  */
 
+/** Return type from SpawnFn — stdout line stream and process exit code. */
+export interface ChildResult {
+	lines: AsyncIterable<string>;
+	exitCode: Promise<number>;
+}
+
+/** Injectable subprocess factory for runner testing. */
+export type SpawnFn = (cmd: string[], stdin: string) => ChildResult;
+
 /** Structured result from a single runner execution. */
 export interface RunResult {
 	success: boolean;