@specship/specship 0.11.0

package/dist/installer/targets/claude.js

@@ -0,0 +1,864 @@
+"use strict";
+/**
+ * Claude Code target. Writes:
+ *
+ *   - MCP server entry to `~/.claude.json` (global = user scope, loads
+ *     in every project) or `./.mcp.json` (local = project scope, the
+ *     file Claude Code actually reads for a single project). See the
+ *     scope table at https://code.claude.com/docs/en/mcp.
+ *   - Permissions to `~/.claude/settings.json` (global) or
+ *     `./.claude/settings.json` (local), gated on `autoAllow`.
+ *   - Instructions to `~/.claude/CLAUDE.md` (global) or
+ *     `./.claude/CLAUDE.md` (local).
+ *
+ * Earlier versions wrote the local MCP entry to `./.claude.json` — a
+ * file Claude Code never reads — so the server silently never loaded
+ * until the user manually renamed it to `.mcp.json` (issue #207). We
+ * now write `./.mcp.json` and migrate any stale `./.claude.json` entry
+ * out of the way on install and uninstall.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeTarget = void 0;
+exports.writeMcpEntry = writeMcpEntry;
+exports.cleanupLegacyHooks = cleanupLegacyHooks;
+exports.cleanupCurrentHooks = cleanupCurrentHooks;
+exports.writePermissionsEntry = writePermissionsEntry;
+exports.statusLineState = statusLineState;
+exports.getStatusLineSnippet = getStatusLineSnippet;
+exports.writeStatusLineEntry = writeStatusLineEntry;
+exports.removeStatusLineEntry = removeStatusLineEntry;
+exports.removeInstructionsEntry = removeInstructionsEntry;
+exports.writeHooksEntry = writeHooksEntry;
+exports.writeSddHookEntry = writeSddHookEntry;
+exports.cleanupSddHooks = cleanupSddHooks;
+exports.writeSddInstructionsEntry = writeSddInstructionsEntry;
+exports.removeSddInstructionsEntry = removeSddInstructionsEntry;
+exports.writeCommandsEntries = writeCommandsEntries;
+exports.cleanupLegacyCommandsEntries = cleanupLegacyCommandsEntries;
+exports.writeAgentsEntries = writeAgentsEntries;
+exports.removeCommandsEntries = removeCommandsEntries;
+exports.removeAgentsEntries = removeAgentsEntries;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const shared_1 = require("./shared");
+const instructions_template_1 = require("../instructions-template");
+function configDir(loc) {
+    return loc === 'global'
+        ? path.join(os.homedir(), '.claude')
+        : path.join(process.cwd(), '.claude');
+}
+function mcpJsonPath(loc) {
+    // global → ~/.claude.json (user scope: visible in every project).
+    // local  → ./.mcp.json (project scope: the ONLY project-level MCP
+    // file Claude Code reads — NOT ./.claude.json, which it ignores).
+    return loc === 'global'
+        ? path.join(os.homedir(), '.claude.json')
+        : path.join(process.cwd(), '.mcp.json');
+}
+/**
+ * Where pre-#207 installers wrote the local MCP entry. Claude Code
+ * never reads a project-level `./.claude.json`, so we migrate the
+ * specship entry out of it on install and strip it on uninstall.
+ * Only the project-local path is legacy — global `~/.claude.json` is
+ * the correct user-scope location and is left untouched.
+ */
+function legacyLocalMcpPath() {
+    return path.join(process.cwd(), '.claude.json');
+}
+function settingsJsonPath(loc) {
+    return path.join(configDir(loc), 'settings.json');
+}
+function instructionsPath(loc) {
+    return path.join(configDir(loc), 'CLAUDE.md');
+}
+/**
+ * The CLAUDE.md Claude Code actually LOADS as memory — distinct from
+ * `instructionsPath` (the legacy `.claude/CLAUDE.md`, which the #529 block
+ * used). Project memory is the repo-root `./CLAUDE.md`; user memory is
+ * `~/.claude/CLAUDE.md`. The spec-driven-development steering rule goes here so
+ * the agent actually reads it.
+ */
+function claudeMdPath(loc) {
+    return loc === 'global'
+        ? path.join(os.homedir(), '.claude', 'CLAUDE.md')
+        : path.join(process.cwd(), 'CLAUDE.md');
+}
+function commandsDir(loc) {
+    return path.join(configDir(loc), 'commands');
+}
+function agentsDir(loc) {
+    return path.join(configDir(loc), 'agents');
+}
+/**
+ * Plugin-asset source dir at the package root — same `commands/`,
+ * `agents/`, `hooks/` directories that ship the plugin manifest path.
+ * Resolves identically from `src/installer/targets/claude.ts` (dev /
+ * test) and `dist/installer/targets/claude.js` (installed npm package).
+ */
+function packageAssetPath(...segments) {
+    return path.join(__dirname, '..', '..', '..', ...segments);
+}
+// Slash commands are a small set of progressive DOORS (WORKFLOW-DOORS-DOC),
+// split into two TIERS (INSTALL-WEDGE-DOC, REQ-WEDGE-001.A3). The retrieval door
+// is the adoption wedge — it ships on a default install with zero workflow
+// change. The governance doors (the spec lifecycle + the gate) are the deliberate
+// deep end and ship ONLY on an explicit opt-in (`--sdd`). Each door dispatches its
+// sub-actions internally, so a newcomer meets one obvious entry per phase instead
+// of a long flat list.
+/** Retrieval tier — the reads door. Shipped on every install. */
+const RETRIEVAL_TIER_COMMANDS = [
+    'ss-explore.md', // reads: explore / trace / impact
+];
+/** Governance tier — the intent + gate doors, plus the design→code commands. Opt-in (`--sdd`). */
+const GOVERNANCE_TIER_COMMANDS = [
+    'ss-spec.md', // intent loop: view / new / fast / implement / review / triage / behaviour / domain
+    'ss-check.md', // gate & health: check / drifted / fix / relink / health
+    // Design→code workflow (own surface; designer is slated for a separate cut, untouched here).
+    'ss-design-implement.md',
+    'ss-design-loop.md',
+];
+/**
+ * Every command SpecShip ships, both tiers. Used by uninstall (which removes
+ * the whole surface regardless of which tier was installed) and the dry-run
+ * file list.
+ */
+const SHIPPED_COMMANDS = [...RETRIEVAL_TIER_COMMANDS, ...GOVERNANCE_TIER_COMMANDS];
+/**
+ * Slash commands the installer used to ship but no longer does, so install can
+ * self-heal on upgrade (it removes any an earlier installer wrote, so the user's
+ * autocomplete doesn't carry stale duplicates) and uninstall strips them too.
+ * Two generations:
+ *   - the pre-v0.2 `cg-` prefix (from when SpecShip was "code graph");
+ *   - the flat per-action `ss-*` commands collapsed into the explore/spec/check
+ *     doors by WORKFLOW-DOORS-DOC (REQ-DOORS-003.A1). NOTE: the three surviving
+ *     doors — ss-explore, ss-spec, ss-check — are deliberately NOT listed here.
+ */
+const LEGACY_SHIPPED_COMMANDS = [
+    // pre-v0.2 `cg-` prefix
+    'cg-sync.md',
+    'cg-trace.md',
+    'cg-explore.md',
+    'cg-impact.md',
+    'cg-spec.md',
+    'cg-implement.md',
+    'cg-drifted.md',
+    'cg-fix.md',
+    'cg-relink.md',
+    'cg-spec-author.md',
+    'cg-spec-review.md',
+    // per-action ss-* commands folded into the doors (WORKFLOW-DOORS-DOC)
+    'ss-sync.md',
+    'ss-trace.md',
+    'ss-impact.md',
+    'ss-implement.md',
+    'ss-spec-author.md',
+    'ss-spec-review.md',
+    'ss-brainstorm.md',
+    'ss-domain.md',
+    'ss-triage.md',
+    'ss-behaviour.md',
+    'ss-drifted.md',
+    'ss-fix.md',
+    'ss-relink.md',
+];
+/** Subagents the installer copies into Claude's agents dir. */
+const SHIPPED_AGENTS = ['specship-explorer.md'];
+/** The PostToolUse + SessionStart hooks the installer writes. */
+const SPECSHIP_HOOKS = [
+    {
+        event: 'PostToolUse',
+        matcher: 'Edit|Write|MultiEdit',
+        hook: { type: 'command', command: 'specship sync --quiet', async: true },
+    },
+    {
+        event: 'SessionStart',
+        matcher: 'startup|resume',
+        hook: { type: 'command', command: 'specship sync --quiet' },
+    },
+];
+/**
+ * The spec-driven-development steering hook (SDD-INSTALL-DOC, REQ-SDD-002).
+ * A `UserPromptSubmit` hook executed by the harness; `specship spec-nudge`
+ * reads the prompt and, on feature/bug-shaped intent, injects a non-blocking
+ * reminder to author the spec via spec-author first. UserPromptSubmit has no
+ * tool matcher, so the matcher is empty (runs on every prompt; the nudge
+ * command does the conservative intent filtering itself).
+ */
+const SPECSHIP_SDD_HOOKS = [
+    {
+        event: 'UserPromptSubmit',
+        matcher: '',
+        hook: { type: 'command', command: 'specship spec-nudge' },
+    },
+];
+/**
+ * The status-line entry the installer writes into `settings.json`
+ * (SHIP-STATUSLINE-DOC). `command` mirrors the MCP launcher (`specship` on
+ * PATH); Claude Code pipes the status-line JSON to it on stdin and renders its
+ * stdout. The `_specship` marker is how uninstall knows we own this entry — a
+ * status line the user authored has no marker and is never touched.
+ */
+const SPECSHIP_STATUSLINE = {
+    type: 'command',
+    command: 'specship statusline',
+    _specship: true,
+};
+/** True when a `statusLine` object is one SpecShip wrote (carries our marker). */
+function isOurStatusLine(sl) {
+    return !!sl && typeof sl === 'object' && sl._specship === true;
+}
+class ClaudeCodeTarget {
+    id = 'claude';
+    displayName = 'Claude Code';
+    docsUrl = 'https://docs.claude.com/en/docs/claude-code';
+    supportsLocation(_loc) {
+        return true;
+    }
+    detect(loc) {
+        const mcpPath = mcpJsonPath(loc);
+        const config = (0, shared_1.readJsonFile)(mcpPath);
+        const alreadyConfigured = !!config.mcpServers?.specship;
+        // For "installed" we infer from the existence of either the dir
+        // (global) or the project marker file (local). Cheap and avoids
+        // shelling out to `claude --version`.
+        const installed = loc === 'global'
+            ? fs.existsSync(configDir(loc)) || fs.existsSync(mcpPath)
+            : fs.existsSync(mcpPath) || fs.existsSync(configDir(loc));
+        return { installed, alreadyConfigured, configPath: mcpPath };
+    }
+    install(loc, opts) {
+        const files = [];
+        // 1. MCP server entry
+        files.push(writeMcpEntry(loc));
+        // 1b. Migrate away any stale ./.claude.json left by a pre-#207
+        // local install, so the project isn't left with two competing
+        // (one dead) MCP configs.
+        if (loc === 'local') {
+            const migrated = cleanupLegacyLocalMcp();
+            if (migrated)
+                files.push(migrated);
+        }
+        // 2. Permissions (only when autoAllow)
+        if (opts.autoAllow) {
+            files.push(writePermissionsEntry(loc));
+        }
+        // 2b. Strip stale auto-sync hooks left by a pre-0.8 install. Those
+        // versions wrote `specship mark-dirty` / `sync-if-dirty` hooks to
+        // settings.json; both subcommands are gone from the CLI, so the
+        // Stop hook now fails every turn with "unknown command
+        // 'sync-if-dirty'". Cleaning up on install makes an upgrade
+        // self-healing. Only surfaced when something was actually removed.
+        const hookCleanup = cleanupLegacyHooks(loc);
+        if (hookCleanup.action === 'removed')
+            files.push(hookCleanup);
+        // 2c. Write the current auto-sync hooks (PostToolUse + SessionStart
+        // running `specship sync --quiet`). Gated on autoAllow — same
+        // posture as the permissions list since both auto-execute commands
+        // without prompting. Idempotent: re-running with identical hooks
+        // already in settings.json returns 'unchanged'.
+        if (opts.autoAllow) {
+            files.push(writeHooksEntry(loc));
+        }
+        // 3. CLAUDE.md instructions — no longer written. The specship
+        // usage guidance now ships solely in the MCP server's `initialize`
+        // response (see `mcp/server-instructions.ts`), which Claude Code
+        // surfaces in the system prompt automatically. Writing it into
+        // CLAUDE.md as well meant the agent read the same playbook twice
+        // every turn (issue #529). Strip any block a previous install left
+        // behind so an upgrade self-heals — same idiom as the hook cleanup.
+        const instrCleanup = removeInstructionsEntry(loc);
+        if (instrCleanup.action === 'removed')
+            files.push(instrCleanup);
+        // 4. Slash commands + the specship-explorer subagent. NOT gated on
+        // autoAllow — these only execute when the user / agent invokes them
+        // explicitly. Copies the same .md files that ship for the plugin
+        // install path, so the two flows can't drift apart.
+        //
+        // 4a. Strip any legacy `cg-*.md` slash commands the pre-v0.2
+        // installer wrote. Self-heals on upgrade so the user's autocomplete
+        // doesn't carry both prefixes side-by-side.
+        // Governance is opt-in (INSTALL-WEDGE-DOC, REQ-WEDGE-002): the spec /
+        // authoring / review / design commands AND the SDD steering ship together
+        // only when the user explicitly enables them with `--sdd`. A default install
+        // provisions the retrieval tier alone, protecting the wedge (REQ-WEDGE-001).
+        const includeGovernance = opts.sdd === true;
+        for (const f of cleanupLegacyCommandsEntries(loc))
+            files.push(f);
+        for (const f of writeCommandsEntries(loc, includeGovernance))
+            files.push(f);
+        for (const f of writeAgentsEntries(loc))
+            files.push(f);
+        // 5. Spec-driven-development steering (SDD-INSTALL-DOC, as superseded by
+        // INSTALL-WEDGE-DOC). Part of the governance tier — opt-in via `--sdd`.
+        // Writes a marker-delimited "invoke spec-author first" rule into the project
+        // CLAUDE.md and a UserPromptSubmit nudge hook. NOT gated on autoAllow — the
+        // CLAUDE.md rule executes nothing and the nudge hook only prints guidance.
+        if (includeGovernance) {
+            files.push(writeSddInstructionsEntry(loc));
+            files.push(writeSddHookEntry(loc));
+        }
+        // 6. Status-line segment (SHIP-STATUSLINE-DOC, REQ-STATUSLINE-006).
+        // Strictly opt-in — only when the caller set installStatusLine (the
+        // interactive prompt, or `--statusline`). Never clobbers a user's existing
+        // status line: writeStatusLineEntry returns 'kept' and we surface the
+        // composable snippet as a note so the user can wire it in themselves.
+        const notes = [];
+        if (opts.installStatusLine) {
+            const sl = writeStatusLineEntry(loc);
+            files.push(sl);
+            if (sl.action === 'kept') {
+                notes.push('A status line is already configured — left untouched. Add the SpecShip ' +
+                    `segment to your own status-line script:\n    ${getStatusLineSnippet()}`);
+            }
+        }
+        return notes.length ? { files, notes } : { files };
+    }
+    uninstall(loc) {
+        const files = [];
+        // 1. MCP server entry
+        const mcpPath = mcpJsonPath(loc);
+        const config = (0, shared_1.readJsonFile)(mcpPath);
+        if (config.mcpServers?.specship) {
+            delete config.mcpServers.specship;
+            if (Object.keys(config.mcpServers).length === 0) {
+                delete config.mcpServers;
+            }
+            (0, shared_1.writeJsonFile)(mcpPath, config);
+            files.push({ path: mcpPath, action: 'removed' });
+        }
+        else {
+            files.push({ path: mcpPath, action: 'not-found' });
+        }
+        // 1b. Also strip the specship entry from a legacy ./.claude.json
+        // so uninstall fully reverses a pre-#207 local install.
+        if (loc === 'local') {
+            const migrated = cleanupLegacyLocalMcp();
+            if (migrated)
+                files.push(migrated);
+        }
+        // 2. Permissions
+        const settingsPath = settingsJsonPath(loc);
+        const settings = (0, shared_1.readJsonFile)(settingsPath);
+        if (Array.isArray(settings.permissions?.allow)) {
+            const before = settings.permissions.allow.length;
+            settings.permissions.allow = settings.permissions.allow.filter((p) => !p.startsWith('mcp__specship__'));
+            if (settings.permissions.allow.length !== before) {
+                if (settings.permissions.allow.length === 0) {
+                    delete settings.permissions.allow;
+                }
+                if (Object.keys(settings.permissions).length === 0) {
+                    delete settings.permissions;
+                }
+                (0, shared_1.writeJsonFile)(settingsPath, settings);
+                files.push({ path: settingsPath, action: 'removed' });
+            }
+            else {
+                files.push({ path: settingsPath, action: 'not-found' });
+            }
+        }
+        else {
+            files.push({ path: settingsPath, action: 'not-found' });
+        }
+        // 2b. Strip auto-sync hooks the installer wrote — both the
+        // current `specship sync --quiet` form (writeHooksEntry) and the
+        // legacy `mark-dirty`/`sync-if-dirty` forms (pre-0.8). Two passes
+        // so each predicate stays narrow and we never accidentally strip a
+        // user-written hook.
+        const currentCleanup = cleanupCurrentHooks(loc);
+        if (currentCleanup.action === 'removed')
+            files.push(currentCleanup);
+        const legacyCleanup = cleanupLegacyHooks(loc);
+        if (legacyCleanup.action === 'removed')
+            files.push(legacyCleanup);
+        // 3. Instructions — strip the legacy SpecShip block if present.
+        files.push(removeInstructionsEntry(loc));
+        // 4. Slash commands + subagent — remove our shipped files; sibling
+        // user-written .md files in the same dir are left untouched.
+        // Includes legacy `cg-*.md` from pre-v0.2 installers so uninstall
+        // leaves the commands dir clean regardless of which prefix was
+        // installed.
+        for (const f of cleanupLegacyCommandsEntries(loc))
+            files.push(f);
+        for (const f of removeCommandsEntries(loc))
+            files.push(f);
+        for (const f of removeAgentsEntries(loc))
+            files.push(f);
+        // 5. Spec-driven-development steering — strip the CLAUDE.md rule block
+        // and the nudge hook (no-op when absent). Always runs so uninstall fully
+        // reverses install regardless of whether --no-sdd was used.
+        files.push(removeSddInstructionsEntry(loc));
+        const sddHookCleanup = cleanupSddHooks(loc);
+        if (sddHookCleanup.action === 'removed')
+            files.push(sddHookCleanup);
+        // 6. Status-line segment — remove only the marked entry we wrote
+        // (REQ-STATUSLINE-007). A user-authored status line has no marker and is
+        // left untouched; absent entry is a no-op. Always runs so uninstall fully
+        // reverses an opt-in status-line install.
+        const slCleanup = removeStatusLineEntry(loc);
+        if (slCleanup.action === 'removed')
+            files.push(slCleanup);
+        return { files };
+    }
+    printConfig(loc) {
+        const target = mcpJsonPath(loc);
+        const snippet = JSON.stringify({ mcpServers: { specship: (0, shared_1.getMcpServerConfig)() } }, null, 2);
+        return `# Add to ${target}\n\n${snippet}\n`;
+    }
+    describePaths(loc) {
+        return [
+            mcpJsonPath(loc),
+            settingsJsonPath(loc),
+            instructionsPath(loc),
+            ...SHIPPED_COMMANDS.map((f) => path.join(commandsDir(loc), f)),
+            ...SHIPPED_AGENTS.map((f) => path.join(agentsDir(loc), f)),
+        ];
+    }
+}
+/**
+ * Per-file write helpers, exported so the legacy `config-writer.ts`
+ * shim can call only the named operation (writeMcpConfig writes ONLY
+ * the MCP entry, etc.) instead of `claudeTarget.install()` which
+ * writes all three files. Without this split the shims silently
+ * cause side effects callers don't expect.
+ */
+function writeMcpEntry(loc) {
+    const file = mcpJsonPath(loc);
+    const existing = (0, shared_1.readJsonFile)(file);
+    const before = existing.mcpServers?.specship;
+    const after = (0, shared_1.getMcpServerConfig)();
+    if ((0, shared_1.jsonDeepEqual)(before, after)) {
+        // Already exactly what we'd write — preserve byte-identical file.
+        return { path: file, action: 'unchanged' };
+    }
+    // 'created' here means: the file itself did not exist before this
+    // write. A pre-existing MCP JSON file (`~/.claude.json` globally,
+    // `./.mcp.json` locally) containing other MCP servers (no
+    // `specship` key) is 'updated', not 'created' — we're adding an
+    // entry to a file that was already there. Codex uses a different
+    // idiom (empty-content => 'created') because its config.toml is
+    // ours alone to manage.
+    const action = before ? 'updated' : (fs.existsSync(file) ? 'updated' : 'created');
+    if (!existing.mcpServers)
+        existing.mcpServers = {};
+    existing.mcpServers.specship = after;
+    (0, shared_1.writeJsonFile)(file, existing);
+    return { path: file, action };
+}
+/**
+ * Strip the specship entry from a legacy project-local
+ * `./.claude.json` (written by pre-#207 installers, which Claude Code
+ * never read). Surgical: only our `specship` key is removed; sibling
+ * MCP servers and any unrelated keys are preserved, and the file is
+ * deleted only when removal leaves it completely empty. Returns the
+ * file action for reporting, or `null` when there's nothing to migrate.
+ */
+function cleanupLegacyLocalMcp() {
+    const file = legacyLocalMcpPath();
+    if (!fs.existsSync(file))
+        return null;
+    const config = (0, shared_1.readJsonFile)(file);
+    if (!config.mcpServers?.specship)
+        return null;
+    delete config.mcpServers.specship;
+    if (Object.keys(config.mcpServers).length === 0)
+        delete config.mcpServers;
+    if (Object.keys(config).length === 0) {
+        try {
+            fs.unlinkSync(file);
+        }
+        catch { /* ignore */ }
+    }
+    else {
+        (0, shared_1.writeJsonFile)(file, config);
+    }
+    return { path: file, action: 'removed' };
+}
+/**
+ * True when a Claude Code hook `command` is one of the **pre-0.8**
+ * specship auto-sync hooks: `specship mark-dirty` (PostToolUse) /
+ * `specship sync-if-dirty` (Stop). Both subcommands have since been
+ * removed from the CLI, so the Stop hook fails every turn with
+ * "unknown command 'sync-if-dirty'" — stripping them on install
+ * (self-heal on upgrade) is what keeps the upgrade quiet. Local builds
+ * also wrote the npx form, which still contains the `specship
+ * <subcommand>` substring; the substring match covers both. Sibling
+ * user hooks (e.g. GitKraken's `gk ai hook run`) match nothing here.
+ *
+ * The **current** auto-sync hook form (`specship sync --quiet`) is
+ * NOT matched here — install writes those and would re-strip its own
+ * work if this predicate covered them. The uninstall flow uses
+ * `isCurrentSpecshipHookCommand` for those, on top of this one.
+ */
+function isLegacySpecshipHookCommand(command) {
+    if (typeof command !== 'string')
+        return false;
+    return (command.includes('specship mark-dirty') ||
+        command.includes('specship sync-if-dirty'));
+}
+/**
+ * True when a hook `command` is one of the auto-sync hooks
+ * `writeHooksEntry` writes in this release (`specship sync --quiet`).
+ * Uninstall-only — install must NOT match these or it would destroy
+ * the entries it just wrote.
+ */
+function isCurrentSpecshipHookCommand(command) {
+    if (typeof command !== 'string')
+        return false;
+    return SPECSHIP_HOOKS.some(({ hook }) => command === hook.command);
+}
+/**
+ * Strip specship hook commands matched by `predicate` from Claude
+ * `settings.json`. Surgical at the individual-command level: only
+ * matched entries are dropped, so a sibling hook sharing a matcher
+ * group (or the Stop event) survives. Matcher groups are pruned only
+ * once their `hooks` array is empty, events only once they have no
+ * groups left, and `hooks` itself only once every event is gone — and
+ * none of that runs unless we actually removed a command, so a
+ * settings.json with no matching hooks is left byte-for-byte untouched
+ * and reported `unchanged`.
+ */
+function stripHooksMatching(loc, predicate) {
+    const file = settingsJsonPath(loc);
+    if (!fs.existsSync(file))
+        return { path: file, action: 'not-found' };
+    const settings = (0, shared_1.readJsonFile)(file);
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+        return { path: file, action: 'unchanged' };
+    }
+    let removedAny = false;
+    for (const event of Object.keys(hooks)) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        for (const group of groups) {
+            if (!group || !Array.isArray(group.hooks))
+                continue;
+            const before = group.hooks.length;
+            group.hooks = group.hooks.filter((h) => !predicate(h?.command));
+            if (group.hooks.length !== before)
+                removedAny = true;
+        }
+    }
+    if (!removedAny)
+        return { path: file, action: 'unchanged' };
+    for (const event of Object.keys(hooks)) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        hooks[event] = groups.filter((g) => !(g && Array.isArray(g.hooks) && g.hooks.length === 0));
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    if (Object.keys(hooks).length === 0)
+        delete settings.hooks;
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: 'removed' };
+}
+/**
+ * Remove stale **pre-0.8** specship auto-sync hooks
+ * (`specship mark-dirty` / `specship sync-if-dirty`) from Claude
+ * `settings.json`. Safe to call from both `install` (self-heal on
+ * upgrade) and `uninstall`. Exported so it can be unit-tested directly.
+ */
+function cleanupLegacyHooks(loc) {
+    return stripHooksMatching(loc, isLegacySpecshipHookCommand);
+}
+/**
+ * Remove the current-release auto-sync hooks (`specship sync --quiet`)
+ * written by `writeHooksEntry`. Uninstall-only — install would
+ * destroy its own write if this ran there.
+ */
+function cleanupCurrentHooks(loc) {
+    return stripHooksMatching(loc, isCurrentSpecshipHookCommand);
+}
+function writePermissionsEntry(loc) {
+    const file = settingsJsonPath(loc);
+    const settings = (0, shared_1.readJsonFile)(file);
+    const created = !fs.existsSync(file);
+    if (!settings.permissions)
+        settings.permissions = {};
+    if (!Array.isArray(settings.permissions.allow))
+        settings.permissions.allow = [];
+    const want = (0, shared_1.getSpecShipPermissions)();
+    const before = [...settings.permissions.allow];
+    for (const perm of want) {
+        if (!settings.permissions.allow.includes(perm)) {
+            settings.permissions.allow.push(perm);
+        }
+    }
+    if ((0, shared_1.jsonDeepEqual)(before, settings.permissions.allow) && !created) {
+        return { path: file, action: 'unchanged' };
+    }
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: created ? 'created' : 'updated' };
+}
+/**
+ * What status line is configured at this location, from SpecShip's point of
+ * view (REQ-STATUSLINE-006): `none` (free to write), `ours` (a marked entry we
+ * wrote — safe to re-assert), or `foreign` (a status line the user owns — must
+ * never be clobbered). Drives the installer's offer-vs-snippet decision.
+ */
+function statusLineState(loc) {
+    const settings = (0, shared_1.readJsonFile)(settingsJsonPath(loc));
+    if (!settings.statusLine)
+        return 'none';
+    return isOurStatusLine(settings.statusLine) ? 'ours' : 'foreign';
+}
+/** The one-line snippet a user composes into their own status-line script. */
+function getStatusLineSnippet() {
+    return 'specship statusline   # pipe Claude\'s status-line JSON in; append its output to your line';
+}
+/**
+ * Write SpecShip's status-line entry into `settings.json`
+ * (REQ-STATUSLINE-006). Refuses to overwrite a status line the user already
+ * configured: returns `kept` when a foreign `statusLine` is present, so the
+ * caller can surface the composable snippet instead. Idempotent — re-asserting
+ * our own marked entry byte-for-byte returns `unchanged`.
+ */
+function writeStatusLineEntry(loc) {
+    const file = settingsJsonPath(loc);
+    const settings = (0, shared_1.readJsonFile)(file);
+    const existing = settings.statusLine;
+    // Never clobber a user-authored status line.
+    if (existing && !isOurStatusLine(existing)) {
+        return { path: file, action: 'kept' };
+    }
+    if (isOurStatusLine(existing) && (0, shared_1.jsonDeepEqual)(existing, SPECSHIP_STATUSLINE)) {
+        return { path: file, action: 'unchanged' };
+    }
+    const created = !fs.existsSync(file);
+    settings.statusLine = { ...SPECSHIP_STATUSLINE };
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: created ? 'created' : 'updated' };
+}
+/**
+ * Inverse of `writeStatusLineEntry`: remove the `statusLine` entry ONLY when
+ * it is the marked one we wrote (REQ-STATUSLINE-007). A user-authored status
+ * line (no marker) is left exactly as-is; an absent entry is a no-op.
+ */
+function removeStatusLineEntry(loc) {
+    const file = settingsJsonPath(loc);
+    if (!fs.existsSync(file))
+        return { path: file, action: 'not-found' };
+    const settings = (0, shared_1.readJsonFile)(file);
+    if (!isOurStatusLine(settings.statusLine)) {
+        // Either nothing there, or a user-owned status line — never touch it.
+        return { path: file, action: settings.statusLine ? 'kept' : 'not-found' };
+    }
+    delete settings.statusLine;
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: 'removed' };
+}
+/**
+ * Strip the marker-delimited SpecShip block from CLAUDE.md if a prior
+ * install wrote one. Specship no longer maintains an instructions file
+ * (issue #529) — the MCP server's `initialize` instructions are the
+ * single source of truth — so both install (self-heal on upgrade) and
+ * uninstall call this. `removeMarkedSection` returns `not-found`/`kept`
+ * when there's nothing to strip; the install caller drops those from
+ * the report so a fresh install stays quiet.
+ */
+function removeInstructionsEntry(loc) {
+    const file = instructionsPath(loc);
+    const action = (0, shared_1.removeMarkedSection)(file, instructions_template_1.SPECSHIP_SECTION_START, instructions_template_1.SPECSHIP_SECTION_END);
+    return { path: file, action };
+}
+/**
+ * Write specship's auto-sync hooks into Claude `settings.json`. Merges
+ * idempotently into any user-defined hooks: a matcher group sharing our
+ * exact matcher string is reused; sibling matchers / events / events are
+ * untouched. Returns `unchanged` when our two hook commands are already
+ * present byte-for-byte in the right places.
+ *
+ * Gated by `install()` on `autoAllow` — same posture as the permissions
+ * list. The matching uninstall lives in `cleanupLegacyHooks` (whose
+ * matcher predicate covers BOTH the new `specship sync --quiet` form
+ * and the legacy `specship mark-dirty`/`sync-if-dirty` forms).
+ */
+function writeHooksEntry(loc) {
+    return writeHooksFor(loc, SPECSHIP_HOOKS);
+}
+/**
+ * Write the spec-driven-development UserPromptSubmit nudge hook into
+ * `settings.json` (SDD-INSTALL-DOC, REQ-SDD-002). Same idempotent merge as
+ * the auto-sync hooks; gated by `install()` on `opts.sdd` rather than
+ * `autoAllow`, since it's part of the SDD steering feature.
+ */
+function writeSddHookEntry(loc) {
+    return writeHooksFor(loc, SPECSHIP_SDD_HOOKS);
+}
+/**
+ * Idempotently merge a set of hooks into Claude `settings.json`. A matcher
+ * group sharing our exact matcher string is reused; sibling matchers / events
+ * are untouched; a command already present byte-for-byte is skipped. Returns
+ * `unchanged` when nothing was added.
+ */
+function writeHooksFor(loc, hooks) {
+    const file = settingsJsonPath(loc);
+    const created = !fs.existsSync(file);
+    const settings = (0, shared_1.readJsonFile)(file);
+    const beforeJson = JSON.stringify(settings);
+    if (!settings.hooks || typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+        settings.hooks = {};
+    }
+    for (const { event, matcher, hook } of hooks) {
+        if (!Array.isArray(settings.hooks[event]))
+            settings.hooks[event] = [];
+        let group = settings.hooks[event].find((g) => g && g.matcher === matcher);
+        if (!group) {
+            group = { matcher, hooks: [] };
+            settings.hooks[event].push(group);
+        }
+        if (!Array.isArray(group.hooks))
+            group.hooks = [];
+        // Idempotent: skip if a command-equal entry is already there.
+        if (!group.hooks.some((h) => h && h.command === hook.command)) {
+            group.hooks.push({ ...hook });
+        }
+    }
+    const afterJson = JSON.stringify(settings);
+    if (beforeJson === afterJson && !created) {
+        return { path: file, action: 'unchanged' };
+    }
+    (0, shared_1.writeJsonFile)(file, settings);
+    return { path: file, action: created ? 'created' : 'updated' };
+}
+/** True when a hook command is the SDD nudge (`specship spec-nudge`). Uninstall-only. */
+function isSddHookCommand(command) {
+    if (typeof command !== 'string')
+        return false;
+    return SPECSHIP_SDD_HOOKS.some(({ hook }) => command === hook.command);
+}
+/** Remove the SDD nudge hook written by `writeSddHookEntry`. Uninstall-only. */
+function cleanupSddHooks(loc) {
+    return stripHooksMatching(loc, isSddHookCommand);
+}
+/**
+ * Write the spec-driven-development steering rule into the project CLAUDE.md
+ * (SDD-INSTALL-DOC, REQ-SDD-001). Idempotent + marker-delimited so the user's
+ * surrounding content is untouched and a re-run reports `unchanged`. Distinct
+ * markers from the legacy #529 block — this is the ordering rule, not the MCP
+ * playbook.
+ */
+function writeSddInstructionsEntry(loc) {
+    const file = claudeMdPath(loc);
+    const action = (0, shared_1.upsertMarkedSection)(file, instructions_template_1.SPECSHIP_SDD_SECTION_START, instructions_template_1.SPECSHIP_SDD_SECTION_END, (0, instructions_template_1.getSddRuleBlock)());
+    return { path: file, action };
+}
+/** Inverse of `writeSddInstructionsEntry`: strip the SDD rule block. */
+function removeSddInstructionsEntry(loc) {
+    const file = claudeMdPath(loc);
+    const action = (0, shared_1.removeMarkedSection)(file, instructions_template_1.SPECSHIP_SDD_SECTION_START, instructions_template_1.SPECSHIP_SDD_SECTION_END);
+    return { path: file, action };
+}
+/**
+ * Copy our shipped slash commands (commands/ss-*.md) into the user's
+ * commands dir (~/.claude/commands/ globally, ./.claude/commands/
+ * locally). Per-file idempotent: a destination with identical bytes is
+ * reported `unchanged`. Sibling user-written .md files in the same dir
+ * are never touched.
+ *
+ * The retrieval tier is always written; the governance tier is written only
+ * when `includeGovernance` is set (INSTALL-WEDGE-DOC, REQ-WEDGE-001/002). A
+ * default install never touches the governance commands — neither writing them
+ * nor (since this only ever writes) removing any a prior opt-in left behind, so
+ * an existing governance install is preserved on upgrade (REQ-WEDGE-002.A4).
+ */
+function writeCommandsEntries(loc, includeGovernance = false) {
+    const cmds = includeGovernance ? SHIPPED_COMMANDS : RETRIEVAL_TIER_COMMANDS;
+    return cmds.map((name) => copyAsset(packageAssetPath('commands', name), path.join(commandsDir(loc), name)));
+}
+/**
+ * Remove legacy `cg-*.md` slash commands left behind by a pre-v0.2
+ * installer. Called from `install()` so an upgrade self-heals (the user
+ * doesn't end up with both prefixes side-by-side cluttering their
+ * autocomplete) and from `uninstall()` so the legacy files don't
+ * persist after specship is removed. Sibling user-written .md files
+ * in the same dir are never touched — only the exact filenames in
+ * LEGACY_SHIPPED_COMMANDS are candidates.
+ */
+function cleanupLegacyCommandsEntries(loc) {
+    return LEGACY_SHIPPED_COMMANDS
+        .map((name) => removeFile(path.join(commandsDir(loc), name)))
+        // Only surface files that actually existed and got removed — keeps
+        // the install/uninstall log quiet for users who never had the
+        // legacy `cg-*` prefix on disk.
+        .filter((entry) => entry.action === 'removed');
+}
+/**
+ * Copy our shipped subagent (agents/specship-explorer.md) into the
+ * user's agents dir. Same idempotency contract as writeCommandsEntries.
+ */
+function writeAgentsEntries(loc) {
+    return SHIPPED_AGENTS.map((name) => copyAsset(packageAssetPath('agents', name), path.join(agentsDir(loc), name)));
+}
+/**
+ * Inverse of writeCommandsEntries: delete each cg-*.md we shipped, if
+ * present. A file the user replaced with their own content is still
+ * removed — match the existing uninstall posture for files specship
+ * owns (the user can re-add their version after).
+ */
+function removeCommandsEntries(loc) {
+    return SHIPPED_COMMANDS.map((name) => removeFile(path.join(commandsDir(loc), name)));
+}
+/** Inverse of writeAgentsEntries. */
+function removeAgentsEntries(loc) {
+    return SHIPPED_AGENTS.map((name) => removeFile(path.join(agentsDir(loc), name)));
+}
+function copyAsset(src, dest) {
+    const body = fs.readFileSync(src, 'utf-8');
+    if (fs.existsSync(dest)) {
+        const existing = fs.readFileSync(dest, 'utf-8');
+        if (existing === body)
+            return { path: dest, action: 'unchanged' };
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, body);
+        return { path: dest, action: 'updated' };
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, body);
+    return { path: dest, action: 'created' };
+}
+function removeFile(p) {
+    if (!fs.existsSync(p))
+        return { path: p, action: 'not-found' };
+    fs.unlinkSync(p);
+    return { path: p, action: 'removed' };
+}
+exports.claudeTarget = new ClaudeCodeTarget();
+//# sourceMappingURL=claude.js.map