@launch11/srgical 0.0.1

package/dist/core/studio-session.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STUDIO_MESSAGES = void 0;
+exports.loadStudioSession = loadStudioSession;
+exports.loadStudioSessionState = loadStudioSessionState;
+exports.saveStudioSession = saveStudioSession;
+exports.loadStoredActiveAgentId = loadStoredActiveAgentId;
+exports.saveStoredActiveAgentId = saveStoredActiveAgentId;
+const workspace_1 = require("./workspace");
+exports.DEFAULT_STUDIO_MESSAGES = [
+    {
+        role: "assistant",
+        content: "Describe what you are building, what is already true in the repo, or the next decision you need to make. I will help turn it into a disciplined `.srgical/` execution pack, and `/write` will update the repo files when you are ready."
+    }
+];
+async function loadStudioSession(workspaceRoot) {
+    return (await loadStudioSessionState(workspaceRoot)).messages;
+}
+async function loadStudioSessionState(workspaceRoot) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot);
+    const exists = await (0, workspace_1.fileExists)(paths.studioSession);
+    if (!exists) {
+        return createDefaultSessionState();
+    }
+    try {
+        const raw = await (0, workspace_1.readText)(paths.studioSession);
+        const parsed = JSON.parse(raw);
+        const messages = Array.isArray(parsed.messages) ? sanitizeMessages(parsed.messages) : [];
+        return {
+            messages: messages.length > 0 ? messages : cloneMessages(exports.DEFAULT_STUDIO_MESSAGES),
+            activeAgentId: sanitizeActiveAgentId(parsed.activeAgentId)
+        };
+    }
+    catch {
+        return createDefaultSessionState();
+    }
+}
+async function saveStudioSession(workspaceRoot, messages) {
+    const currentState = await loadStudioSessionState(workspaceRoot);
+    await writeStudioSession(workspaceRoot, {
+        messages,
+        activeAgentId: currentState.activeAgentId
+    });
+}
+async function loadStoredActiveAgentId(workspaceRoot) {
+    return (await loadStudioSessionState(workspaceRoot)).activeAgentId;
+}
+async function saveStoredActiveAgentId(workspaceRoot, activeAgentId) {
+    const currentState = await loadStudioSessionState(workspaceRoot);
+    await writeStudioSession(workspaceRoot, {
+        messages: currentState.messages,
+        activeAgentId
+    });
+}
+async function writeStudioSession(workspaceRoot, state) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+    const payload = {
+        version: 2,
+        updatedAt: new Date().toISOString(),
+        messages: sanitizeMessages(state.messages),
+        activeAgentId: sanitizeActiveAgentId(state.activeAgentId)
+    };
+    await (0, workspace_1.writeText)(paths.studioSession, JSON.stringify(payload, null, 2));
+}
+function sanitizeMessages(messages) {
+    return messages
+        .filter((message) => {
+        if (!message || typeof message !== "object") {
+            return false;
+        }
+        return isRole(message.role) && typeof message.content === "string" && message.content.trim().length > 0;
+    })
+        .map((message) => ({
+        role: message.role,
+        content: message.content
+    }));
+}
+function cloneMessages(messages) {
+    return messages.map((message) => ({
+        role: message.role,
+        content: message.content
+    }));
+}
+function createDefaultSessionState() {
+    return {
+        messages: cloneMessages(exports.DEFAULT_STUDIO_MESSAGES),
+        activeAgentId: null
+    };
+}
+function sanitizeActiveAgentId(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function isRole(value) {
+    return value === "user" || value === "assistant" || value === "system";
+}

package/dist/core/templates.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlanTemplate = buildPlanTemplate;
+exports.buildContextTemplate = buildContextTemplate;
+exports.buildTrackerTemplate = buildTrackerTemplate;
+exports.buildNextPromptTemplate = buildNextPromptTemplate;
+exports.getInitialTemplates = getInitialTemplates;
+const node_path_1 = __importDefault(require("node:path"));
+function projectNameFromRoot(root) {
+    return node_path_1.default.basename(root);
+}
+function buildPlanTemplate(root) {
+    const projectName = projectNameFromRoot(root);
+    return `# ${projectName} Product Plan
+
+Updated: ${new Date().toISOString().slice(0, 10)}
+
+## Purpose
+
+This file is the stable high-level plan for the current project. It should capture the architecture direction, the
+workflow shape, and the non-negotiable product rules that each execution slice must preserve.
+
+## Mission
+
+Define and ship a local-first CLI that helps a user:
+
+1. plan a project with an AI inside a dedicated interface,
+2. write a tracker pack into the repo,
+3. execute the next eligible delivery slice with AI support,
+4. keep progress incremental, validated, and resumable.
+
+## Locked Decisions
+
+- planning packs live under \`.srgical/\`
+- the workflow remains markdown-first and repo-visible
+- AI actions remain explicit and user-triggered
+- execution should happen in small validated slices
+- the interface should feel intentionally designed, not merely functional
+
+## Primary Workflow To Optimize
+
+1. open a studio
+2. talk to the planner
+3. trigger plan-pack generation
+4. run the next eligible step block
+5. review validation and continue
+
+## Target End State
+
+- the tool owns the planning ritual instead of relying on repeated prompt pastes
+- the pack format stays readable by humans and agents
+- agent execution can resume cleanly from repo state
+- the UI feels like a sharp creative control room
+`;
+}
+function buildContextTemplate() {
+    return `# Agent Context Kickoff
+
+Updated: ${new Date().toISOString()}
+Updated By: srgical
+
+## Mission
+
+Continue the current project from the planning pack in \`.srgical/\`. Read the stable plan, the tracker, and the next
+agent prompt before making changes.
+
+## Working Agreements
+
+- execute only the next eligible step or contiguous low-risk step block
+- keep changes incremental and validated
+- update the tracker and this handoff log after each completed block
+- stop when a blocker changes scope materially
+
+## Current Position
+
+- Last Completed: \`BOOT-001\`
+- Next Recommended: \`PLAN-001\`
+- Updated At: \`${new Date().toISOString()}\`
+- Updated By: \`srgical\`
+
+## Handoff Log
+
+### ${new Date().toISOString().slice(0, 10)} - BOOT-001 - srgical
+
+- Created the initial \`.srgical/\` planning pack.
+- Validation: confirmed the four planning-pack files were written.
+- Blockers: none.
+- Next recommended work: \`PLAN-001\`.
+`;
+}
+function buildTrackerTemplate() {
+    return `# Detailed Implementation Plan
+
+Updated: ${new Date().toISOString()}
+Updated By: srgical
+
+## Status Legend
+
+- \`pending\`: not started
+- \`in_progress\`: currently being executed
+- \`done\`: completed and validated
+- \`blocked\`: cannot proceed without resolving a blocker
+- \`skipped\`: intentionally skipped by an explicit design decision
+
+## Current Position
+
+- Last Completed: \`BOOT-001\`
+- Next Recommended: \`PLAN-001\`
+- Updated At: \`${new Date().toISOString()}\`
+- Updated By: \`srgical\`
+
+## Step Rules
+
+- Work 1 to 2 contiguous steps only when they stay in the same subsystem and still fit comfortably in context.
+- Do not mark a step \`done\` without recording validation notes.
+- Update the current position and handoff log after each completed block.
+- Stop immediately when a blocker changes scope materially.
+
+## Bootstrap
+
+| ID | Status | Depends On | Scope | Acceptance | Notes |
+| --- | --- | --- | --- | --- | --- |
+| BOOT-001 | done | - | Create the planning-pack scaffold. | The \`.srgical/\` pack exists. | Completed during \`srgical init\`. |
+
+## Planning
+
+| ID | Status | Depends On | Scope | Acceptance | Notes |
+| --- | --- | --- | --- | --- | --- |
+| PLAN-001 | pending | BOOT-001 | Convert the planning conversation into a stable product plan, kickoff log, tracker, and next-agent prompt. | The pack reflects the real project direction and is ready for execution. | Pending planner write. |
+
+## Delivery
+
+| ID | Status | Depends On | Scope | Acceptance | Notes |
+| --- | --- | --- | --- | --- | --- |
+| EXEC-001 | pending | PLAN-001 | Execute the next eligible implementation slice from the tracker. | The selected slice is complete, validated, and logged. | Pending tracker detail. |
+`;
+}
+function buildNextPromptTemplate() {
+    return `# Next Agent Prompt
+
+You are continuing the current project from the existing repo state. Do not restart product design or casually rewrite
+the whole codebase.
+
+## Read Order
+
+1. Read \`.srgical/02-agent-context-kickoff.md\`.
+2. Read \`.srgical/01-product-plan.md\`.
+3. Read \`.srgical/03-detailed-implementation-plan.md\`.
+4. Execute only the next eligible step block.
+
+## What To Determine Before Editing
+
+1. Identify \`Last Completed\` and \`Next Recommended\` in the tracker.
+2. Confirm the next eligible step or contiguous low-risk step block.
+3. Keep scope incremental and validation-aware.
+
+## Execution Rules
+
+1. Announce the chosen step ID or step IDs before making substantive edits.
+2. Execute the step block end-to-end.
+3. Preserve the locked product decisions from the plan.
+4. Run validation appropriate to the step block.
+5. Update the tracker and kickoff log when the block is complete.
+
+## Required Updates After Execution
+
+1. Update \`.srgical/03-detailed-implementation-plan.md\`.
+2. Mark finished steps \`done\` only if validation passed.
+3. Update the \`Current Position\` section.
+4. Append a dated handoff entry to \`.srgical/02-agent-context-kickoff.md\`.
+
+## Stop Conditions
+
+- Stop after finishing the chosen step block.
+- Stop before broadening into a different subsystem unless the tracker explicitly calls for it.
+- Stop and record a blocker if new architecture work is required.
+`;
+}
+function getInitialTemplates(paths) {
+    return {
+        [paths.plan]: buildPlanTemplate(paths.root),
+        [paths.context]: buildContextTemplate(),
+        [paths.tracker]: buildTrackerTemplate(),
+        [paths.nextPrompt]: buildNextPromptTemplate()
+    };
+}

package/dist/core/workspace.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAN_DIR = void 0;
+exports.resolveWorkspace = resolveWorkspace;
+exports.getPlanningPackPaths = getPlanningPackPaths;
+exports.ensurePlanningDir = ensurePlanningDir;
+exports.fileExists = fileExists;
+exports.planningPackExists = planningPackExists;
+exports.readText = readText;
+exports.writeText = writeText;
+exports.isGitRepo = isGitRepo;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.PLAN_DIR = ".srgical";
+function resolveWorkspace(input) {
+    return node_path_1.default.resolve(input ?? process.cwd());
+}
+function getPlanningPackPaths(root) {
+    const dir = node_path_1.default.join(root, exports.PLAN_DIR);
+    return {
+        root,
+        dir,
+        plan: node_path_1.default.join(dir, "01-product-plan.md"),
+        context: node_path_1.default.join(dir, "02-agent-context-kickoff.md"),
+        tracker: node_path_1.default.join(dir, "03-detailed-implementation-plan.md"),
+        nextPrompt: node_path_1.default.join(dir, "04-next-agent-prompt.md"),
+        studioSession: node_path_1.default.join(dir, "studio-session.json"),
+        executionState: node_path_1.default.join(dir, "execution-state.json"),
+        executionLog: node_path_1.default.join(dir, "execution-log.md")
+    };
+}
+async function ensurePlanningDir(root) {
+    const paths = getPlanningPackPaths(root);
+    await (0, promises_1.mkdir)(paths.dir, { recursive: true });
+    return paths;
+}
+async function fileExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function planningPackExists(root) {
+    const paths = getPlanningPackPaths(root);
+    const checks = await Promise.all([
+        fileExists(paths.plan),
+        fileExists(paths.context),
+        fileExists(paths.tracker),
+        fileExists(paths.nextPrompt)
+    ]);
+    return checks.every(Boolean);
+}
+async function readText(filePath) {
+    return (0, promises_1.readFile)(filePath, "utf8");
+}
+async function writeText(filePath, content) {
+    await (0, promises_1.writeFile)(filePath, content, "utf8");
+}
+async function isGitRepo(root) {
+    return fileExists(node_path_1.default.join(root, ".git"));
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const doctor_1 = require("./commands/doctor");
+const init_1 = require("./commands/init");
+const run_next_1 = require("./commands/run-next");
+const studio_1 = require("./commands/studio");
+const program = new commander_1.Command();
+const packageVersion = readPackageVersion();
+program
+    .name("srgical")
+    .description("Local-first AI planning and execution orchestration.")
+    .version(packageVersion);
+program
+    .command("doctor")
+    .description("Inspect the workspace and local agent availability.")
+    .argument("[workspace]", "Workspace path")
+    .action(async (workspace) => {
+    await (0, doctor_1.runDoctorCommand)(workspace);
+});
+program
+    .command("init")
+    .description("Create a local .srgical planning pack scaffold.")
+    .argument("[workspace]", "Workspace path")
+    .option("-f, --force", "Overwrite an existing planning pack")
+    .action(async (workspace, options) => {
+    await (0, init_1.runInitCommand)(workspace, Boolean(options.force));
+});
+program
+    .command("studio")
+    .description("Open the planning studio.")
+    .argument("[workspace]", "Workspace path")
+    .action(async (workspace) => {
+    await (0, studio_1.runStudioCommand)(workspace);
+});
+program
+    .command("run-next")
+    .description("Run the current next-agent prompt through the active agent adapter.")
+    .argument("[workspace]", "Workspace path")
+    .option("--dry-run", "Preview the current execution prompt without invoking the active agent")
+    .option("--agent <id>", "Temporarily override the active agent for this run only")
+    .action(async (workspace, options) => {
+    await (0, run_next_1.runRunNextCommand)(workspace, { dryRun: Boolean(options.dryRun), agent: options.agent });
+});
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});
+function readPackageVersion() {
+    const packageJsonPath = node_path_1.default.resolve(__dirname, "..", "package.json");
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+    return packageJson.version ?? "0.0.0";
+}