@shaykec/app-agent 1.0.0

package/dist/index.js

@@ -0,0 +1,929 @@
+#!/usr/bin/env node
+import * as p from "@clack/prompts";
+import fs from "fs-extra";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { collectUserInput, confirmInput, parseCliArgs, parseManagementCommand } from "./cli.js";
+import { buildAgentPrompt, buildTestPrompt, buildScratchPrompt, buildQuickPrompt, buildUpdatePrompt } from "./prompt-builder.js";
+import { createEngine } from "./engines/index.js";
+import { validateOutput, reportValidation } from "./validator.js";
+import { validatePrompt, formatSanitizationResult } from "./prompt-sanitizer.js";
+import { checkGitHubPrereqs, pushToGitHub, deriveRepoName, commitChanges, pushBranch, createPullRequest, isGitRepo, hasRemoteOrigin, collectScreenshots, ensureScreenshotsGitignoreException, generateReadmeScreenshots, buildPrBodyWithScreenshots, } from "./github.js";
+import { PATHS, ASSET_PATHS, DEFAULT_ENGINE, DEFAULT_MODEL, SKELETON_TEMPLATE_NAME, expandPlatform } from "./config.js";
+import { listApps, runApp, resolveAppContext } from "./app-manager.js";
+import { scaffoldWorkspace, cleanupWorkspace } from "./workspace.js";
+import { resolveUpdateContext } from "./updater.js";
+/** Peek at argv for --engine flag before full CLI parsing (needed for pre-flight check) */
+function peekEngineFlag() {
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        if ((args[i] === "--engine" || args[i] === "-e") && args[i + 1]) {
+            return args[i + 1];
+        }
+    }
+    return undefined;
+}
+async function main() {
+    // ── Management commands (no build agent needed) ─────────────────────
+    const mgmtCmd = parseManagementCommand();
+    if (mgmtCmd) {
+        if (mgmtCmd.command === "list") {
+            await listApps();
+        }
+        else if (mgmtCmd.command === "run") {
+            await runApp(mgmtCmd.appName);
+        }
+        else if (mgmtCmd.command === "test") {
+            await testApp(mgmtCmd.appName, mgmtCmd.engine, mgmtCmd.model);
+        }
+        return;
+    }
+    // ── Determine engine ────────────────────────────────────────────────
+    // Engine can come from CLI flags (parsed later) or env var; peek at argv for early detection
+    const earlyEngine = peekEngineFlag() ?? DEFAULT_ENGINE;
+    const engine = createEngine(earlyEngine);
+    // ── Pre-flight checks ───────────────────────────────────────────────
+    const agentCheck = await engine.checkInstallation();
+    if (!agentCheck.ok) {
+        p.log.error(agentCheck.error);
+        process.exit(1);
+    }
+    const ghCheck = await checkGitHubPrereqs();
+    if (!ghCheck.ok) {
+        for (const err of ghCheck.errors) {
+            p.log.warn(err);
+        }
+        p.log.warn("GitHub push will be skipped. You can push manually after the build.");
+    }
+    // ── Collect user input ──────────────────────────────────────────────
+    const cliResult = parseCliArgs();
+    const input = cliResult?.input ?? await collectUserInput();
+    const cliFlags = cliResult?.flags ?? {};
+    // Re-resolve engine with the actual flag value (CLI flags override peek)
+    const selectedEngine = cliFlags.engine ?? input.engine ?? earlyEngine;
+    const resolvedEngine = selectedEngine !== earlyEngine ? createEngine(selectedEngine) : engine;
+    if (!cliResult) {
+        await confirmInput(input);
+    }
+    else {
+        if (input.update) {
+            p.log.info(`Target:   ${input.updateTarget}`);
+            p.log.info(`Change:   ${input.description}`);
+            p.log.info(`Engine:   ${resolvedEngine.name}`);
+            p.log.info(`Model:    ${input.model}`);
+            p.log.info("Mode:     Update");
+        }
+        else {
+            p.log.info(`App:      ${input.description}`);
+            p.log.info(`Platform: ${input.platform}`);
+            p.log.info(`Engine:   ${resolvedEngine.name}`);
+            p.log.info(`Model:    ${input.model}`);
+            if (input.quick) {
+                p.log.info("Mode:     Quick");
+            }
+            else if (input.scratch) {
+                p.log.info("Mode:     From scratch");
+            }
+        }
+    }
+    // ── Prompt security validation (Layer 1) ────────────────────────────
+    p.log.step("Validating prompt security...");
+    const sanitization = validatePrompt(input.description);
+    if (!sanitization.safe) {
+        p.log.error("Prompt rejected by security sanitizer:");
+        p.log.error(formatSanitizationResult(sanitization));
+        p.outro("Your app description was blocked because it contains patterns associated with prompt injection, " +
+            "malicious intent, or system manipulation. Please rephrase your description to focus on what the app " +
+            "should do for its users.");
+        process.exit(1);
+    }
+    if (sanitization.findings.length > 0) {
+        p.log.warn("Prompt security warnings (proceeding with caution):");
+        p.log.warn(formatSanitizationResult(sanitization));
+    }
+    else {
+        p.log.info("Prompt security check passed.");
+    }
+    // ── Scaffold workspace (npx mode) ───────────────────────────────────
+    // When running as an installed npm package, create symlinks and config
+    // files in the user's cwd so the agent engine can find assets.
+    await scaffoldWorkspace();
+    // ── Ensure output directory exists ─────────────────────────────────
+    await fs.ensureDir(PATHS.output);
+    // Note: previously built apps are preserved in output/.
+    // Use `--list` to see all apps or `--run <name>` to launch one on a simulator.
+    // ── Update mode (separate flow) ────────────────────────────────────
+    if (input.update && input.updateTarget) {
+        await updateApp(input, resolvedEngine, ghCheck.ok);
+        return;
+    }
+    // ── Dual-platform build (parallel) ──────────────────────────────────
+    if (input.platform === "both") {
+        await runParallelBuild(input, resolvedEngine, cliResult, cliFlags, ghCheck.ok);
+        return;
+    }
+    // ── Build agent prompt (single platform) ───────────────────────────
+    let prompt;
+    // Safe cast: at this point platform is "ios" | "android" (not "both")
+    const singlePlatform = input.platform;
+    // Always use monorepo layout: output/{app-name}/{platform}/
+    const appName = deriveAppName(input.description);
+    const monorepoDir = path.join(PATHS.output, appName); // repo root for GitHub
+    const appDir = path.join(monorepoDir, singlePlatform); // where code lives
+    let knownAppDir = appDir;
+    if (input.quick) {
+        // Quick mode: orchestrator pre-clones the skeleton template, renames it, and generates project
+        const displayName = deriveDisplayName(appName);
+        const bundleId = deriveBundleId(appName);
+        // Clone skeleton template
+        const skeletonPath = path.join(PATHS.templates, singlePlatform, SKELETON_TEMPLATE_NAME);
+        if (!(await fs.pathExists(skeletonPath))) {
+            p.log.error(`Skeleton template not found at: ${skeletonPath}`);
+            process.exit(1);
+        }
+        // Remove existing monorepo dir if present
+        if (await fs.pathExists(monorepoDir)) {
+            await fs.remove(monorepoDir);
+        }
+        await fs.copy(skeletonPath, appDir);
+        p.log.info(`Skeleton cloned to: ${appDir}`);
+        // Rename the template from "Skeleton" to the app name
+        const renameScript = path.join(ASSET_PATHS.scripts, "rename-template.sh");
+        if (await fs.pathExists(renameScript)) {
+            try {
+                execSync(`bash "${renameScript}" "${SKELETON_TEMPLATE_NAME}" "${displayName}" "${bundleId}" "${singlePlatform}" "${appDir}"`, { stdio: "pipe", timeout: 60000 });
+                p.log.info(`Renamed: ${SKELETON_TEMPLATE_NAME} → ${displayName}`);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                p.log.warn(`Rename script failed: ${errMsg.slice(0, 200)}`);
+                p.log.warn("Agent will handle remaining renames.");
+            }
+        }
+        else {
+            p.log.warn("Rename script not found — agent will rename manually.");
+        }
+        p.log.info(`App name: ${appName} | Display: ${displayName} | Bundle ID: ${bundleId}`);
+        prompt = await buildQuickPrompt({ ...input, platform: singlePlatform }, appDir, appName, bundleId);
+        p.log.info("Quick prompt built successfully.");
+    }
+    else if (input.scratch) {
+        // Ensure the monorepo structure exists for scratch mode
+        await fs.ensureDir(appDir);
+        prompt = await buildScratchPrompt(input);
+        // Redirect agent output to the platform subdir (monorepo layout)
+        prompt += `\n\n## OUTPUT DIRECTORY OVERRIDE\n\n` +
+            `IMPORTANT: This build uses a monorepo layout. You MUST write ALL output to \`${appDir}/\` instead of \`output/{app-name}/\`.\n` +
+            `Use "${appName}" as the app name (do NOT append the platform suffix).\n` +
+            `The app directory is: ${appDir}\n` +
+            `Reports go to: ${appDir}/reports/\n` +
+            `Tests go to: ${appDir}/tests/\n`;
+        p.log.info("Scratch prompt built successfully.");
+    }
+    else {
+        // Ensure the monorepo structure exists for template mode
+        await fs.ensureDir(appDir);
+        prompt = await buildAgentPrompt(input);
+        // Redirect agent output to the platform subdir (monorepo layout)
+        prompt += `\n\n## OUTPUT DIRECTORY OVERRIDE\n\n` +
+            `IMPORTANT: This build uses a monorepo layout. You MUST write ALL output to \`${appDir}/\` instead of \`output/{app-name}/\`.\n` +
+            `Use "${appName}" as the app name (do NOT append the platform suffix).\n` +
+            `The app directory is: ${appDir}\n` +
+            `Reports go to: ${appDir}/reports/\n` +
+            `Tests go to: ${appDir}/tests/\n`;
+        p.log.info("Agent prompt built successfully.");
+    }
+    // ── Run the agent engine ────────────────────────────────────────────
+    p.log.step(`Launching ${resolvedEngine.name} agent...`);
+    const runOptions = input.quick ? { skipContinuation: true } : {};
+    const agentResult = await resolvedEngine.run(prompt, input.model, runOptions);
+    if (!agentResult.success) {
+        p.log.error(`Agent failed: ${agentResult.error}`);
+        p.outro("The agent did not complete successfully. Check the output directory for partial results.");
+        process.exit(1);
+    }
+    // ── Proof of work summary ──────────────────────────────────────────
+    displayProofOfWork(agentResult);
+    // ── Report-based proof of work (from summary.json) ─────────────────
+    const reportTarget = knownAppDir
+        ? `${appName}/${singlePlatform}` // e.g., "pet-grooming/ios"
+        : undefined;
+    const reportMeta = await displayReportSummary(reportTarget);
+    // Stream-based Maestro test results (fallback if summary.json missing)
+    displayMaestroResults(agentResult);
+    // ── Validate output ─────────────────────────────────────────────────
+    p.log.step("Validating generated app...");
+    const validation = await validateOutput(singlePlatform, knownAppDir);
+    reportValidation(validation);
+    if (!validation.valid) {
+        p.outro("Validation failed. The stop hook may have already retried. Check output/ for details.");
+        process.exit(1);
+    }
+    // ── Push to GitHub (monorepo root, not the platform subdir) ────────
+    await handleGitHubPush(cliResult, cliFlags, ghCheck.ok, monorepoDir, reportMeta.artifactPath);
+}
+// ---------------------------------------------------------------------------
+// Parallel Build (dual-platform) — works for quick, create, and scratch modes
+// ---------------------------------------------------------------------------
+/**
+ * Run builds for both iOS and Android in parallel.
+ * Creates a monorepo structure: output/{app-name}/ios/ and output/{app-name}/android/
+ *
+ * Quick mode: orchestrator pre-clones + renames skeleton templates before launching agents.
+ * Create/scratch mode: agents handle cloning/writing themselves; we just ensure the directory structure.
+ */
+async function runParallelBuild(input, engine, cliResult, cliFlags, ghAvailable) {
+    const platforms = expandPlatform("both"); // ["ios", "android"]
+    const appName = deriveAppName(input.description);
+    const displayName = deriveDisplayName(appName);
+    const monorepoDir = path.join(PATHS.output, appName);
+    const bundleId = deriveBundleId(appName);
+    const modeLabel = input.quick ? "quick" : input.scratch ? "scratch" : "create";
+    p.log.step(`Dual-platform ${modeLabel} build: ${displayName} (iOS + Android)`);
+    // Remove existing output dir if present
+    if (await fs.pathExists(monorepoDir)) {
+        await fs.remove(monorepoDir);
+    }
+    await fs.ensureDir(monorepoDir);
+    // Quick mode: clone + rename both skeletons before launching agents
+    if (input.quick) {
+        const renameScript = path.join(ASSET_PATHS.scripts, "rename-template.sh");
+        const hasRenameScript = await fs.pathExists(renameScript);
+        for (const plat of platforms) {
+            const platDir = path.join(monorepoDir, plat);
+            const skeletonPath = path.join(PATHS.templates, plat, SKELETON_TEMPLATE_NAME);
+            if (!(await fs.pathExists(skeletonPath))) {
+                p.log.error(`Skeleton template not found for ${plat}: ${skeletonPath}`);
+                process.exit(1);
+            }
+            await fs.copy(skeletonPath, platDir);
+            p.log.info(`[${plat}] Skeleton cloned to: ${platDir}`);
+            if (hasRenameScript) {
+                try {
+                    execSync(`bash "${renameScript}" "${SKELETON_TEMPLATE_NAME}" "${displayName}" "${bundleId}" "${plat}" "${platDir}"`, { stdio: "pipe", timeout: 60000 });
+                    p.log.info(`[${plat}] Renamed: ${SKELETON_TEMPLATE_NAME} → ${displayName}`);
+                }
+                catch (e) {
+                    const errMsg = e instanceof Error ? e.message : String(e);
+                    p.log.warn(`[${plat}] Rename script failed: ${errMsg.slice(0, 200)}`);
+                }
+            }
+        }
+    }
+    else {
+        // Create/scratch: just ensure per-platform subdirectories exist
+        for (const plat of platforms) {
+            await fs.ensureDir(path.join(monorepoDir, plat));
+        }
+    }
+    p.log.info(`App name: ${appName} | Display: ${displayName} | Bundle ID: ${bundleId}`);
+    // Build prompts for each platform using the appropriate prompt builder
+    const prompts = {};
+    for (const plat of platforms) {
+        const platInput = { ...input, platform: plat };
+        const platDir = path.join(monorepoDir, plat);
+        if (input.quick) {
+            prompts[plat] = await buildQuickPrompt(platInput, platDir, appName, bundleId);
+        }
+        else if (input.scratch) {
+            prompts[plat] = await buildScratchPrompt(platInput);
+        }
+        else {
+            prompts[plat] = await buildAgentPrompt(platInput);
+        }
+        // For create/scratch: tell the agent to write into the platform subdirectory
+        // Quick mode already has appDir baked into the prompt by buildQuickPrompt
+        if (!input.quick) {
+            prompts[plat] += `\n\n## OUTPUT DIRECTORY OVERRIDE\n\n` +
+                `IMPORTANT: This is a dual-platform build. You MUST write ALL output to \`${platDir}/\` instead of \`output/{app-name}/\`.\n` +
+                `Use "${appName}" as the app name (do NOT append the platform suffix).\n` +
+                `The app directory is: ${platDir}\n` +
+                `Reports go to: ${platDir}/reports/\n` +
+                `Tests go to: ${platDir}/tests/\n`;
+        }
+    }
+    // Run both agents in parallel
+    p.log.step(`Launching 2 parallel ${engine.name} agents (iOS + Android)...`);
+    const results = await Promise.allSettled(platforms.map((plat, idx) => {
+        const opts = {
+            // Quick mode agents don't need continuation; create/scratch agents do
+            skipContinuation: input.quick,
+            debugLogSuffix: `-${plat}`,
+            // Only the first agent cleans up MCP; the second skips to avoid killing sibling's processes
+            skipMcpCleanup: idx > 0,
+            // Distinguish parallel agents in logs and avoid spinner animation fighting
+            logPrefix: `[${plat}]`,
+            noSpinner: true,
+        };
+        return engine.run(prompts[plat], input.model, opts);
+    }));
+    // Process results
+    const platformResults = [];
+    for (let i = 0; i < platforms.length; i++) {
+        const plat = platforms[i];
+        const result = results[i];
+        if (result.status === "fulfilled") {
+            const agentResult = result.value;
+            platformResults.push({
+                platform: plat,
+                success: agentResult.success,
+                error: agentResult.error,
+                proof: agentResult.proof,
+            });
+            if (agentResult.success) {
+                p.log.success(`[${plat}] Agent completed successfully`);
+            }
+            else {
+                p.log.error(`[${plat}] Agent failed: ${agentResult.error}`);
+            }
+        }
+        else {
+            platformResults.push({
+                platform: plat,
+                success: false,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+            p.log.error(`[${plat}] Agent crashed: ${result.reason}`);
+        }
+    }
+    // Display combined proof of work
+    for (const pr of platformResults) {
+        if (pr.proof) {
+            p.log.step(`[${pr.platform}] Proof of work:`);
+            p.log.info(`  Files written:  ${pr.proof.filesWritten}`);
+            p.log.info(`  Files read:     ${pr.proof.filesRead}`);
+            p.log.info(`  Shell commands: ${pr.proof.shellCommands.length}`);
+            if (pr.proof.costUsd > 0) {
+                p.log.info(`  API cost:       $${pr.proof.costUsd.toFixed(4)}`);
+            }
+        }
+    }
+    // Report total cost
+    const totalCost = platformResults.reduce((sum, pr) => sum + (pr.proof?.costUsd ?? 0), 0);
+    if (totalCost > 0) {
+        p.log.info(`  Total API cost: $${totalCost.toFixed(4)}`);
+    }
+    // Display report summaries for each platform and collect artifact paths
+    const artifactPaths = [];
+    for (const plat of platforms) {
+        const parentDirName = path.basename(monorepoDir);
+        const reportMeta = await displayReportSummary(`${parentDirName}/${plat}`);
+        if (reportMeta.artifactPath) {
+            artifactPaths.push(reportMeta.artifactPath);
+        }
+    }
+    // Validate each platform
+    p.log.step("Validating generated apps...");
+    let allValid = true;
+    for (const plat of platforms) {
+        const platDir = path.join(monorepoDir, plat);
+        const validation = await validateOutput(plat, platDir);
+        if (validation.valid) {
+            p.log.success(`[${plat}] Validation passed`);
+        }
+        else {
+            p.log.error(`[${plat}] Validation failed:`);
+            for (const err of validation.errors) {
+                p.log.error(`  - ${err}`);
+            }
+            allValid = false;
+        }
+        if (validation.warnings.length > 0) {
+            for (const warn of validation.warnings) {
+                p.log.warn(`  [${plat}] ${warn}`);
+            }
+        }
+    }
+    // Check if any platform failed
+    const anyFailed = platformResults.some((pr) => !pr.success);
+    if (anyFailed && !allValid) {
+        p.outro(`Dual-platform build had failures. Check output at: ${monorepoDir}`);
+        process.exit(1);
+    }
+    if (anyFailed) {
+        const failedPlatforms = platformResults.filter((pr) => !pr.success).map((pr) => pr.platform);
+        p.log.warn(`Some platforms failed: ${failedPlatforms.join(", ")}. Continuing with available results.`);
+    }
+    // Push to GitHub (monorepo) — pass first artifact (if any) for display
+    await handleGitHubPush(cliResult, cliFlags, ghAvailable, monorepoDir, artifactPaths[0]);
+}
+// ---------------------------------------------------------------------------
+// Shared helper functions
+// ---------------------------------------------------------------------------
+/**
+ * Display proof-of-work summary from an agent result.
+ */
+function displayProofOfWork(agentResult) {
+    const { proof } = agentResult;
+    p.log.step("Proof of work:");
+    p.log.info(`  Files written:  ${proof.filesWritten}`);
+    p.log.info(`  Files read:     ${proof.filesRead}`);
+    p.log.info(`  Shell commands: ${proof.shellCommands.length}`);
+    p.log.info(`  MCP tool calls: ${proof.mcpCalls.length}`);
+    if (proof.costUsd > 0) {
+        p.log.info(`  API cost:       $${proof.costUsd.toFixed(4)}`);
+    }
+    if (proof.mcpCalls.length > 0) {
+        const mcpBuckets = {};
+        for (const call of proof.mcpCalls) {
+            mcpBuckets[call] = (mcpBuckets[call] ?? 0) + 1;
+        }
+        p.log.info("  ── MCP Breakdown ──");
+        for (const [name, count] of Object.entries(mcpBuckets)) {
+            p.log.info(`    ${name}: ${count}×`);
+        }
+    }
+    if (proof.subagentCalls.length > 0) {
+        p.log.info(`  Subagent delegations: ${proof.subagentCalls.join(", ")}`);
+    }
+}
+/**
+ * Display Maestro test results from stream-based tracking.
+ */
+function displayMaestroResults(agentResult) {
+    const { proof } = agentResult;
+    if (proof.maestroTests.length > 0) {
+        const passed = proof.maestroTests.filter((t) => t.passed).length;
+        p.log.info(`  ── Maestro Tests (stream): ${passed}/${proof.maestroTests.length} passed ──`);
+        for (const t of proof.maestroTests) {
+            const shortFile = t.file.split("/").slice(-2).join("/");
+            const status = t.passed ? "✓ PASS" : "✗ FAIL";
+            const steps = t.totalSteps > 0 ? ` (${t.stepsCompleted}/${t.totalSteps} steps)` : "";
+            p.log.info(`    ${status} ${shortFile}${steps}`);
+            if (t.error) {
+                p.log.warn(`           ${t.error.slice(0, 100)}`);
+            }
+        }
+    }
+}
+/**
+ * Handle GitHub push flow (shared between single and dual-platform builds).
+ */
+async function handleGitHubPush(cliResult, cliFlags, ghAvailable, appDir, artifactPath) {
+    const artifactLine = artifactPath ? `\nBuild artifact: ${artifactPath}` : "";
+    // Prepare screenshots for GitHub if available
+    if (appDir) {
+        const screenshots = collectScreenshots(appDir);
+        if (screenshots.length > 0) {
+            p.log.info(`Found ${screenshots.length} screenshot(s) — adding to README.`);
+            ensureScreenshotsGitignoreException(appDir);
+            const appName = deriveRepoName(appDir);
+            generateReadmeScreenshots(appDir, appName, screenshots);
+        }
+    }
+    if (cliResult && cliFlags.push && appDir) {
+        if (!ghAvailable) {
+            p.log.error("Cannot push to GitHub: prerequisites not met. Run 'gh auth login' first.");
+            p.outro(`App was generated at: ${appDir}${artifactLine}`);
+            process.exit(1);
+        }
+        const repoName = cliFlags.repoName || deriveRepoName(appDir);
+        const ghResult = await pushToGitHub(appDir, repoName);
+        if (ghResult.success) {
+            p.outro(`Done! Your app is at: ${ghResult.repoUrl}${artifactLine}`);
+        }
+        else {
+            p.log.error(`GitHub push failed: ${ghResult.error}`);
+            p.outro(`App was generated at: ${appDir}${artifactLine}\nPush manually with: cd ${appDir} && gh repo create`);
+            process.exit(1);
+        }
+    }
+    else if (cliResult) {
+        p.outro(`Done! Your app is at: ${appDir ?? PATHS.output}${artifactLine}`);
+    }
+    else if (ghAvailable && appDir) {
+        const shouldPush = await p.confirm({ message: "Push to GitHub?" });
+        if (!p.isCancel(shouldPush) && shouldPush) {
+            const repoName = deriveRepoName(appDir);
+            const customName = await p.text({
+                message: "Repository name:",
+                initialValue: repoName,
+                placeholder: repoName,
+            });
+            if (p.isCancel(customName)) {
+                p.cancel("GitHub push skipped.");
+            }
+            else {
+                const ghResult = await pushToGitHub(appDir, customName || repoName);
+                if (ghResult.success) {
+                    p.outro(`Done! Your app is at: ${ghResult.repoUrl}${artifactLine}`);
+                }
+                else {
+                    p.log.error(`GitHub push failed: ${ghResult.error}`);
+                    p.outro(`App was generated at: ${appDir}${artifactLine}\nPush manually with: cd ${appDir} && gh repo create`);
+                }
+            }
+        }
+        else {
+            p.outro(`Done! Your app is at: ${appDir}${artifactLine}`);
+        }
+    }
+    else {
+        p.outro(`Done! Your app is at: ${appDir ?? PATHS.output}${artifactLine}`);
+    }
+}
+/**
+ * Run UI testing on a previously built app.
+ * Resolves app context, builds a test-only prompt, and launches the agent engine.
+ */
+async function testApp(appName, engineOverride, modelOverride) {
+    p.intro(`AppAgent — Test: ${appName}`);
+    // ── Resolve app context ─────────────────────────────────────────────
+    const ctx = await resolveAppContext(appName);
+    p.log.info(`App:      ${ctx.appName}`);
+    p.log.info(`Platform: ${ctx.platform}`);
+    p.log.info(`Bundle:   ${ctx.bundleId}`);
+    if (ctx.artifactPath) {
+        p.log.info(`Artifact: ${ctx.artifactPath}`);
+    }
+    else {
+        p.log.warn("Build artifact not found — agent will rebuild before testing.");
+    }
+    if (ctx.manifestContent) {
+        p.log.info("Manifest: found (parallel batch testing enabled)");
+    }
+    else {
+        p.log.warn("No customization manifest — agent will use single-simulator testing.");
+    }
+    // ── Determine engine and model ──────────────────────────────────────
+    const selectedEngine = engineOverride ?? DEFAULT_ENGINE;
+    const selectedModel = modelOverride ?? DEFAULT_MODEL;
+    const engine = createEngine(selectedEngine);
+    // ── Pre-flight check ────────────────────────────────────────────────
+    const agentCheck = await engine.checkInstallation();
+    if (!agentCheck.ok) {
+        p.log.error(agentCheck.error);
+        process.exit(1);
+    }
+    p.log.info(`Engine:   ${engine.name}`);
+    p.log.info(`Model:    ${selectedModel}`);
+    // ── Scaffold workspace (npx mode) ───────────────────────────────────
+    await scaffoldWorkspace();
+    // ── Build test-only prompt ──────────────────────────────────────────
+    const prompt = await buildTestPrompt(ctx);
+    p.log.info("Test prompt built successfully.");
+    // ── Run the agent engine ────────────────────────────────────────────
+    p.log.step(`Launching ${engine.name} agent for UI testing...`);
+    const agentResult = await engine.run(prompt, selectedModel);
+    if (!agentResult.success) {
+        p.log.error(`Agent failed: ${agentResult.error}`);
+        p.outro("UI testing did not complete successfully. Check the output directory for partial results.");
+        process.exit(1);
+    }
+    // ── Proof of work summary ──────────────────────────────────────────
+    const { proof } = agentResult;
+    p.log.step("Proof of work:");
+    p.log.info(`  Files written:  ${proof.filesWritten}`);
+    p.log.info(`  Files read:     ${proof.filesRead}`);
+    p.log.info(`  Shell commands: ${proof.shellCommands.length}`);
+    p.log.info(`  MCP tool calls: ${proof.mcpCalls.length}`);
+    if (proof.costUsd > 0) {
+        p.log.info(`  API cost:       $${proof.costUsd.toFixed(4)}`);
+    }
+    if (proof.mcpCalls.length > 0) {
+        const mcpBuckets = {};
+        for (const call of proof.mcpCalls) {
+            mcpBuckets[call] = (mcpBuckets[call] ?? 0) + 1;
+        }
+        p.log.info("  ── MCP Breakdown ──");
+        for (const [name, count] of Object.entries(mcpBuckets)) {
+            p.log.info(`    ${name}: ${count}×`);
+        }
+    }
+    if (proof.subagentCalls.length > 0) {
+        p.log.info(`  Subagent delegations: ${proof.subagentCalls.join(", ")}`);
+    }
+    // ── Report-based summary ───────────────────────────────────────────
+    await displayReportSummary(appName);
+    // Stream-based Maestro test results
+    if (proof.maestroTests.length > 0) {
+        const passed = proof.maestroTests.filter((t) => t.passed).length;
+        p.log.info(`  ── Maestro Tests (stream): ${passed}/${proof.maestroTests.length} passed ──`);
+        for (const t of proof.maestroTests) {
+            const shortFile = t.file.split("/").slice(-2).join("/");
+            const status = t.passed ? "✓ PASS" : "✗ FAIL";
+            const steps = t.totalSteps > 0 ? ` (${t.stepsCompleted}/${t.totalSteps} steps)` : "";
+            p.log.info(`    ${status} ${shortFile}${steps}`);
+            if (t.error) {
+                p.log.warn(`           ${t.error.slice(0, 100)}`);
+            }
+        }
+    }
+    p.outro(`UI testing complete for: ${ctx.dirPath}`);
+}
+/**
+ * Update an existing app: resolve source, run agent, commit, and optionally create a PR.
+ */
+async function updateApp(input, engine, ghAvailable) {
+    p.intro("AppAgent — Update existing app");
+    // ── Resolve update context ───────────────────────────────────────────
+    p.log.step("Resolving update source...");
+    const updateCtx = await resolveUpdateContext(input.updateTarget, input.description);
+    // ── Scaffold workspace (npx mode) ────────────────────────────────────
+    await scaffoldWorkspace();
+    // ── Build update prompt ──────────────────────────────────────────────
+    const prompt = await buildUpdatePrompt(updateCtx);
+    p.log.info("Update prompt built successfully.");
+    // ── Run the agent engine ─────────────────────────────────────────────
+    p.log.step(`Launching ${engine.name} agent for update...`);
+    // Update mode doesn't produce reports/ — skip the continuation loop
+    const agentResult = await engine.run(prompt, input.model, { skipContinuation: true });
+    if (!agentResult.success) {
+        p.log.error(`Agent failed: ${agentResult.error}`);
+        p.outro("The agent did not complete successfully. Check the app directory for partial changes.");
+        process.exit(1);
+    }
+    // ── Proof of work summary ────────────────────────────────────────────
+    const { proof } = agentResult;
+    p.log.step("Proof of work:");
+    p.log.info(`  Files written:  ${proof.filesWritten}`);
+    p.log.info(`  Files read:     ${proof.filesRead}`);
+    p.log.info(`  Shell commands: ${proof.shellCommands.length}`);
+    p.log.info(`  MCP tool calls: ${proof.mcpCalls.length}`);
+    if (proof.costUsd > 0) {
+        p.log.info(`  API cost:       $${proof.costUsd.toFixed(4)}`);
+    }
+    // ── Collect screenshots & prepare gitignore ──────────────────────────
+    const screenshots = collectScreenshots(updateCtx.appDir);
+    if (screenshots.length > 0) {
+        p.log.info(`Found ${screenshots.length} screenshot(s) for GitHub.`);
+        ensureScreenshotsGitignoreException(updateCtx.appDir);
+    }
+    // ── Commit changes ───────────────────────────────────────────────────
+    const isRepo = await isGitRepo(updateCtx.appDir);
+    if (isRepo) {
+        const commitMsg = `AppAgent: ${updateCtx.changeDescription}`;
+        p.log.step("Committing changes...");
+        const commitResult = await commitChanges(updateCtx.appDir, commitMsg);
+        if (commitResult.success) {
+            p.log.info("Changes committed.");
+        }
+        else {
+            p.log.warn(`Could not commit: ${commitResult.error}`);
+        }
+        // ── Push and create PR (for GitHub sources or if remote exists) ────
+        const hasRemote = await hasRemoteOrigin(updateCtx.appDir);
+        if (hasRemote && ghAvailable && commitResult.success) {
+            // Auto-create PR for GitHub-cloned repos
+            if (updateCtx.sourceType === "github") {
+                p.log.step("Pushing branch and creating pull request...");
+                const pushResult = await pushBranch(updateCtx.appDir);
+                if (pushResult.success) {
+                    p.log.info(`Branch pushed: ${updateCtx.branchName}`);
+                    const prTitle = `AppAgent: ${updateCtx.changeDescription}`;
+                    const basePrBody = [
+                        "## Summary",
+                        "",
+                        `This PR was generated by AppAgent in Update mode.`,
+                        "",
+                        `**Change request:** ${updateCtx.changeDescription}`,
+                        "",
+                        `**Branch:** \`${updateCtx.branchName}\``,
+                        `**Platform:** ${updateCtx.platform === "ios" ? "iOS" : "Android"}`,
+                        updateCtx.isAppAgentApp ? `**Template:** ${updateCtx.template ?? "unknown"}` : "",
+                    ].filter(Boolean).join("\n");
+                    const prBody = screenshots.length > 0 && updateCtx.repoUrl
+                        ? buildPrBodyWithScreenshots(basePrBody, updateCtx.repoUrl, updateCtx.branchName, screenshots)
+                        : basePrBody;
+                    const prResult = await createPullRequest(updateCtx.appDir, prTitle, prBody);
+                    if (prResult.success) {
+                        p.outro(`Done! Pull request created: ${prResult.prUrl}`);
+                    }
+                    else {
+                        p.log.warn(`PR creation failed: ${prResult.error}`);
+                        p.outro(`Changes committed on branch: ${updateCtx.branchName}\n` +
+                            `Create a PR manually: cd ${updateCtx.appDir} && gh pr create`);
+                    }
+                }
+                else {
+                    p.log.warn(`Push failed: ${pushResult.error}`);
+                    p.outro(`Changes committed locally on branch: ${updateCtx.branchName}\n` +
+                        `Push manually: cd ${updateCtx.appDir} && git push -u origin HEAD`);
+                }
+            }
+            else {
+                // Local source with a remote — offer to push and create PR
+                const shouldPush = await p.confirm({
+                    message: "Push changes and create a pull request?",
+                });
+                if (!p.isCancel(shouldPush) && shouldPush) {
+                    const pushResult = await pushBranch(updateCtx.appDir);
+                    if (pushResult.success) {
+                        const prTitle = `AppAgent: ${updateCtx.changeDescription}`;
+                        const basePrBody = [
+                            "## Summary",
+                            "",
+                            `This PR was generated by AppAgent in Update mode.`,
+                            "",
+                            `**Change request:** ${updateCtx.changeDescription}`,
+                        ].join("\n");
+                        // For local repos with a remote, try to get the repo URL for screenshot embedding
+                        let repoUrl;
+                        try {
+                            const { stdout } = await import("execa").then((m) => m.execa("git", ["remote", "get-url", "origin"], { cwd: updateCtx.appDir }));
+                            repoUrl = stdout.trim();
+                        }
+                        catch {
+                            // No remote URL — skip screenshot embedding
+                        }
+                        const prBody = screenshots.length > 0 && repoUrl
+                            ? buildPrBodyWithScreenshots(basePrBody, repoUrl, updateCtx.branchName, screenshots)
+                            : basePrBody;
+                        const prResult = await createPullRequest(updateCtx.appDir, prTitle, prBody);
+                        if (prResult.success) {
+                            p.outro(`Done! Pull request created: ${prResult.prUrl}`);
+                        }
+                        else {
+                            p.log.warn(`PR creation failed: ${prResult.error}`);
+                            p.outro(`Changes pushed to branch: ${updateCtx.branchName}`);
+                        }
+                    }
+                    else {
+                        p.log.warn(`Push failed: ${pushResult.error}`);
+                        p.outro(`Changes committed locally on branch: ${updateCtx.branchName}`);
+                    }
+                }
+                else {
+                    p.outro(`Done! Changes committed on branch: ${updateCtx.branchName}\n` +
+                        `App directory: ${updateCtx.appDir}`);
+                }
+            }
+        }
+        else {
+            p.outro(`Done! Changes committed on branch: ${updateCtx.branchName}\n` +
+                `App directory: ${updateCtx.appDir}`);
+        }
+    }
+    else {
+        p.outro(`Done! Changes applied to: ${updateCtx.appDir}`);
+    }
+}
+async function displayReportSummary(targetApp) {
+    const result = {};
+    try {
+        let appDirs;
+        if (targetApp) {
+            appDirs = [targetApp];
+        }
+        else {
+            const outputEntries = await fs.readdir(PATHS.output).catch(() => []);
+            appDirs = outputEntries.filter((e) => !e.startsWith(".") && !e.startsWith("_"));
+        }
+        for (const appDir of appDirs) {
+            const summaryPath = `${PATHS.output}/${appDir}/reports/summary.json`;
+            if (!(await fs.pathExists(summaryPath)))
+                continue;
+            const raw = await fs.readFile(summaryPath, "utf-8");
+            const summary = JSON.parse(raw);
+            // Extract artifact path from build step (field names vary across agent runs)
+            const buildStep = summary.steps?.find((s) => s.name === "build");
+            const artifactPath = buildStep?.artifactPath ??
+                buildStep?.["buildArtifact"] ??
+                summary["buildArtifactPath"] ??
+                summary["buildArtifact"];
+            if (artifactPath && (await fs.pathExists(artifactPath))) {
+                result.artifactPath = artifactPath;
+            }
+            result.platform = summary.platform;
+            result.bundleId = summary.bundleId;
+            p.log.step("── Agent Report Summary (from summary.json) ──");
+            if (summary.appName) {
+                p.log.info(`  App:      ${summary.appName}`);
+            }
+            if (summary.template) {
+                p.log.info(`  Template: ${summary.template}`);
+            }
+            if (summary.designBrand) {
+                p.log.info(`  Brand:    ${summary.designBrand}`);
+            }
+            if (summary.overallResult) {
+                const icon = summary.overallResult === "PASS" ? "✓" : "✗";
+                p.log.info(`  Result:   ${icon} ${summary.overallResult}`);
+            }
+            if (summary.duration) {
+                p.log.info(`  Duration: ${summary.duration}`);
+            }
+            if (summary.totalCostUsd != null && summary.totalCostUsd > 0) {
+                p.log.info(`  Cost:     $${summary.totalCostUsd.toFixed(4)}`);
+            }
+            // Display per-step results
+            if (summary.steps && summary.steps.length > 0) {
+                p.log.info("  ── Steps ──");
+                for (const step of summary.steps) {
+                    const icon = step.result === "PASS" || step.result === "SUCCESS" ? "✓" : step.result === "SKIPPED" ? "–" : "✗";
+                    const extras = [];
+                    // Add step-specific details
+                    if ("template" in step && step.template)
+                        extras.push(`template: ${step.template}`);
+                    if ("brand" in step && step.brand)
+                        extras.push(`brand: ${step.brand}`);
+                    if ("artifactPath" in step && step.artifactPath)
+                        extras.push("artifact found");
+                    if ("maestroTests" in step) {
+                        const mt = step.maestroTests;
+                        if (mt?.total)
+                            extras.push(`maestro: ${mt.passed ?? 0}/${mt.total}`);
+                    }
+                    if ("criticalFindings" in step && step.criticalFindings > 0) {
+                        extras.push(`critical: ${step.criticalFindings}`);
+                    }
+                    // Format step duration
+                    if (step.durationSeconds != null) {
+                        const mins = Math.floor(step.durationSeconds / 60);
+                        const secs = step.durationSeconds % 60;
+                        const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+                        extras.push(timeStr);
+                    }
+                    const detail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+                    p.log.info(`    ${icon} Step ${step.step}: ${step.name} — ${step.result}${detail}`);
+                }
+            }
+            // Display build artifact prominently
+            if (result.artifactPath) {
+                const ext = path.extname(result.artifactPath);
+                const artifactType = ext === ".app" ? "iOS App (.app)" :
+                    ext === ".ipa" ? "iOS Archive (.ipa)" :
+                        ext === ".apk" ? "Android APK (.apk)" :
+                            ext === ".aab" ? "Android Bundle (.aab)" :
+                                `Build Artifact (${ext})`;
+                p.log.info("  ── Build Artifact ──");
+                p.log.success(`  ${artifactType}: ${result.artifactPath}`);
+            }
+            // List report files
+            const reportsDir = `${PATHS.output}/${appDir}/reports`;
+            if (await fs.pathExists(reportsDir)) {
+                const reportFiles = (await fs.readdir(reportsDir)).filter((f) => f.endsWith(".md"));
+                if (reportFiles.length > 0) {
+                    p.log.info(`  ── Report Files (${reportFiles.length}) ──`);
+                    for (const f of reportFiles) {
+                        p.log.info(`    ${reportsDir}/${f}`);
+                    }
+                }
+            }
+            // Only process the first app dir
+            break;
+        }
+    }
+    catch {
+        // summary.json not found or malformed — fall back to stream-based tracking
+    }
+    return result;
+}
+/**
+ * Derive a kebab-case app name from the user's description.
+ * Extracts key words and produces something like "pet-grooming-ios".
+ */
+function deriveAppName(description) {
+    // Try to extract an explicit app name (e.g., "called PawSpa", "named FooBar")
+    const namedMatch = description.match(/(?:called|named)\s+["']?(\w+)["']?/i);
+    let baseName;
+    if (namedMatch) {
+        baseName = namedMatch[1];
+    }
+    else {
+        // Take the first few meaningful words from the description
+        const stopWords = new Set(["a", "an", "the", "and", "or", "for", "with", "to", "of", "in", "on", "app", "application"]);
+        const words = description
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, "")
+            .split(/\s+/)
+            .filter((w) => w.length > 1 && !stopWords.has(w))
+            .slice(0, 3);
+        baseName = words.join("-") || "my-app";
+    }
+    // Convert to kebab-case
+    const kebab = baseName
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return kebab || "my-app";
+}
+/**
+ * Derive a PascalCase display name from a kebab-case app name.
+ * e.g., "pet-grooming" -> "PetGrooming", "pawspa" -> "Pawspa"
+ */
+function deriveDisplayName(appName) {
+    return appName
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+}
+/**
+ * Derive a reverse-domain bundle ID from a kebab-case app name.
+ * e.g., "pet-grooming" -> "com.appship.petgrooming"
+ */
+function deriveBundleId(appName) {
+    const cleaned = appName.replace(/-/g, "").toLowerCase();
+    return `com.appship.${cleaned}`;
+}
+main()
+    .catch((err) => {
+    p.log.error(`Unexpected error: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+})
+    .finally(() => {
+    // Clean up scaffolded workspace symlinks and files (npx mode)
+    cleanupWorkspace().catch(() => { });
+});
+//# sourceMappingURL=index.js.map