@launch11/srgical 0.0.2 → 0.0.4

package/README.md

@@ -7,9 +7,9 @@
 3. repeatedly execute the next eligible step,
 4. force validation and handoff updates every time.
 
-The current launch slice supports both local `codex` and local `claude` CLI installs through the same `.srgical/`
-workflow. `srgical` detects which supported tools are actually installed, keeps the planning pack agent-neutral, and
-lets you choose the active agent for the current workspace session.
+The current launch slice supports local `codex`, local `claude`, and local `auggie` installs through the same
+`.srgical/` workflow. `srgical` detects which supported tools are actually installed, keeps the planning pack
+agent-neutral, and lets you choose the active agent for the current workspace session.
 
 ## Why This Exists
 
@@ -46,8 +46,11 @@ This repo currently ships the foundation for:
 - `claude`
   Supported through the same adapter seam for planning, pack writing, and execution when the local Claude Code CLI is
   installed and available on `PATH`.
+- `augment`
+  Supported through the same adapter seam by targeting the local `auggie` binary for planning, pack writing, and
+  execution when Augment CLI automation is available on the current machine.
 
-If only one supported agent is installed, `srgical` can auto-select it for the workspace session. If both are
+If only one supported agent is installed, `srgical` can auto-select it for the workspace session. If more than one is
 installed, you can keep the stored choice in the studio and still override a single execution with
 `srgical run-next --agent <id>`.
 
@@ -145,6 +148,7 @@ To override the active workspace agent for one execution only:
 ```bash
 node dist/index.js run-next --agent codex
 node dist/index.js run-next --agent claude
+node dist/index.js run-next --agent augment
 ```
 
 ## Current Claude Caveat
@@ -155,8 +159,22 @@ uses `plan` mode for planner replies and `acceptEdits` with allowlisted local to
 If the Claude CLI is not installed locally, `doctor`, the studio, and `run-next --agent claude` all report that
 honestly instead of falling back to a fake Claude path.
 
+## Current Augment Caveat
+
+Augment support is wired to the documented `auggie` automation flags: `--print`, `--quiet`, `--instruction-file`,
+`--workspace-root`, `--rules`, `--allow-indexing`, `--wait-for-indexing`, `--max-turns`, and `--ask` for planner-only
+runs.
+
+The defaults deliberately force workspace indexing and append srgical-specific Augment rules so the agent stays biased
+toward incremental planning, validated execution, and clear next-step handoffs. Session history is also left on so
+workspace iterations can accumulate inside Auggie instead of being treated as throwaway runs.
+
+That means successful Augment execution still depends on a real Augment CLI install, an authenticated session such as
+`auggie login` or `AUGMENT_SESSION_AUTH`, and whatever automation entitlements or local permission policies your
+account requires.
+
 ## Planned Next Steps
 
 - deepen the studio experience without weakening the terminal-first workflow
-- keep dual-agent docs and validation honest as Claude runtime behavior gets more live coverage
+- keep multi-agent docs and validation honest as Claude and Augment runtime behavior get more live coverage
 - expand release outputs from npm tarballs into standalone binaries and wrapper package-manager installers

package/dist/core/agent.js

@@ -12,6 +12,7 @@ exports.runNextPrompt = runNextPrompt;
 exports.selectPrimaryAgent = selectPrimaryAgent;
 exports.resetAgentAdaptersForTesting = resetAgentAdaptersForTesting;
 exports.setAgentAdaptersForTesting = setAgentAdaptersForTesting;
+const augment_1 = require("./augment");
 const claude_1 = require("./claude");
 const codex_1 = require("./codex");
 const studio_session_1 = require("./studio-session");
@@ -51,7 +52,25 @@ const claudeAdapter = {
     writePlanningPack: claude_1.writePlanningPack,
     runNextPrompt: claude_1.runNextPrompt
 };
-const defaultAgentAdapters = [codexAdapter, claudeAdapter];
+const augmentAdapter = {
+    id: "augment",
+    label: "Augment CLI",
+    async detectStatus() {
+        const status = await (0, augment_1.detectAugment)();
+        return {
+            id: "augment",
+            label: "Augment CLI",
+            available: status.available,
+            command: status.command,
+            version: status.version,
+            error: status.error
+        };
+    },
+    requestPlannerReply: augment_1.requestPlannerReply,
+    writePlanningPack: augment_1.writePlanningPack,
+    runNextPrompt: augment_1.runNextPrompt
+};
+const defaultAgentAdapters = [codexAdapter, claudeAdapter, augmentAdapter];
 let registeredAgentAdapters = [...defaultAgentAdapters];
 let primaryAgentId = registeredAgentAdapters[0].id;
 function getSupportedAgentAdapters() {

package/dist/core/augment.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAugment = detectAugment;
+exports.requestPlannerReply = requestPlannerReply;
+exports.writePlanningPack = writePlanningPack;
+exports.runNextPrompt = runNextPrompt;
+exports.setAugmentRuntimeForTesting = setAugmentRuntimeForTesting;
+exports.resetAugmentRuntimeForTesting = resetAugmentRuntimeForTesting;
+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 AUGMENT_INSTALL_HINT = "install Augment CLI to enable";
+const AUGMENT_DEFAULT_RULES = `You are operating inside srgical, a local-first planning and iteration machine.
+
+Default behavior:
+- Ground decisions in the current repository state and the current .srgical files when they exist.
+- Prefer small validated steps over broad speculative rewrites.
+- Preserve a clear next-step handoff after each meaningful change.
+- Treat planning as preparation for execution, not open-ended brainstorming.
+- Keep outputs practical, explicit, and ready for the next iteration.`;
+let augmentCommandPromise;
+let forcedAugmentCommand = null;
+let spawnAndCaptureImpl = spawnAndCaptureBase;
+async function detectAugment() {
+    try {
+        const command = await resolveAugmentCommand();
+        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" ? "auggie.exe" : "auggie",
+            error: normalizeAugmentDetectionError(error)
+        };
+    }
+}
+async function requestPlannerReply(workspaceRoot, messages) {
+    const result = await runAugmentExec({
+        cwd: workspaceRoot,
+        prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
+        askMode: true,
+        maxTurns: 4
+    });
+    return result.lastMessage.trim();
+}
+async function writePlanningPack(workspaceRoot, messages) {
+    const planningEpoch = await (0, planning_epochs_1.preparePlanningPackForWrite)(workspaceRoot);
+    const augmentStatus = await detectAugment();
+    if (!augmentStatus.available) {
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, augmentStatus.error ?? "Augment CLI is unavailable", "Augment CLI"));
+    }
+    try {
+        const result = await runAugmentExec({
+            cwd: workspaceRoot,
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            maxTurns: 24
+        });
+        return appendPlanningEpochSummary(planningEpoch, result.lastMessage.trim());
+    }
+    catch (error) {
+        if (isAugmentUnavailableError(error)) {
+            const message = error instanceof Error ? error.message : "Augment CLI is unavailable";
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Augment CLI"));
+        }
+        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 runAugmentExec({
+        cwd: workspaceRoot,
+        prompt,
+        maxTurns: 24
+    });
+    return result.lastMessage.trim();
+}
+function setAugmentRuntimeForTesting(options) {
+    if (Object.prototype.hasOwnProperty.call(options, "command")) {
+        forcedAugmentCommand = options.command ?? null;
+        augmentCommandPromise = undefined;
+    }
+    if (options.spawnAndCapture) {
+        spawnAndCaptureImpl = options.spawnAndCapture;
+    }
+}
+function resetAugmentRuntimeForTesting() {
+    forcedAugmentCommand = null;
+    augmentCommandPromise = undefined;
+    spawnAndCaptureImpl = spawnAndCaptureBase;
+}
+async function runAugmentExec(options) {
+    const tempDir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "srgical-augment-"));
+    const promptFile = node_path_1.default.join(tempDir, "prompt.txt");
+    const rulesFile = node_path_1.default.join(tempDir, "rules.md");
+    const command = await resolveAugmentCommand();
+    const args = [
+        "--print",
+        "--quiet",
+        "--workspace-root",
+        options.cwd,
+        "--instruction-file",
+        promptFile,
+        "--rules",
+        rulesFile,
+        "--allow-indexing",
+        "--wait-for-indexing"
+    ];
+    if (options.askMode) {
+        args.push("--ask");
+    }
+    if (options.maxTurns) {
+        args.push("--max-turns", String(options.maxTurns));
+    }
+    await (0, promises_1.writeFile)(promptFile, options.prompt, "utf8");
+    await (0, promises_1.writeFile)(rulesFile, AUGMENT_DEFAULT_RULES, "utf8");
+    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 resolveAugmentCommand() {
+    if (forcedAugmentCommand) {
+        return forcedAugmentCommand;
+    }
+    if (!augmentCommandPromise) {
+        augmentCommandPromise = loadAugmentCommand();
+    }
+    return augmentCommandPromise;
+}
+async function loadAugmentCommand() {
+    if (process.platform !== "win32") {
+        return "auggie";
+    }
+    const result = await spawnAndCaptureImpl("where.exe", ["auggie"], 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 an Augment 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 normalizeAugmentDetectionError(error) {
+    const message = error instanceof Error ? error.message : "Failed to run auggie";
+    const normalized = message.toLowerCase();
+    if (normalized.includes("could not find files for the given pattern") ||
+        normalized.includes("unable to resolve an augment executable path") ||
+        normalized.includes("'auggie' is not recognized") ||
+        normalized.includes("enoent")) {
+        return AUGMENT_INSTALL_HINT;
+    }
+    return message;
+}
+function isAugmentUnavailableError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return (message.includes("unable to resolve an augment executable path") ||
+        message.includes("'auggie' is not recognized") ||
+        message.includes("enoent") ||
+        message.includes("failed to run auggie"));
+}
+function appendPlanningEpochSummary(preparation, summary) {
+    const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(preparation);
+    return [epochSummary, summary].filter(Boolean).join("\n");
+}

package/dist/ui/studio.js

@@ -335,7 +335,7 @@ async function launchStudio(options = {}) {
                 await appendMessage({
                     role: "system",
                     content: [
-                        "Usage: `/agent codex` or `/agent claude`",
+                        buildAgentUsageMessage(),
                         "",
                         renderAgentSelectionMessage(agentState.status, agentState.statuses)
                     ].join("\n")
@@ -650,6 +650,19 @@ function renderAgentSelectionMessage(activeAgent, statuses) {
         ...statuses.map((status) => formatAgentStatusLine(status, status.id === activeAgent.id))
     ].join("\n");
 }
+function buildAgentUsageMessage() {
+    const usages = (0, agent_1.getSupportedAgentAdapters)().map((adapter) => `\`/agent ${adapter.id}\``);
+    if (usages.length === 0) {
+        return "Usage: `/agent <id>`";
+    }
+    if (usages.length === 1) {
+        return `Usage: ${usages[0]}`;
+    }
+    if (usages.length === 2) {
+        return `Usage: ${usages[0]} or ${usages[1]}`;
+    }
+    return `Usage: ${usages.slice(0, -1).join(", ")}, or ${usages[usages.length - 1]}`;
+}
 function formatAgentStatusLine(status, selected) {
     const prefix = selected ? "*" : "-";
     const detail = status.available ? `ready (${status.version ?? "version unknown"})` : formatUnavailableAgentDetail(status);

package/docs/distribution.md

@@ -6,9 +6,9 @@ The current production release channels are GitHub Packages for npm, the public
 Versioning is tag-driven from git history, which means the repo carries a base major/minor line and CI computes the
 next patch version during release instead of committing a version bump back to `main`.
 
-The npm package does not bundle `codex` or `claude`. Users still need at least one supported local agent CLI installed
-separately and available on `PATH`, and `srgical doctor` remains the truthful way to confirm which agents are usable on
-the current machine.
+The npm package does not bundle `codex`, `claude`, or `auggie`. Users still need at least one supported local agent CLI
+installed separately and available on `PATH`, and `srgical doctor` remains the truthful way to confirm which agents are
+usable on the current machine.
 
 ## Release Flow
 
@@ -76,8 +76,8 @@ After installing the package, run:
 srgical doctor
 ```
 
-That verifies the workspace state, shows the active agent, and reports whether `codex` and `claude` are locally
-available or missing.
+That verifies the workspace state, shows the active agent, and reports whether `codex`, `claude`, and `auggie` are
+locally available or missing.
 
 ## Artifact Strategy
 
@@ -96,7 +96,7 @@ npm install -g @launch11/srgical
 
 - Required local prerequisites after install:
   - authenticated access to GitHub Packages
-  - `codex` and/or `claude` installed separately
+  - `codex`, `claude`, and/or `auggie` installed separately
   - available on `PATH` for the current shell session
 
 - Local install smoke test from a generated tarball:

package/docs/product-foundation.md

@@ -27,7 +27,7 @@ time.
 
 ## V1 Scope
 
-- Two launch-scope agent adapters: `codex` and `claude`
+- Three launch-scope agent adapters: `codex`, `claude`, and `augment`
 - One planning-pack format under `.srgical/`
 - One full-screen TUI for planning conversation
 - One execution command that runs the current next-step prompt through the active workspace agent

package/docs/testing-strategy.md

@@ -24,8 +24,9 @@ real bugs.
 
 ### Tier 3: Adapter and Agent behavior
 
-- primary-agent status detection must degrade cleanly when Codex is unavailable.
-- planner, pack-writing, and execution adapters must preserve today's Codex-first behavior.
+- primary-agent status detection must degrade cleanly when any supported adapter is unavailable.
+- planner, pack-writing, and execution adapters must preserve today's multi-agent behavior across Codex, Claude Code,
+  and Augment CLI.
 - Windows command resolution and shell-shim launching must stay covered because that path has already broken once.
 
 ### Tier 4: Release confidence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launch11/srgical",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A polished local-first CLI for planning and executing long AI-driven delivery sequences.",
   "files": [
     "dist",