@launch11/srgical 0.0.1 → 0.0.3

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>`.
 
@@ -79,16 +82,14 @@ npm run release:pack
 The release bundle lands under `.artifacts/release/`. The broader distribution path, including standalone binaries and
 wrapper package-manager installs, is documented in `docs/distribution.md`.
 
-For release work, add a changeset in your feature branch:
-
-```bash
-npm run changeset
-```
-
 When that branch reaches `main`, the release workflow versions the package, publishes `@launcheleven/srgical` to
 GitHub Packages, publishes `@launch11/srgical` to npm, and opens a matching GitHub Release entry with the packaged
 artifacts.
 
+The repo keeps a base version line in `package.json` and CI computes the next patch version from matching git tags. For
+example, a base version of `0.0.0` means releases flow as `0.0.1`, `0.0.2`, and so on. To move to a new minor line,
+change the base version to something like `0.1.0`.
+
 ## Install Prerequisites
 
 Install `srgical`, then install at least one supported local agent CLI separately.
@@ -147,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
@@ -157,8 +159,18 @@ 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`, `--allow-indexing`, `--wait-for-indexing`, `--dont-save-session`, `--max-turns`, and `--ask` for
+planner-only 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,267 @@
+"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";
+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 command = await resolveAugmentCommand();
+    const args = [
+        "--print",
+        "--quiet",
+        "--workspace-root",
+        options.cwd,
+        "--instruction-file",
+        promptFile,
+        "--allow-indexing",
+        "--wait-for-indexing",
+        "--dont-save-session"
+    ];
+    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");
+    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

@@ -3,26 +3,27 @@
 ## Current Production Channel
 
 The current production release channels are GitHub Packages for npm, the public npm registry, and GitHub Releases.
-Versioning is source-controlled with Changesets, which means semver intent lives in pull requests instead of being
-inferred from CI build numbers.
+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
 
-1. A feature branch that changes the package also adds a changeset with `npm run changeset`.
-2. When that branch lands on `main`, the release workflow runs `npm ci`, `npm test`, and `npm run version-packages`.
-3. If the changesets produce a version bump, the workflow commits the updated `package.json`, `CHANGELOG.md`, and
-   consumed changeset files back to `main`.
-4. The same workflow run publishes `@launcheleven/srgical` to GitHub Packages.
-5. The workflow also stages and publishes `@launch11/srgical` to the public npm registry.
-6. After both publishes, the workflow creates a `v<version>` tag and a GitHub Release with the packaged artifacts
-   attached.
+1. `package.json` stores the release line, such as `0.0.0` or `0.1.0`.
+2. When a commit lands on `main`, the release workflow runs `npm ci` and `npm test`.
+3. CI reads the base version, looks for existing `v<major>.<minor>.*` tags, and computes the next patch version for
+   the current untagged commit.
+4. The workflow stages that computed version into temporary package copies without mutating the committed repo files.
+5. The same workflow publishes `@launcheleven/srgical` to GitHub Packages and `@launch11/srgical` to the public npm
+   registry.
+6. After both publishes succeed, the workflow creates a `v<version>` tag and a GitHub Release with the packaged
+   artifacts attached.
 
-This keeps the published semver repeatable across reruns and tracked in git history instead of being tied to a specific
-Actions run number, without requiring a separate release PR just to ship the version bump.
+This keeps the published semver repeatable for a given commit, avoids commit-noise from release-only version bumps, and
+still gives each published package a unique version that both registries can accept.
 
 ## Local Release Check
 
@@ -36,8 +37,9 @@ That command:
 
 - builds the TypeScript CLI,
 - runs `node dist/index.js doctor`,
-- creates an npm tarball under `.artifacts/release/`,
-- writes `release-manifest.json` and `release-manifest.md` with the artifact path and SHA256 hash.
+- computes the next release version from git tags,
+- creates GitHub Packages and npm tarballs under `.artifacts/release/`,
+- writes `release-manifest.json` and `release-manifest.md` with the artifact paths and SHA256 hashes.
 
 ## Registry Configuration
 
@@ -74,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
 
@@ -94,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
@@ -45,6 +45,6 @@ time.
 ## Distribution Strategy
 
 - Native packages: GitHub Packages as `@launcheleven/srgical` and npm public as `@launch11/srgical`
-- Versioning model: semver via Changesets on GitHub Actions, with version commits pushed directly to `main`
+- Versioning model: semver via git tags on GitHub Actions, with `package.json` carrying the base major/minor line
 - Release artifacts: standalone binaries for Windows, macOS, and Linux
 - Package-manager wrappers: `brew`, `choco`, and other ecosystems can install those release artifacts

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.1",
+  "version": "0.0.3",
   "description": "A polished local-first CLI for planning and executing long AI-driven delivery sequences.",
   "files": [
     "dist",
@@ -13,18 +13,11 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "changeset": "changeset",
     "dev": "tsx src/index.ts",
-    "release": "npm run release:pack && npm run publish:github && npm run publish:npm",
     "start": "node dist/index.js",
     "doctor": "tsx src/index.ts doctor",
     "test": "tsx --test test/**/*.test.ts",
-    "test:coverage": "tsx --test --experimental-test-coverage test/**/*.test.ts",
-    "version-packages": "changeset version",
-    "release:pack": "node scripts/release-pack.mjs",
-    "publish:github": "changeset publish",
-    "publish:npm": "node scripts/publish-npm.mjs",
-    "release:version": "node scripts/read-package-version.mjs"
+    "test:coverage": "tsx --test --experimental-test-coverage test/**/*.test.ts"
   },
   "engines": {
     "node": ">=20"
@@ -38,8 +31,8 @@
     "url": "https://github.com/LaunchEleven/Srgical/issues"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   },
   "keywords": [
     "ai",
@@ -55,7 +48,6 @@
     "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.30.0",
     "@types/blessed": "^0.1.27",
     "@types/node": "^25.5.0",
     "tsx": "^4.21.0",