@launch11/srgical 0.0.1

package/dist/core/claude.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectClaude = detectClaude;
+exports.requestPlannerReply = requestPlannerReply;
+exports.writePlanningPack = writePlanningPack;
+exports.runNextPrompt = runNextPrompt;
+exports.setClaudeRuntimeForTesting = setClaudeRuntimeForTesting;
+exports.resetClaudeRuntimeForTesting = resetClaudeRuntimeForTesting;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const local_pack_1 = require("./local-pack");
+const planning_epochs_1 = require("./planning-epochs");
+const prompts_1 = require("./prompts");
+const FOLLOW_APPENDED_PROMPT_QUERY = "Follow the appended system prompt exactly, do the work in the current working directory, and return only the final response.";
+const CLAUDE_WRITE_ALLOW_TOOLS = ["Bash", "Read", "Edit", "Write"];
+const CLAUDE_INSTALL_HINT = "install Claude Code CLI to enable";
+let claudeCommandPromise;
+let forcedClaudeCommand = null;
+let spawnAndCaptureImpl = spawnAndCaptureBase;
+async function detectClaude() {
+    try {
+        const command = await resolveClaudeCommand();
+        const version = await spawnAndCaptureImpl(command, ["--version"], process.cwd());
+        return {
+            available: true,
+            command,
+            version: version.stdout.trim()
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            command: process.platform === "win32" ? "claude.exe" : "claude",
+            error: normalizeClaudeDetectionError(error)
+        };
+    }
+}
+async function requestPlannerReply(workspaceRoot, messages) {
+    const result = await runClaudeExec({
+        cwd: workspaceRoot,
+        prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
+        permissionMode: "plan",
+        maxTurns: 4
+    });
+    return result.lastMessage.trim();
+}
+async function writePlanningPack(workspaceRoot, messages) {
+    const planningEpoch = await (0, planning_epochs_1.preparePlanningPackForWrite)(workspaceRoot);
+    const claudeStatus = await detectClaude();
+    if (!claudeStatus.available) {
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, claudeStatus.error ?? "Claude Code CLI is unavailable", "Claude Code"));
+    }
+    try {
+        const result = await runClaudeExec({
+            cwd: workspaceRoot,
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            permissionMode: "acceptEdits",
+            allowedTools: CLAUDE_WRITE_ALLOW_TOOLS,
+            maxTurns: 24
+        });
+        return appendPlanningEpochSummary(planningEpoch, result.lastMessage.trim());
+    }
+    catch (error) {
+        if (isClaudeUnavailableError(error)) {
+            const message = error instanceof Error ? error.message : "Claude Code CLI is unavailable";
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Claude Code"));
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(planningEpoch);
+        if (epochSummary) {
+            throw new Error(`${epochSummary}\n${message}`);
+        }
+        throw error;
+    }
+}
+async function runNextPrompt(workspaceRoot, prompt) {
+    const result = await runClaudeExec({
+        cwd: workspaceRoot,
+        prompt,
+        permissionMode: "acceptEdits",
+        allowedTools: CLAUDE_WRITE_ALLOW_TOOLS,
+        maxTurns: 24
+    });
+    return result.lastMessage.trim();
+}
+function setClaudeRuntimeForTesting(options) {
+    if (Object.prototype.hasOwnProperty.call(options, "command")) {
+        forcedClaudeCommand = options.command ?? null;
+        claudeCommandPromise = undefined;
+    }
+    if (options.spawnAndCapture) {
+        spawnAndCaptureImpl = options.spawnAndCapture;
+    }
+}
+function resetClaudeRuntimeForTesting() {
+    forcedClaudeCommand = null;
+    claudeCommandPromise = undefined;
+    spawnAndCaptureImpl = spawnAndCaptureBase;
+}
+async function runClaudeExec(options) {
+    const tempDir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "srgical-claude-"));
+    const promptFile = node_path_1.default.join(tempDir, "prompt.txt");
+    const command = await resolveClaudeCommand();
+    const args = ["-p", "--output-format", "text", "--permission-mode", options.permissionMode];
+    await (0, promises_1.writeFile)(promptFile, options.prompt, "utf8");
+    args.push("--append-system-prompt-file", promptFile);
+    if (options.allowedTools && options.allowedTools.length > 0) {
+        const settingsFile = node_path_1.default.join(tempDir, "settings.json");
+        await (0, promises_1.writeFile)(settingsFile, JSON.stringify({
+            permissions: {
+                allow: options.allowedTools
+            }
+        }, null, 2), "utf8");
+        args.push("--settings", settingsFile);
+    }
+    if (options.maxTurns) {
+        args.push("--max-turns", String(options.maxTurns));
+    }
+    args.push("--no-session-persistence", FOLLOW_APPENDED_PROMPT_QUERY);
+    try {
+        const result = await spawnAndCaptureImpl(command, args, options.cwd);
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            lastMessage: result.stdout.trim()
+        };
+    }
+    finally {
+        await (0, promises_1.rm)(tempDir, { recursive: true, force: true });
+    }
+}
+async function resolveClaudeCommand() {
+    if (forcedClaudeCommand) {
+        return forcedClaudeCommand;
+    }
+    if (!claudeCommandPromise) {
+        claudeCommandPromise = loadClaudeCommand();
+    }
+    return claudeCommandPromise;
+}
+async function loadClaudeCommand() {
+    if (process.platform !== "win32") {
+        return "claude";
+    }
+    const result = await spawnAndCaptureImpl("where.exe", ["claude"], process.cwd());
+    const matches = result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const shim = matches.find((line) => {
+        const lower = line.toLowerCase();
+        return lower.endsWith(".cmd") || lower.endsWith(".bat");
+    });
+    if (shim) {
+        return shim;
+    }
+    const executable = matches.find((line) => line.toLowerCase().endsWith(".exe"));
+    if (executable) {
+        return executable;
+    }
+    for (const candidate of matches) {
+        const siblingShim = await resolveSiblingShim(candidate);
+        if (siblingShim) {
+            return siblingShim;
+        }
+    }
+    if (matches.length > 0) {
+        return matches[0];
+    }
+    throw new Error("Unable to resolve a Claude executable path.");
+}
+function spawnAndCaptureBase(command, args, cwd, stdinText) {
+    return new Promise((resolve, reject) => {
+        const spec = buildSpawnSpec(command, args, cwd);
+        const child = (0, node_child_process_1.spawn)(spec.command, spec.args, spec.options);
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+                return;
+            }
+            reject(new Error(stderr.trim() || stdout.trim() || `${command} exited with code ${code}`));
+        });
+        if (stdinText) {
+            child.stdin.write(stdinText);
+        }
+        child.stdin.end();
+    });
+}
+function buildSpawnSpec(command, args, cwd) {
+    const lower = command.toLowerCase();
+    if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+        const commandLine = [quoteForShell(command), ...args.map(quoteForShell)].join(" ");
+        return {
+            command: commandLine,
+            args: [],
+            options: {
+                cwd,
+                env: process.env,
+                shell: true
+            }
+        };
+    }
+    return {
+        command,
+        args,
+        options: {
+            cwd,
+            env: process.env
+        }
+    };
+}
+async function resolveSiblingShim(candidate) {
+    const extension = node_path_1.default.extname(candidate);
+    if (extension) {
+        return null;
+    }
+    for (const suffix of [".cmd", ".bat", ".exe"]) {
+        const sibling = `${candidate}${suffix}`;
+        try {
+            await (0, promises_1.access)(sibling);
+            return sibling;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function quoteForShell(value) {
+    if (/^[A-Za-z0-9_:\\/.=-]+$/.test(value)) {
+        return value;
+    }
+    const escaped = value.replace(/"/g, '""');
+    return `"${escaped}"`;
+}
+function normalizeClaudeDetectionError(error) {
+    const message = error instanceof Error ? error.message : "Failed to run claude";
+    const normalized = message.toLowerCase();
+    if (normalized.includes("could not find files for the given pattern") ||
+        normalized.includes("unable to resolve a claude executable path") ||
+        normalized.includes("'claude' is not recognized") ||
+        normalized.includes("enoent")) {
+        return CLAUDE_INSTALL_HINT;
+    }
+    return message;
+}
+function isClaudeUnavailableError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return (message.includes("unable to resolve a claude executable path") ||
+        message.includes("'claude' is not recognized") ||
+        message.includes("enoent") ||
+        message.includes("failed to run claude"));
+}
+function appendPlanningEpochSummary(preparation, summary) {
+    const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(preparation);
+    return [epochSummary, summary].filter(Boolean).join("\n");
+}

package/dist/core/codex.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCodex = detectCodex;
+exports.requestPlannerReply = requestPlannerReply;
+exports.writePlanningPack = writePlanningPack;
+exports.runNextPrompt = runNextPrompt;
+exports.setCodexRuntimeForTesting = setCodexRuntimeForTesting;
+exports.resetCodexRuntimeForTesting = resetCodexRuntimeForTesting;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const local_pack_1 = require("./local-pack");
+const planning_epochs_1 = require("./planning-epochs");
+const prompts_1 = require("./prompts");
+let codexCommandPromise;
+let forcedCodexCommand = null;
+let spawnAndCaptureImpl = spawnAndCaptureBase;
+async function detectCodex() {
+    try {
+        const command = await resolveCodexCommand();
+        const version = await spawnAndCaptureImpl(command, ["--version"], process.cwd());
+        return {
+            available: true,
+            command,
+            version: version.stdout.trim()
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            command: process.platform === "win32" ? "codex.exe" : "codex",
+            error: error instanceof Error ? error.message : "Failed to run codex"
+        };
+    }
+}
+async function requestPlannerReply(workspaceRoot, messages) {
+    const result = await runCodexExec({
+        cwd: workspaceRoot,
+        prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
+        allowWrite: false,
+        skipGitRepoCheck: true,
+        ephemeral: true
+    });
+    return result.lastMessage.trim();
+}
+async function writePlanningPack(workspaceRoot, messages) {
+    const planningEpoch = await (0, planning_epochs_1.preparePlanningPackForWrite)(workspaceRoot);
+    const codexStatus = await detectCodex();
+    if (!codexStatus.available) {
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, codexStatus.error ?? "Codex is unavailable", "Codex"));
+    }
+    try {
+        const result = await runCodexExec({
+            cwd: workspaceRoot,
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            allowWrite: true,
+            skipGitRepoCheck: true,
+            ephemeral: false
+        });
+        return appendPlanningEpochSummary(planningEpoch, result.lastMessage.trim());
+    }
+    catch (error) {
+        if (isCodexUnavailableError(error)) {
+            const message = error instanceof Error ? error.message : "Codex is unavailable";
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Codex"));
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(planningEpoch);
+        if (epochSummary) {
+            throw new Error(`${epochSummary}\n${message}`);
+        }
+        throw error;
+    }
+}
+async function runNextPrompt(workspaceRoot, prompt) {
+    const result = await runCodexExec({
+        cwd: workspaceRoot,
+        prompt,
+        allowWrite: true,
+        skipGitRepoCheck: true,
+        ephemeral: false
+    });
+    return result.lastMessage.trim();
+}
+function setCodexRuntimeForTesting(options) {
+    if (Object.prototype.hasOwnProperty.call(options, "command")) {
+        forcedCodexCommand = options.command ?? null;
+        codexCommandPromise = undefined;
+    }
+    if (options.spawnAndCapture) {
+        spawnAndCaptureImpl = options.spawnAndCapture;
+    }
+}
+function resetCodexRuntimeForTesting() {
+    forcedCodexCommand = null;
+    codexCommandPromise = undefined;
+    spawnAndCaptureImpl = spawnAndCaptureBase;
+}
+async function runCodexExec(options) {
+    const tempDir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "srgical-codex-"));
+    const outputFile = node_path_1.default.join(tempDir, "last-message.txt");
+    const args = ["exec", "--color", "never", "-o", outputFile];
+    const command = await resolveCodexCommand();
+    if (options.allowWrite) {
+        args.push("--full-auto");
+    }
+    else {
+        args.push("-s", "read-only");
+    }
+    if (options.skipGitRepoCheck) {
+        args.push("--skip-git-repo-check");
+    }
+    if (options.ephemeral) {
+        args.push("--ephemeral");
+    }
+    args.push("-");
+    try {
+        const result = await spawnAndCaptureImpl(command, args, options.cwd, options.prompt);
+        const lastMessage = await (0, promises_1.readFile)(outputFile, "utf8");
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            lastMessage
+        };
+    }
+    finally {
+        await (0, promises_1.rm)(tempDir, { recursive: true, force: true });
+    }
+}
+async function resolveCodexCommand() {
+    if (forcedCodexCommand) {
+        return forcedCodexCommand;
+    }
+    if (!codexCommandPromise) {
+        codexCommandPromise = loadCodexCommand();
+    }
+    return codexCommandPromise;
+}
+async function loadCodexCommand() {
+    if (process.platform !== "win32") {
+        return "codex";
+    }
+    const result = await spawnAndCaptureImpl("where.exe", ["codex"], process.cwd());
+    const matches = result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const shim = matches.find((line) => {
+        const lower = line.toLowerCase();
+        return lower.endsWith(".cmd") || lower.endsWith(".bat");
+    });
+    if (shim) {
+        return shim;
+    }
+    const executable = matches.find((line) => line.toLowerCase().endsWith(".exe"));
+    if (executable) {
+        return executable;
+    }
+    for (const candidate of matches) {
+        const siblingShim = await resolveSiblingShim(candidate);
+        if (siblingShim) {
+            return siblingShim;
+        }
+    }
+    if (matches.length > 0) {
+        return matches[0];
+    }
+    throw new Error("Unable to resolve a Codex executable path.");
+}
+function spawnAndCaptureBase(command, args, cwd, stdinText) {
+    return new Promise((resolve, reject) => {
+        const spec = buildSpawnSpec(command, args, cwd);
+        const child = (0, node_child_process_1.spawn)(spec.command, spec.args, spec.options);
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+                return;
+            }
+            reject(new Error(stderr.trim() || stdout.trim() || `${command} exited with code ${code}`));
+        });
+        if (stdinText) {
+            child.stdin.write(stdinText);
+        }
+        child.stdin.end();
+    });
+}
+function buildSpawnSpec(command, args, cwd) {
+    const lower = command.toLowerCase();
+    if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+        const commandLine = [quoteForShell(command), ...args.map(quoteForShell)].join(" ");
+        return {
+            command: commandLine,
+            args: [],
+            options: {
+                cwd,
+                env: process.env,
+                shell: true
+            }
+        };
+    }
+    return {
+        command,
+        args,
+        options: {
+            cwd,
+            env: process.env
+        }
+    };
+}
+async function resolveSiblingShim(candidate) {
+    const extension = node_path_1.default.extname(candidate);
+    if (extension) {
+        return null;
+    }
+    for (const suffix of [".cmd", ".bat", ".exe"]) {
+        const sibling = `${candidate}${suffix}`;
+        try {
+            await (0, promises_1.access)(sibling);
+            return sibling;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function quoteForShell(value) {
+    if (/^[A-Za-z0-9_:\\/.=-]+$/.test(value)) {
+        return value;
+    }
+    const escaped = value.replace(/"/g, '""');
+    return `"${escaped}"`;
+}
+function isCodexUnavailableError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return (message.includes("unable to resolve a codex executable path") ||
+        message.includes("'codex' is not recognized") ||
+        message.includes("enoent") ||
+        message.includes("failed to run codex"));
+}
+function appendPlanningEpochSummary(preparation, summary) {
+    const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(preparation);
+    return [epochSummary, summary].filter(Boolean).join("\n");
+}

package/dist/core/execution-controls.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderExecutionStepLines = renderExecutionStepLines;
+exports.hasQueuedNextStep = hasQueuedNextStep;
+exports.formatNoQueuedNextStepMessage = formatNoQueuedNextStepMessage;
+exports.formatStepLabel = formatStepLabel;
+exports.renderDryRunPreview = renderDryRunPreview;
+exports.formatExecutionFailureMessage = formatExecutionFailureMessage;
+const agent_1 = require("./agent");
+const PROMPT_PREVIEW_LINE_LIMIT = 18;
+const PROMPT_PREVIEW_CHAR_LIMIT = 1200;
+function renderExecutionStepLines(nextStepSummary, nextRecommended) {
+    if (!nextStepSummary) {
+        return [
+            "Next step summary: unavailable.",
+            nextRecommended
+                ? `Tracker points to \`${nextRecommended}\`, but its table row could not be summarized.`
+                : "Tracker does not currently expose a next recommended step."
+        ];
+    }
+    const lines = [
+        `Next step: ${nextStepSummary.id}${nextStepSummary.phase ? ` (${nextStepSummary.phase})` : ""}`,
+        `Scope: ${nextStepSummary.scope || "unknown"}`,
+        `Acceptance: ${nextStepSummary.acceptance || "unknown"}`
+    ];
+    if (nextStepSummary.notes) {
+        lines.push(`Notes: ${nextStepSummary.notes}`);
+    }
+    return lines;
+}
+function hasQueuedNextStep(nextRecommended) {
+    return Boolean(nextRecommended);
+}
+function formatNoQueuedNextStepMessage(source) {
+    return [
+        "No next recommended step is currently queued in `.srgical/03-detailed-implementation-plan.md`.",
+        source === "run-next"
+            ? "Run `srgical studio` to queue more work or update the tracker before executing again."
+            : "Use the planning studio to queue more work or update the tracker before running execution again."
+    ].join("\n");
+}
+function formatStepLabel(nextStepSummary, nextRecommended) {
+    if (nextStepSummary) {
+        return `\`${nextStepSummary.id}\`${nextStepSummary.phase ? ` (${nextStepSummary.phase})` : ""}`;
+    }
+    if (nextRecommended) {
+        return `\`${nextRecommended}\``;
+    }
+    return null;
+}
+function renderDryRunPreview(prompt, nextStepSummary, nextRecommended) {
+    const lines = [
+        "Execution dry run:",
+        ...renderExecutionStepLines(nextStepSummary, nextRecommended),
+        "",
+        ...buildPromptPreviewLines(prompt),
+        "",
+        `Dry run only: ${(0, agent_1.getPrimaryAgentAdapter)().label} was not invoked and no execution state or run log was updated.`
+    ];
+    return lines;
+}
+function formatExecutionFailureMessage(errorMessage, nextStepSummary, nextRecommended, source) {
+    const lines = [
+        `Execution failed${formatStepLabel(nextStepSummary, nextRecommended) ? ` for ${formatStepLabel(nextStepSummary, nextRecommended)}` : ""}.`,
+        `Reason: ${errorMessage}`,
+        "",
+        "Recovery:",
+        "- Review `.srgical/04-next-agent-prompt.md` and `.srgical/03-detailed-implementation-plan.md`.",
+        "- Inspect `.srgical/execution-state.json` for the latest recorded failure summary."
+    ];
+    if (source === "run-next") {
+        lines.push("- Inspect `.srgical/execution-log.md` for the durable run history.");
+    }
+    lines.push("- Preview safely with `srgical run-next --dry-run` or `/preview` in the studio.");
+    return lines.join("\n");
+}
+function buildPromptPreviewLines(prompt) {
+    const promptLines = prompt.split(/\r?\n/);
+    const preview = promptLines.slice(0, PROMPT_PREVIEW_LINE_LIMIT).join("\n");
+    const trimmedPreview = preview.length <= PROMPT_PREVIEW_CHAR_LIMIT ? preview : `${preview.slice(0, PROMPT_PREVIEW_CHAR_LIMIT).trimEnd()}...`;
+    return [
+        `Prompt preview: first ${Math.min(PROMPT_PREVIEW_LINE_LIMIT, promptLines.length)} of ${promptLines.length} lines.`,
+        "",
+        trimmedPreview,
+        ...(promptLines.length > PROMPT_PREVIEW_LINE_LIMIT ? ["", "... [preview truncated]"] : [])
+    ];
+}