@bridge_gpt/mcp-server 0.2.16 → 0.2.19

package/build/backend-warnings.js

@@ -0,0 +1,44 @@
+// Shared helper for surfacing non-blocking backend warnings (BAPI-545) as
+// user-visible MCP tool text. The Tier-4 ticket-text routes (PRD, FSD,
+// clarifying questions, ticket critique, ticket review, create_doc) attach a
+// disclosure to their JSON response body when no VCS connection exists but
+// still succeed — this never changes tool success/failure status, it only
+// appends non-blocking text.
+// Extracts warning strings from a parsed backend JSON response. Accepts the
+// real backend shape (a singular `warning: string | null` field, as used by
+// the Tier-4 trigger endpoints' MessageResponse) and, defensively, a
+// `warnings` array of strings or `{ message: string }` objects (in case a
+// future backend response adopts the list shape instead). Invalid/empty
+// values are ignored; never throws.
+export function extractBackendWarnings(body) {
+    if (body === null || typeof body !== "object") {
+        return [];
+    }
+    const record = body;
+    const warnings = [];
+    if (typeof record.warning === "string" && record.warning) {
+        warnings.push(record.warning);
+    }
+    if (Array.isArray(record.warnings)) {
+        for (const entry of record.warnings) {
+            if (typeof entry === "string" && entry) {
+                warnings.push(entry);
+            }
+            else if (entry !== null &&
+                typeof entry === "object" &&
+                typeof entry.message === "string" &&
+                entry.message) {
+                warnings.push(entry.message);
+            }
+        }
+    }
+    return warnings;
+}
+// Appends a non-blocking warning section to existing tool output text.
+// Returns `text` unchanged (byte-for-byte) when `warnings` is empty.
+export function appendBackendWarningsToText(text, warnings) {
+    if (!warnings.length) {
+        return text;
+    }
+    return `${text}\n\n**Warning:** ${warnings.join(" ")}`;
+}

package/build/claude-settings.js

@@ -0,0 +1,129 @@
+/**
+ * Generic, conductor-independent `.claude/settings.local.json` merge machinery
+ * (BAPI-534).
+ *
+ * Extracted from `start-tickets-conductor.ts` so both the conductor hook
+ * provisioning and the Epic Conductor v2 executor deny-layer provisioning share
+ * ONE malformed-safe read/merge/write implementation. `start-tickets-conductor.ts`
+ * re-implements `mergeClaudeSettingsWithConductorHook` /
+ * `provisionConductorHookForWorktree` as thin wrappers over these helpers,
+ * preserving their exported signatures and pinned behavior.
+ *
+ * Discipline preserved verbatim from the original:
+ *  - a missing settings file is treated as `{}`;
+ *  - a malformed / non-object settings file is NEVER clobbered (returns a
+ *    `malformed` result and does not write);
+ *  - the merged object is written pretty-printed (2-space indent) with a single
+ *    trailing newline;
+ *  - error strings are generic and never echo file contents.
+ */
+import path from "node:path";
+/** Broad matcher used for `PreToolUse` when no existing matcher is present. */
+export const DEFAULT_PRE_TOOL_USE_MATCHER = "*";
+function asHookEntries(value) {
+    return Array.isArray(value) ? value : [];
+}
+/** Does this event already register `command` as a command hook? */
+function entriesContainCommand(entries, command) {
+    return entries.some((entry) => Array.isArray(entry?.hooks) &&
+        entry.hooks.some((h) => h && h.type === "command" && h.command === command));
+}
+/** Detect an existing PreToolUse matcher to mirror, if any. */
+export function detectExistingPreToolUseMatcher(settings) {
+    const hooks = settings.hooks;
+    if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks))
+        return undefined;
+    const entries = asHookEntries(hooks.PreToolUse);
+    for (const entry of entries) {
+        if (typeof entry?.matcher === "string")
+            return entry.matcher;
+    }
+    return undefined;
+}
+/**
+ * Merge a command hook into an existing Claude settings object across `events`
+ * (plus `PreToolUse` when `enablePreToolUse` is true) WITHOUT removing any
+ * existing settings or hooks. Idempotent: re-applying the same command never
+ * duplicates an entry. `PreToolUse` mirrors any existing matcher style.
+ */
+export function mergeClaudeSettingsWithCommandHook(settings, command, events, options = {}) {
+    const existingHooks = settings.hooks !== null && typeof settings.hooks === "object" && !Array.isArray(settings.hooks)
+        ? settings.hooks
+        : {};
+    const hooks = { ...existingHooks };
+    const allEvents = [...events];
+    if (options.enablePreToolUse && !allEvents.includes("PreToolUse")) {
+        allEvents.push("PreToolUse");
+    }
+    for (const event of allEvents) {
+        const entries = asHookEntries(hooks[event]);
+        if (entriesContainCommand(entries, command)) {
+            // Idempotent: already registered for this event.
+            hooks[event] = entries;
+            continue;
+        }
+        const newEntry = { hooks: [{ type: "command", command }] };
+        if (event === "PreToolUse") {
+            // Explicit matcher wins; else mirror any existing PreToolUse matcher; else
+            // fall back to the broad default.
+            newEntry.matcher =
+                options.preToolUseMatcher ??
+                    detectExistingPreToolUseMatcher(settings) ??
+                    DEFAULT_PRE_TOOL_USE_MATCHER;
+        }
+        hooks[event] = [...entries, newEntry];
+    }
+    return { ...settings, hooks };
+}
+/**
+ * Provision (merge into) ONE worktree's `.claude/settings.local.json`. Missing
+ * settings are treated as `{}`; malformed JSON is a safety stop (the file is
+ * never overwritten). `mergeSettings` receives the parsed existing object (or
+ * `{}`) and returns the object to write. Writes pretty-printed JSON with a
+ * trailing newline.
+ */
+export async function provisionClaudeSettingsForWorktree(worktreePath, mergeSettings, deps) {
+    const claudeDir = path.join(worktreePath, ".claude");
+    const settingsPath = path.join(claudeDir, "settings.local.json");
+    let existing = {};
+    let raw = null;
+    try {
+        raw = await deps.readFile(settingsPath);
+    }
+    catch {
+        // Missing file -> treat as empty settings.
+        raw = null;
+    }
+    if (raw !== null) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return {
+                    ok: false,
+                    reason: "malformed",
+                    error: "existing .claude/settings.local.json is not a JSON object",
+                };
+            }
+            existing = parsed;
+        }
+        catch {
+            // Malformed JSON: fail rather than clobber the user's file. The error is
+            // generic — it never echoes the file contents.
+            return {
+                ok: false,
+                reason: "malformed",
+                error: "existing .claude/settings.local.json contains invalid JSON",
+            };
+        }
+    }
+    const merged = mergeSettings(existing);
+    try {
+        await deps.mkdir(claudeDir, { recursive: true });
+        await deps.writeFile(settingsPath, `${JSON.stringify(merged, null, 2)}\n`);
+    }
+    catch {
+        // Best-effort: a write/mkdir failure must not block the actual work.
+        return { ok: false, reason: "io", error: "failed to write .claude/settings.local.json" };
+    }
+    return { ok: true };
+}