@drawcall/create 0.1.3 → 0.2.0

package/dist/git.d.ts

@@ -0,0 +1,27 @@
+import { Context, Effect, Layer } from "effect";
+import { type HarnessName, type PipelineStage } from "./constants.js";
+import { GitFailure } from "./errors.js";
+import { Shell } from "./shell.js";
+export interface RunMeta {
+    readonly prompt: string;
+    readonly harness?: HarnessName;
+    readonly harnessArgs?: ReadonlyArray<string>;
+    readonly harnessTimeoutMs?: number;
+    readonly maxTurns?: number;
+    readonly skipTemplate?: boolean;
+}
+export type StageMarker = PipelineStage | "done";
+export interface GitService {
+    readonly init: (cwd: string) => Effect.Effect<void, GitFailure>;
+    readonly resetClean: (cwd: string) => Effect.Effect<void, GitFailure>;
+    readonly treeHash: (cwd: string) => Effect.Effect<string>;
+    readonly checkpoint: (cwd: string, stage: StageMarker, run?: RunMeta) => Effect.Effect<void, GitFailure>;
+    readonly latestStage: (cwd: string) => Effect.Effect<StageMarker | undefined>;
+    readonly countStage: (cwd: string, stage: StageMarker) => Effect.Effect<number>;
+    readonly readRunMeta: (cwd: string) => Effect.Effect<RunMeta | undefined>;
+}
+declare const Git_base: Context.TagClass<Git, "Git", GitService>;
+export declare class Git extends Git_base {
+}
+export declare const GitLive: Layer.Layer<Git, never, Shell>;
+export {};

package/dist/git.js

@@ -0,0 +1,77 @@
+import { Context, Effect, Layer } from "effect";
+import { CHECKPOINT_SUBJECT, PIPELINE_STAGES, RUN_TRAILER, STAGE_TRAILER } from "./constants.js";
+import { GitFailure } from "./errors.js";
+import { Shell } from "./shell.js";
+const STAGE_MARKERS = [...PIPELINE_STAGES, "done"];
+// A trailer value is just a string from git; only recognize it if it is one of our markers, so an
+// unrelated or malformed value reads as "no checkpoint" rather than a bogus resume point.
+function asStageMarker(value) {
+    return STAGE_MARKERS.find((marker) => marker === value);
+}
+export class Git extends Context.Tag("Git")() {
+}
+const live = (shell) => {
+    const run = (cwd, args) => shell.run({ command: "git", args, cwd });
+    // Run a git op that must succeed; a non-zero exit is an unexpected GitFailure carrying the output.
+    const must = (cwd, op, args) => run(cwd, args).pipe(Effect.flatMap((r) => r.exitCode === 0
+        ? Effect.void
+        : Effect.fail(new GitFailure({ op, detail: r.output.slice(-400) }))));
+    // First non-empty line of a per-commit trailer query (git logs newest-first), or undefined.
+    const newestTrailer = (cwd, key) => run(cwd, ["log", `--format=%(trailers:key=${key},valueonly)`]).pipe(Effect.map((r) => {
+        if (r.exitCode !== 0)
+            return undefined; // empty repo / no commits
+        const line = r.output.split("\n").find((l) => l.trim().length > 0);
+        return line?.trim();
+    }));
+    return {
+        init: (cwd) => must(cwd, "init", ["init"]).pipe(
+        // Guarantee a commit identity so checkpoints never fail on a machine with no global git
+        // config — without it the very first commit aborts. Only set locally when nothing is
+        // configured, so a user's own identity is preserved.
+        Effect.zipRight(run(cwd, ["config", "user.email"])), Effect.flatMap((r) => r.exitCode === 0 && r.output.trim().length > 0
+            ? Effect.void
+            : must(cwd, "config", ["config", "user.email", "create@drawcall.ai"]).pipe(Effect.zipRight(must(cwd, "config", ["config", "user.name", "drawcall-create"]))))),
+        resetClean: (cwd) => 
+        // Resume only from a clean committed state: a turn killed mid-edit can leave partial,
+        // partially-destructive changes. `clean -fd` (not -x) keeps node_modules and gitignored scratch.
+        must(cwd, "reset", ["reset", "--hard", "HEAD"]).pipe(Effect.zipRight(must(cwd, "clean", ["clean", "-fd"]))),
+        // The content hash of HEAD's tree. Crucial for progress detection: an --allow-empty checkpoint
+        // advances the commit hash but leaves the tree identical, so a tree hash can't be faked by an
+        // empty marker commit — only real file changes move it.
+        treeHash: (cwd) => run(cwd, ["rev-parse", "HEAD^{tree}"]).pipe(Effect.map((r) => (r.exitCode === 0 ? r.output.trim() : ""))),
+        checkpoint: (cwd, stage, runMeta) => {
+            const trailerLines = [`${STAGE_TRAILER}: ${stage}`];
+            if (runMeta)
+                trailerLines.push(`${RUN_TRAILER}: ${JSON.stringify(runMeta)}`);
+            return must(cwd, "add", ["add", "-A"]).pipe(Effect.zipRight(must(cwd, "commit", [
+                "commit",
+                "--allow-empty",
+                "-m",
+                CHECKPOINT_SUBJECT(stage),
+                "-m",
+                trailerLines.join("\n")
+            ])));
+        },
+        latestStage: (cwd) => newestTrailer(cwd, STAGE_TRAILER).pipe(Effect.map(asStageMarker)),
+        countStage: (cwd, stage) => run(cwd, ["log", `--format=%(trailers:key=${STAGE_TRAILER},valueonly)`]).pipe(Effect.map((r) => r.exitCode !== 0 ? 0 : r.output.split("\n").filter((l) => l.trim() === stage).length)),
+        readRunMeta: (cwd) => newestTrailer(cwd, RUN_TRAILER).pipe(Effect.map((value) => (value ? parseRunMeta(value) : undefined)))
+    };
+};
+// A corrupt or shape-wrong trailer must never abort resume — it reads as "no metadata". We only
+// trust it once it parses to an object carrying the one field resume actually requires, a string
+// prompt; the rest are optional and read defensively at the call site.
+function parseRunMeta(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return undefined;
+    if (typeof parsed.prompt !== "string")
+        return undefined;
+    return parsed;
+}
+export const GitLive = Layer.effect(Git, Effect.map(Shell, (shell) => live(shell)));

package/dist/harness.d.ts

@@ -1,13 +1,24 @@
+import { Context, Effect, Layer } from "effect";
 import { type HarnessName } from "./constants.js";
-import type { CommandExists, CommandInvocation, CommandResult, CommandRunner } from "./subprocess.js";
-export type HarnessRunner = {
-    harness: HarnessName;
-    harnessArgs: string[];
-    timeoutMs: number;
-    cwd: string;
-    runner: CommandRunner;
+import { PreflightError } from "./errors.js";
+import { type CommandResult, Shell } from "./shell.js";
+export declare function harnessInvocation(harness: HarnessName, prompt: string, cwd: string, harnessArgs?: ReadonlyArray<string>): {
+    command: string;
+    args: string[];
 };
-export declare function selectHarness(requested: HarnessName | undefined, env: NodeJS.ProcessEnv, commandExists: CommandExists): Promise<HarnessName>;
-export declare function harnessInvocation(harness: HarnessName, prompt: string, cwd: string, harnessArgs?: string[]): CommandInvocation;
-/** Run one harness-turn: build the harness-command and hand it to the command-runner. */
-export declare function runHarnessTurn(harnessRunner: HarnessRunner, prompt: string): Promise<CommandResult>;
+export interface HarnessTurn {
+    readonly harness: HarnessName;
+    readonly prompt: string;
+    readonly cwd: string;
+    readonly harnessArgs?: ReadonlyArray<string>;
+    readonly timeoutMs?: number;
+}
+export interface HarnessService {
+    readonly runTurn: (turn: HarnessTurn) => Effect.Effect<CommandResult>;
+    readonly select: (requested: HarnessName | undefined) => Effect.Effect<HarnessName, PreflightError>;
+}
+declare const Harness_base: Context.TagClass<Harness, "Harness", HarnessService>;
+export declare class Harness extends Harness_base {
+}
+export declare const HarnessLive: Layer.Layer<Harness, never, Shell>;
+export {};

package/dist/harness.js

@@ -1,81 +1,61 @@
-import { CliError, HARNESS_NAMES } from "./constants.js";
-export async function selectHarness(requested, env, commandExists) {
-    if (requested) {
-        if (await commandExists(requested, env))
-            return requested;
-        throw new CliError(`requested harness "${requested}" was not found on PATH`);
-    }
-    for (const harness of HARNESS_NAMES) {
-        if (await commandExists(harness, env))
-            return harness;
-    }
-    throw new CliError(`no supported harness found. Checked: ${HARNESS_NAMES.join(", ")}`);
-}
+import { Context, Effect, Layer } from "effect";
+import { HARNESS_NAMES } from "./constants.js";
+import { PreflightError } from "./errors.js";
+import { Shell } from "./shell.js";
+// How each harness is invoked headlessly: the flags that make it run one non-interactive turn and
+// auto-approve the tool calls a build needs (writes, npm, proof runs). This is hard-won per-harness
+// knowledge, kept verbatim from the original — the rewrite changes the orchestration around it, not
+// the invocations themselves.
 export function harnessInvocation(harness, prompt, cwd, harnessArgs = []) {
     switch (harness) {
         case "opencode":
-            // "--dangerously-skip-permissions" auto-approves tool calls; without it opencode gates
-            // writes/commands in a headless run (no user to approve), so file writes get rejected and
-            // stages like goal finish without producing their output file. Matches claude/gemini/grok.
-            // "--dir <cwd>" pins opencode's project directory to the spawned cwd. opencode otherwise
-            // resolves its own project root by walking up to a git root, and the
-            // GIT_CEILING_DIRECTORIES=<parent> env that buildSubprocessEnv injects perturbs that walk
-            // so writes land in the PARENT of the project dir — it reports "Patch 1 file / Created X"
-            // but the file is written one level up, so create's existsSync(GOAL.md) check then fails.
             return {
                 command: "opencode",
-                args: ["run", "--dangerously-skip-permissions", "--dir", cwd, ...harnessArgs, prompt],
-                cwd
+                args: ["run", "--dangerously-skip-permissions", "--dir", cwd, ...harnessArgs, prompt]
             };
         case "codex":
-            return {
-                command: "codex",
-                args: ["exec", "--skip-git-repo-check", ...harnessArgs, prompt],
-                cwd
-            };
+            return { command: "codex", args: ["exec", "--skip-git-repo-check", ...harnessArgs, prompt] };
         case "claude":
-            // The harness must run commands autonomously (Market searches, npm, vitexec proof checks,
-            // uikitml convert). "acceptEdits" only auto-approves file edits and gates every command,
-            // which deadlocks headless --print runs; bypassPermissions auto-approves commands too.
             return {
                 command: "claude",
-                args: ["--print", "--permission-mode", "bypassPermissions", ...harnessArgs, prompt],
-                cwd
+                args: ["--print", "--permission-mode", "bypassPermissions", ...harnessArgs, prompt]
             };
         case "pi":
-            return { command: "pi", args: [...harnessArgs, "-p", prompt], cwd };
+            return { command: "pi", args: [...harnessArgs, "-p", prompt] };
         case "gemini":
-            // "yolo" auto-approves commands too; "auto_edit" would gate them like claude's acceptEdits.
-            // Hardcoded flags come before harnessArgs so users can override them, matching claude.
-            // "--skip-trust" is required for headless runs: in an untrusted folder Gemini silently
-            // downgrades "yolo" back to "default" (gating every tool) and then errors out, so the turn
-            // dies in ~1s without doing anything.
             return {
                 command: "gemini",
-                args: ["--approval-mode", "yolo", "--skip-trust", ...harnessArgs, "--prompt", prompt],
-                cwd
+                args: ["--approval-mode", "yolo", "--skip-trust", ...harnessArgs, "--prompt", prompt]
             };
         case "grok":
-            // Headless single-turn: "-p" prints to stdout and exits; "--always-approve" auto-runs the
-            // commands/edits the build needs (npm, vitexec, file writes), matching claude/gemini's yolo.
             return {
                 command: "grok",
-                args: ["--always-approve", "--output-format", "plain", ...harnessArgs, "-p", prompt],
-                cwd
+                args: ["--always-approve", "--output-format", "plain", ...harnessArgs, "-p", prompt]
             };
         case "forge":
-            // "-p <prompt>" runs one command non-interactively and exits; in this mode forge auto-runs
-            // its tools (no approve/yolo flag exists or is needed — verified it writes files unattended).
-            // "-C <cwd>" pins forge's working directory. forge otherwise blocks waiting on stdin, but
-            // create's runner spawns with stdin ignored, so the turn proceeds. The model and reasoning
-            // effort come from forge's own config (the configured Opus 4.8 high), not a CLI flag.
-            return { command: "forge", args: ["-C", cwd, ...harnessArgs, "-p", prompt], cwd };
+            return { command: "forge", args: ["-C", cwd, ...harnessArgs, "-p", prompt] };
     }
 }
-/** Run one harness-turn: build the harness-command and hand it to the command-runner. */
-export async function runHarnessTurn(harnessRunner, prompt) {
-    return harnessRunner.runner({
-        ...harnessInvocation(harnessRunner.harness, prompt, harnessRunner.cwd, harnessRunner.harnessArgs),
-        timeoutMs: harnessRunner.timeoutMs
-    });
+export class Harness extends Context.Tag("Harness")() {
 }
+const live = (shell) => ({
+    runTurn: ({ harness, prompt, cwd, harnessArgs, timeoutMs }) => {
+        const { command, args } = harnessInvocation(harness, prompt, cwd, harnessArgs);
+        return shell.run({ command, args, cwd, timeoutMs });
+    },
+    select: (requested) => Effect.gen(function* () {
+        if (requested) {
+            if (yield* shell.exists(requested))
+                return requested;
+            return yield* Effect.fail(new PreflightError({ message: `requested harness "${requested}" was not found on PATH` }));
+        }
+        for (const harness of HARNESS_NAMES) {
+            if (yield* shell.exists(harness))
+                return harness;
+        }
+        return yield* Effect.fail(new PreflightError({
+            message: `no supported harness found on PATH. Checked: ${HARNESS_NAMES.join(", ")}`
+        }));
+    })
+});
+export const HarnessLive = Layer.effect(Harness, Effect.map(Shell, (shell) => live(shell)));

package/dist/index.d.ts

@@ -1,9 +1,13 @@
 export * from "./constants.js";
+export * from "./classify.js";
+export * from "./errors.js";
 export * from "./prompts.js";
-export * from "./subprocess.js";
-export * from "./progress-log.js";
+export * from "./logger.js";
+export * from "./shell.js";
+export * from "./git.js";
 export * from "./harness.js";
 export * from "./scaffold.js";
-export * from "./create.js";
+export * from "./resume.js";
+export * from "./stages.js";
 export * from "./supervisor.js";
 export * from "./command.js";

package/dist/index.js

@@ -1,9 +1,13 @@
 export * from "./constants.js";
+export * from "./classify.js";
+export * from "./errors.js";
 export * from "./prompts.js";
-export * from "./subprocess.js";
-export * from "./progress-log.js";
+export * from "./logger.js";
+export * from "./shell.js";
+export * from "./git.js";
 export * from "./harness.js";
 export * from "./scaffold.js";
-export * from "./create.js";
+export * from "./resume.js";
+export * from "./stages.js";
 export * from "./supervisor.js";
 export * from "./command.js";

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from "effect";
+export interface LoggerService {
+    readonly write: (text: string) => Effect.Effect<void>;
+    readonly captured: (line: string) => Effect.Effect<void>;
+}
+declare const Logger_base: Context.TagClass<Logger, "Logger", LoggerService>;
+export declare class Logger extends Logger_base {
+}
+export declare const LoggerLive: (logFile?: string) => Layer.Layer<Logger>;
+export declare const LoggerCollecting: (sink: string[]) => Layer.Layer<Logger>;
+export {};

package/dist/logger.js

@@ -0,0 +1,31 @@
+import { appendFileSync } from "node:fs";
+import { Context, Effect, Layer } from "effect";
+export class Logger extends Context.Tag("Logger")() {
+}
+function stamp() {
+    const now = new Date();
+    const pad = (value, length = 2) => String(value).padStart(length, "0");
+    return `[${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${pad(now.getMilliseconds(), 3)}]`;
+}
+// Appends synchronously: the volumes are tiny and an immediate flush means the log survives an
+// uncatchable SIGKILL, which is exactly the failure mode the log exists to explain. A missing/locked
+// file is swallowed — losing a log line must never abort the run it documents.
+const appendLine = (logFile, text) => {
+    if (logFile === undefined)
+        return;
+    try {
+        appendFileSync(logFile, `${text}\n`);
+    }
+    catch {
+        /* the run proceeds even if its log cannot be written */
+    }
+};
+export const LoggerLive = (logFile) => Layer.succeed(Logger, {
+    write: (text) => Effect.sync(() => appendLine(logFile, text)),
+    captured: (line) => Effect.sync(() => appendLine(logFile, `${stamp()} ${line}`))
+});
+// Test logger: collects everything into the given array so a test can assert what was logged.
+export const LoggerCollecting = (sink) => Layer.succeed(Logger, {
+    write: (text) => Effect.sync(() => void sink.push(text)),
+    captured: (line) => Effect.sync(() => void sink.push(line))
+});

package/dist/resume.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { type PipelineStage } from "./constants.js";
+import { Git, type StageMarker } from "./git.js";
+export type NextStep = {
+    readonly _tag: "stage";
+    readonly stage: PipelineStage;
+} | {
+    readonly _tag: "done";
+};
+export declare function stageAfter(marker: StageMarker | undefined): NextStep;
+export declare const planNext: (cwd: string) => Effect.Effect<NextStep, never, Git>;

package/dist/resume.js

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { PIPELINE_STAGES } from "./constants.js";
+import { Git } from "./git.js";
+// Pure mapping from "newest completed checkpoint" to "next thing to run". Kept pure so it is
+// exhaustively unit-tested against every marker without touching git.
+export function stageAfter(marker) {
+    if (marker === undefined)
+        return { _tag: "stage", stage: "scaffold" }; // a fresh directory
+    if (marker === "done")
+        return { _tag: "done" };
+    // "build" repeats once per turn; resuming at "build" keeps building until the plan is consumed,
+    // at which point the build stage records "done". Every other marker advances one stage in order.
+    if (marker === "build")
+        return { _tag: "stage", stage: "build" };
+    const next = PIPELINE_STAGES[PIPELINE_STAGES.indexOf(marker) + 1];
+    return next ? { _tag: "stage", stage: next } : { _tag: "done" };
+}
+export const planNext = (cwd) => Effect.flatMap(Git, (git) => Effect.map(git.latestStage(cwd), stageAfter));

package/dist/scaffold.d.ts

@@ -1,15 +1,13 @@
+import { Context, Effect, Layer } from "effect";
 import { type HarnessName } from "./constants.js";
-import { type CommandRunner } from "./subprocess.js";
+import { FsFailure, StageFailure } from "./errors.js";
+import { Shell } from "./shell.js";
 export declare function generateProjectName(): string;
-export declare function initGitRepo(cwd: string, runner: CommandRunner): Promise<void>;
-export declare function commitAll(cwd: string, runner: CommandRunner, message: string): Promise<void>;
-export declare function initNpmProject(cwd: string, _runner: CommandRunner): Promise<void>;
-export declare function ensureProjectGitignore(cwd: string): Promise<void>;
-export declare function ensureNpmrc(cwd: string): Promise<void>;
-export declare function ensureBaseProjectDirectories(cwd: string): Promise<void>;
-export declare function installSkills(cwd: string, harness: HarnessName, runner: CommandRunner): Promise<void>;
-export declare function installDependencies(cwd: string, runner: CommandRunner): Promise<void>;
-export declare function ensureStateReadme(cwd: string): Promise<void>;
-export declare function ensureLocalCliShims(cwd: string): Promise<void>;
-export declare function ensureMarketCliShim(cwd: string): Promise<void>;
-export declare function ensureActaCliShim(cwd: string): Promise<void>;
+export interface ScaffoldService {
+    readonly run: (cwd: string, harness: HarnessName) => Effect.Effect<void, StageFailure | FsFailure>;
+}
+declare const Scaffold_base: Context.TagClass<Scaffold, "Scaffold", ScaffoldService>;
+export declare class Scaffold extends Scaffold_base {
+}
+export declare const ScaffoldLive: Layer.Layer<Scaffold, never, Shell>;
+export {};