@electric-agent/agent 1.0.0

package/dist/engine/message-parser.d.ts

@@ -0,0 +1,8 @@
+import type { EngineEvent } from "@electric-agent/protocol";
+/**
+ * Parse an SDK message into one or more EngineEvents.
+ * This mirrors the logic in processAgentMessage but produces structured events
+ * instead of console output.
+ */
+export declare function sdkMessageToEvents(message: Record<string, unknown>, agent?: string): EngineEvent[];
+//# sourceMappingURL=message-parser.d.ts.map

package/dist/engine/message-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-parser.d.ts","sourceRoot":"","sources":["../../src/engine/message-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3D;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,KAAK,CAAC,EAAE,MAAM,GACZ,WAAW,EAAE,CAqGf"}

package/dist/engine/message-parser.js

@@ -0,0 +1,106 @@
+import { ts } from "@electric-agent/protocol";
+/**
+ * Parse an SDK message into one or more EngineEvents.
+ * This mirrors the logic in processAgentMessage but produces structured events
+ * instead of console output.
+ */
+export function sdkMessageToEvents(message, agent) {
+    const events = [];
+    if (message.type === "assistant" && message.message?.content) {
+        const content = message.message.content;
+        for (const block of content) {
+            if ("text" in block && block.text) {
+                const text = block.text;
+                events.push({ type: "assistant_message", text, agent, ts: ts() });
+            }
+            else if ("thinking" in block && block.thinking) {
+                events.push({
+                    type: "assistant_thinking",
+                    text: block.thinking,
+                    agent,
+                    ts: ts(),
+                });
+            }
+            else if ("name" in block) {
+                const name = block.name;
+                const input = (block.input || {});
+                const tool_use_id = (block.id || `tool_${Date.now()}`);
+                events.push({
+                    type: "pre_tool_use",
+                    tool_name: name,
+                    tool_use_id,
+                    tool_input: input,
+                    agent,
+                    ts: ts(),
+                });
+            }
+        }
+    }
+    else if (message.type === "user" && message.message?.content) {
+        // SDK sends tool results as user messages with tool_result content blocks
+        const msgContent = message.message.content;
+        if (Array.isArray(msgContent)) {
+            for (const block of msgContent) {
+                if (typeof block === "object" &&
+                    block &&
+                    block.type === "tool_result") {
+                    const b = block;
+                    const tool_use_id = (b.tool_use_id || "");
+                    const content = b.content;
+                    const texts = [];
+                    if (typeof content === "string") {
+                        texts.push(content);
+                    }
+                    else if (Array.isArray(content)) {
+                        for (const inner of content) {
+                            if (typeof inner === "object" && inner && "text" in inner) {
+                                texts.push(inner.text);
+                            }
+                        }
+                    }
+                    events.push({
+                        type: "post_tool_use",
+                        tool_use_id,
+                        tool_response: texts.join("\n"),
+                        agent,
+                        ts: ts(),
+                    });
+                }
+            }
+        }
+    }
+    else if (message.type === "result") {
+        const sub = String(message.subtype);
+        const cost = message.total_cost_usd;
+        const costStr = `(cost: $${cost?.toFixed(4) || "?"})`;
+        if (cost !== undefined) {
+            events.push({ type: "cost_update", totalCostUsd: cost, ts: ts() });
+        }
+        if (sub === "success") {
+            events.push({
+                type: "log",
+                level: "done",
+                message: `Agent completed ${costStr}`,
+                ts: ts(),
+            });
+        }
+        else if (sub.includes("max_turns")) {
+            events.push({
+                type: "log",
+                level: "task",
+                message: `Agent reached turn limit ${costStr}`,
+                ts: ts(),
+            });
+        }
+        else {
+            events.push({
+                type: "log",
+                level: "error",
+                message: `Agent stopped: ${sub} ${costStr}`,
+                ts: ts(),
+            });
+        }
+    }
+    return events;
+}
+//# sourceMappingURL=message-parser.js.map

package/dist/engine/message-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-parser.js","sourceRoot":"","sources":["../../src/engine/message-parser.ts"],"names":[],"mappings":"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"}

package/dist/engine/orchestrator.d.ts

@@ -0,0 +1,50 @@
+import type { EngineEvent } from "@electric-agent/protocol";
+export interface OrchestratorCallbacks {
+    onEvent: (event: EngineEvent) => void | Promise<void>;
+    onClarificationNeeded: (questions: string[], summary: string) => Promise<string[]>;
+    onPlanReady: (plan: string) => Promise<"approve" | "revise" | "cancel">;
+    onRevisionRequested: () => Promise<string>;
+    onContinueNeeded: () => Promise<boolean>;
+}
+/**
+ * Check if the target directory already exists. If so, append a random 4-char hex suffix.
+ */
+export declare function resolveProjectDir(baseDir: string, name: string): {
+    projectName: string;
+    projectDir: string;
+};
+/**
+ * Run the full "new project" flow.
+ */
+export declare function runNew(opts: {
+    description: string;
+    projectName?: string;
+    baseDir?: string;
+    verbose?: boolean;
+    autoApprove?: boolean;
+    initGit?: boolean;
+    callbacks: OrchestratorCallbacks;
+    abortController?: AbortController;
+    /** If provided, create a GitHub repo and push the scaffold before planning */
+    gitRepoName?: string;
+    gitRepoVisibility?: "public" | "private";
+}): Promise<{
+    sessionId?: string;
+    projectDir?: string;
+}>;
+/**
+ * Run a single iteration on an existing project.
+ */
+export declare function runIterate(opts: {
+    projectDir: string;
+    userRequest: string;
+    verbose?: boolean;
+    callbacks: OrchestratorCallbacks;
+    abortController?: AbortController;
+    resumeSessionId?: string;
+}): Promise<{
+    success: boolean;
+    errors: string[];
+    sessionId?: string;
+}>;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/engine/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/engine/orchestrator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAW3D,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAGrD,qBAAqB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IAClF,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAA;IACvE,mBAAmB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAC1C,gBAAgB,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACxC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACV;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAQ7C;AAuCD;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,qBAAqB,CAAA;IAChC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iBAAiB,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CACxC,GAAG,OAAO,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAyTvD;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,qBAAqB,CAAA;IAChC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmFtE"}

package/dist/engine/orchestrator.js

@@ -0,0 +1,492 @@
+import { execSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ts } from "@electric-agent/protocol";
+import { evaluateDescription, inferProjectName } from "../agents/clarifier.js";
+import { runCoder } from "../agents/coder.js";
+import { runPlanner } from "../agents/planner.js";
+import { createProgressReporter } from "../progress/reporter.js";
+import { scaffold } from "../scaffold/index.js";
+import { validatePlaybooks } from "../tools/playbook.js";
+import { updateSession } from "../working-memory/session.js";
+import { sdkMessageToEvents } from "./message-parser.js";
+/**
+ * Check if the target directory already exists. If so, append a random 4-char hex suffix.
+ */
+export function resolveProjectDir(baseDir, name) {
+    const candidate = path.resolve(baseDir, name);
+    if (!fs.existsSync(candidate)) {
+        return { projectName: name, projectDir: candidate };
+    }
+    const suffix = crypto.randomBytes(2).toString("hex");
+    const uniqueName = `${name}-${suffix}`;
+    return { projectName: uniqueName, projectDir: path.resolve(baseDir, uniqueName) };
+}
+function buildEnhancedDescription(original, questions, answers) {
+    let enhanced = original;
+    if (questions.length > 0) {
+        enhanced += "\n\nAdditional details:";
+        for (let i = 0; i < questions.length; i++) {
+            if (answers[i]) {
+                enhanced += `\n- ${questions[i]} ${answers[i]}`;
+            }
+        }
+    }
+    // Extra free-text answer beyond the numbered questions
+    const extra = answers[questions.length];
+    if (extra) {
+        enhanced += `\n\nExtra context from the user:\n${extra}`;
+    }
+    return enhanced;
+}
+/**
+ * Create an onMessage callback that parses SDK messages into EngineEvents.
+ */
+function createMessageForwarder(callbacks, agent) {
+    return (msg) => {
+        const events = sdkMessageToEvents(msg, agent);
+        for (const event of events) {
+            callbacks.onEvent(event);
+        }
+    };
+}
+/**
+ * Run the full "new project" flow.
+ */
+export async function runNew(opts) {
+    const { callbacks } = opts;
+    const emit = (event) => callbacks.onEvent(event);
+    const reporter = createReporterFromCallbacks(callbacks, opts.verbose);
+    // Step 0: Evaluate confidence, clarify if needed, and infer project name
+    // Run evaluation and name inference in parallel to save time
+    let description = opts.description;
+    let inferredName = opts.projectName || "";
+    emit({ type: "log", level: "plan", message: "Analyzing your description...", ts: ts() });
+    try {
+        // Run evaluation and name inference concurrently — both use the original description
+        const [evaluation, earlyName] = await Promise.all([
+            evaluateDescription(opts.description),
+            inferredName || inferProjectName(opts.description),
+        ]);
+        if (!inferredName)
+            inferredName = earlyName;
+        if (evaluation.confidence < 70) {
+            emit({
+                type: "log",
+                level: "plan",
+                message: `Confidence: ${evaluation.confidence}% — need more details before planning`,
+                ts: ts(),
+            });
+            emit({
+                type: "clarification_needed",
+                questions: evaluation.questions,
+                confidence: evaluation.confidence,
+                summary: evaluation.summary,
+                ts: ts(),
+            });
+            const answers = await callbacks.onClarificationNeeded(evaluation.questions, evaluation.summary);
+            description = buildEnhancedDescription(opts.description, evaluation.questions, answers);
+            emit({
+                type: "log",
+                level: "plan",
+                message: "Description enriched with your answers",
+                ts: ts(),
+            });
+        }
+        else {
+            emit({
+                type: "log",
+                level: "plan",
+                message: `Confidence: ${evaluation.confidence}% — description is clear`,
+                ts: ts(),
+            });
+        }
+    }
+    catch {
+        emit({ type: "log", level: "plan", message: "Skipping clarification step", ts: ts() });
+        if (!inferredName)
+            inferredName = await inferProjectName(description);
+    }
+    const baseDir = opts.baseDir || process.cwd();
+    // When the caller provides an explicit projectName (e.g. server/sandbox),
+    // use it as-is — no dedup suffix. A sprite has exactly one project, and
+    // the server-sent name is used for the GitHub repo. Only add entropy
+    // when the name was inferred and might collide on a developer's machine.
+    const { projectName, projectDir } = opts.projectName
+        ? { projectName: inferredName, projectDir: path.resolve(baseDir, inferredName) }
+        : resolveProjectDir(baseDir, inferredName);
+    emit({ type: "log", level: "plan", message: `Creating project: ${projectName}`, ts: ts() });
+    emit({ type: "log", level: "plan", message: `Description: ${description}`, ts: ts() });
+    // Step 1: Scaffold
+    emit({
+        type: "log",
+        level: "task",
+        message: "Scaffolding project from KPB template...",
+        ts: ts(),
+    });
+    const skipGit = opts.initGit === false;
+    const scaffoldResult = await scaffold(projectDir, { projectName, reporter, skipGit });
+    if (scaffoldResult.errors.length > 0) {
+        for (const err of scaffoldResult.errors) {
+            emit({ type: "log", level: "error", message: err, ts: ts() });
+        }
+    }
+    if (scaffoldResult.skippedInstall) {
+        emit({
+            type: "log",
+            level: "error",
+            message: "Dependency install failed. You may need to run 'pnpm install' manually.",
+            ts: ts(),
+        });
+    }
+    // Validate critical project structure before proceeding to planner/coder
+    const pkgExists = fs.existsSync(path.join(projectDir, "package.json"));
+    if (!pkgExists) {
+        emit({
+            type: "log",
+            level: "error",
+            message: "Critical: package.json missing after scaffold — cannot proceed",
+            ts: ts(),
+        });
+        emit({
+            type: "phase_complete",
+            phase: "scaffold",
+            success: false,
+            errors: ["package.json missing after scaffold"],
+            ts: ts(),
+        });
+        return { projectDir };
+    }
+    emit({ type: "log", level: "done", message: "Scaffold complete", ts: ts() });
+    // Step 1b: Validate playbooks
+    try {
+        validatePlaybooks(projectDir);
+    }
+    catch (e) {
+        emit({
+            type: "log",
+            level: "error",
+            message: e instanceof Error ? e.message : "Playbook validation failed",
+            ts: ts(),
+        });
+        emit({
+            type: "phase_complete",
+            phase: "scaffold",
+            success: false,
+            errors: ["Playbook validation failed"],
+            ts: ts(),
+        });
+        return { projectDir };
+    }
+    // Step 1c: Create GitHub repo and push scaffold (if repo config provided)
+    if (opts.gitRepoName) {
+        emit({
+            type: "log",
+            level: "task",
+            message: "Creating GitHub repo and pushing scaffold...",
+            ts: ts(),
+        });
+        gitAutoCommit(projectDir, "chore: initial scaffold", emit);
+        try {
+            const vis = opts.gitRepoVisibility || "private";
+            execSync(`gh repo create "${opts.gitRepoName}" --${vis} --source . --remote origin --push`, {
+                cwd: projectDir,
+                stdio: "pipe",
+                timeout: 60_000,
+                env: { ...process.env },
+            });
+            emit({
+                type: "log",
+                level: "done",
+                message: `GitHub repo created: ${opts.gitRepoName} (${vis})`,
+                ts: ts(),
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "unknown error";
+            emit({ type: "log", level: "error", message: `Repo creation failed: ${msg}`, ts: ts() });
+            emit({ type: "session_end", success: false, ts: ts() });
+            return { projectDir };
+        }
+    }
+    // Step 2: Plan
+    emit({ type: "log", level: "plan", message: "Running planner agent...", ts: ts() });
+    const plannerForwarder = createMessageForwarder(callbacks, "planner");
+    let plan = await runPlanner(description, projectDir, reporter, plannerForwarder, opts.abortController);
+    // Step 3: Approve
+    if (!opts.autoApprove) {
+        emit({ type: "plan_ready", plan, ts: ts() });
+        let decision = await callbacks.onPlanReady(plan);
+        while (decision === "revise") {
+            const feedback = await callbacks.onRevisionRequested();
+            emit({
+                type: "log",
+                level: "plan",
+                message: "Re-running planner with feedback...",
+                ts: ts(),
+            });
+            plan = await runPlanner(`${description}\n\nRevision feedback: ${feedback}`, projectDir, reporter, plannerForwarder, opts.abortController);
+            emit({ type: "plan_ready", plan, ts: ts() });
+            decision = await callbacks.onPlanReady(plan);
+        }
+        if (decision === "cancel") {
+            emit({ type: "log", level: "error", message: "Cancelled by user", ts: ts() });
+            emit({
+                type: "session_end",
+                success: false,
+                ts: ts(),
+            });
+            return { projectDir };
+        }
+    }
+    // Step 4: Write plan and initialize session (parallel — independent operations)
+    const fsPromises = await import("node:fs/promises");
+    await Promise.all([
+        fsPromises.writeFile(path.join(projectDir, "PLAN.md"), plan, "utf-8"),
+        updateSession(projectDir, {
+            appName: projectName,
+            currentPhase: "generation",
+            currentTask: "Starting code generation",
+            buildStatus: "pending",
+            totalBuilds: 0,
+            totalErrors: 0,
+            escalations: 0,
+        }),
+    ]);
+    // Step 5: Run coder (with continuation on max turns / max budget)
+    emit({ type: "log", level: "task", message: "Running coder agent...", ts: ts() });
+    const coderForwarder = createMessageForwarder(callbacks, "coder");
+    let result = await runCoder(projectDir, undefined, reporter, coderForwarder, undefined, opts.abortController);
+    while (result.stopReason === "max_turns" || result.stopReason === "max_budget") {
+        emit({
+            type: "continue_needed",
+            reason: result.stopReason,
+            ts: ts(),
+        });
+        const shouldContinue = await callbacks.onContinueNeeded();
+        if (!shouldContinue) {
+            emit({
+                type: "log",
+                level: "done",
+                message: "Stopped by user. Run 'electric-agent iterate' to continue later.",
+                ts: ts(),
+            });
+            emit({ type: "session_end", success: true, ts: ts() });
+            return { sessionId: result.sessionId, projectDir };
+        }
+        emit({ type: "log", level: "task", message: "Continuing coder agent...", ts: ts() });
+        result = await runCoder(projectDir, "Continue where you left off. Keep working on the remaining unchecked tasks in PLAN.md.", reporter, coderForwarder, result.sessionId, opts.abortController);
+    }
+    if (result.success) {
+        // Auto-commit after successful generation
+        emit({ type: "log", level: "task", message: "Creating git commit...", ts: ts() });
+        const commitResult = gitAutoCommit(projectDir, "feat: initial app generation", emit);
+        if (commitResult) {
+            emit({
+                type: "git_checkpoint",
+                commitHash: commitResult,
+                message: "feat: initial app generation",
+                ts: ts(),
+            });
+            // Push to remote if one exists (e.g. repo was created during scaffold)
+            gitAutoPush(projectDir, emit);
+        }
+        emit({
+            type: "log",
+            level: "done",
+            message: `Project ${projectName} created successfully!`,
+            ts: ts(),
+        });
+        emit({ type: "log", level: "done", message: `  cd ${projectName}`, ts: ts() });
+        emit({ type: "log", level: "done", message: "  electric-agent up", ts: ts() });
+    }
+    else {
+        emit({
+            type: "log",
+            level: "error",
+            message: `Generation completed with errors: ${result.errors.join(", ")}`,
+            ts: ts(),
+        });
+        emit({
+            type: "log",
+            level: "error",
+            message: "Run 'electric-agent iterate' to continue fixing issues",
+            ts: ts(),
+        });
+    }
+    emit({
+        type: "phase_complete",
+        phase: "generation",
+        success: result.success,
+        errors: result.errors,
+        ts: ts(),
+    });
+    emit({ type: "session_end", success: result.success, ts: ts() });
+    return { sessionId: result.sessionId, projectDir };
+}
+/**
+ * Run a single iteration on an existing project.
+ */
+export async function runIterate(opts) {
+    const { callbacks, projectDir, userRequest } = opts;
+    const emit = (event) => callbacks.onEvent(event);
+    const reporter = createReporterFromCallbacks(callbacks, opts.verbose);
+    const messageForwarder = createMessageForwarder(callbacks, "coder");
+    const iterationPrompt = `The user wants the following change to the existing app:
+
+${userRequest}
+
+Instructions:
+1. Consult ARCHITECTURE.md (injected into your context as <app-architecture>) to understand the app structure — do NOT scan the filesystem
+2. Read PLAN.md to see what was built and previous iterations
+3. Read "electric-app-guardrails" playbook FIRST for critical integration rules
+4. Use list_playbooks to discover relevant skills, then read only what you need for this change
+5. Add a new "## Iteration: ${userRequest.slice(0, 60)}" section to the bottom of PLAN.md with tasks for this change
+6. Read ONLY the specific source files you need to modify (consult ARCHITECTURE.md for exact paths)
+7. Implement the changes immediately — write the actual code, following the Drizzle Workflow order
+8. If schema changes are needed, run drizzle-kit generate && drizzle-kit migrate
+9. Mark tasks as done in PLAN.md after completing them
+10. Update ARCHITECTURE.md to reflect any changes (new entities, routes, components, styles, or contexts)
+11. Run the build tool ONCE after all changes are complete — not after each file
+
+Do NOT just write a plan — implement the changes directly.`;
+    emit({ type: "log", level: "task", message: "Running coder with your request...", ts: ts() });
+    let result = await runCoder(projectDir, iterationPrompt, reporter, messageForwarder, opts.resumeSessionId, opts.abortController);
+    while (result.stopReason === "max_turns" || result.stopReason === "max_budget") {
+        emit({ type: "continue_needed", reason: result.stopReason, ts: ts() });
+        const shouldContinue = await callbacks.onContinueNeeded();
+        if (!shouldContinue) {
+            emit({
+                type: "log",
+                level: "done",
+                message: "Paused. You can continue this work in the next iteration.",
+                ts: ts(),
+            });
+            return { success: true, errors: [], sessionId: result.sessionId };
+        }
+        emit({ type: "log", level: "task", message: "Continuing coder agent...", ts: ts() });
+        result = await runCoder(projectDir, "Continue where you left off. Keep implementing the remaining changes.", reporter, messageForwarder, result.sessionId, opts.abortController);
+    }
+    if (result.success) {
+        // Auto-commit after successful iteration
+        emit({ type: "log", level: "task", message: "Creating git commit...", ts: ts() });
+        const commitMsg = `feat: ${userRequest.slice(0, 70)}`;
+        const commitResult = gitAutoCommit(projectDir, commitMsg, emit);
+        if (commitResult) {
+            emit({
+                type: "git_checkpoint",
+                commitHash: commitResult,
+                message: commitMsg,
+                ts: ts(),
+            });
+        }
+        emit({ type: "log", level: "done", message: "Changes applied successfully", ts: ts() });
+    }
+    else {
+        emit({
+            type: "log",
+            level: "error",
+            message: `Issues: ${result.errors.join(", ")}`,
+            ts: ts(),
+        });
+    }
+    return { success: result.success, errors: result.errors, sessionId: result.sessionId };
+}
+/**
+ * Stage all changes and commit. Returns the commit hash, or null if there were no changes.
+ */
+function gitAutoCommit(projectDir, message, emit) {
+    // Check for .git directory before attempting git operations
+    if (!fs.existsSync(path.join(projectDir, ".git"))) {
+        emit({
+            type: "log",
+            level: "error",
+            message: "Skipping git commit — no .git directory found (git init may have failed during scaffold)",
+            ts: ts(),
+        });
+        return null;
+    }
+    try {
+        execSync("git add -A", { cwd: projectDir, stdio: "pipe" });
+        try {
+            execSync("git diff --cached --quiet", { cwd: projectDir, stdio: "pipe" });
+            emit({ type: "log", level: "done", message: "No changes to commit", ts: ts() });
+            return null;
+        }
+        catch {
+            // There are staged changes — proceed
+        }
+        const safeMsg = message.replace(/"/g, '\\"');
+        execSync(`git commit -m "${safeMsg}"`, { cwd: projectDir, stdio: "pipe" });
+        const hash = execSync("git rev-parse HEAD", {
+            cwd: projectDir,
+            encoding: "utf-8",
+            stdio: "pipe",
+        }).trim();
+        emit({ type: "log", level: "done", message: `Committed: ${message}`, ts: ts() });
+        return hash;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        emit({ type: "log", level: "error", message: `Git commit failed: ${msg}`, ts: ts() });
+        return null;
+    }
+}
+/**
+ * Push to remote origin if configured. Silently skips if no remote exists.
+ */
+function gitAutoPush(projectDir, emit) {
+    try {
+        // Check if a remote origin exists
+        const remote = execSync("git remote get-url origin", {
+            cwd: projectDir,
+            encoding: "utf-8",
+            stdio: "pipe",
+        }).trim();
+        if (!remote) {
+            emit({
+                type: "log",
+                level: "verbose",
+                message: "No remote configured — skipping push",
+                ts: ts(),
+            });
+            return;
+        }
+        const branch = execSync("git branch --show-current", {
+            cwd: projectDir,
+            encoding: "utf-8",
+            stdio: "pipe",
+        }).trim();
+        emit({ type: "log", level: "task", message: `Pushing to origin/${branch}...`, ts: ts() });
+        const pushOutput = execSync(`git push -u origin ${branch} 2>&1`, {
+            cwd: projectDir,
+            encoding: "utf-8",
+            timeout: 60_000,
+            env: { ...process.env },
+        }).trim();
+        if (pushOutput) {
+            emit({ type: "log", level: "verbose", message: pushOutput, ts: ts() });
+        }
+        emit({ type: "log", level: "done", message: `Pushed to origin/${branch}`, ts: ts() });
+    }
+    catch (err) {
+        const detail = err?.stderr ||
+            err?.stdout ||
+            (err instanceof Error ? err.message : "Push failed");
+        emit({
+            type: "log",
+            level: "error",
+            message: `Git push failed: ${detail}`,
+            ts: ts(),
+        });
+    }
+}
+/**
+ * Create a ProgressReporter that works for both CLI and web by forwarding to the engine callback.
+ * The reporter is used by scaffold and other components that need it directly.
+ */
+function createReporterFromCallbacks(_callbacks, verbose) {
+    return createProgressReporter({ verbose });
+}
+//# sourceMappingURL=orchestrator.js.map