@structured-vibe-coding/core 0.20.0 → 0.22.0

package/dist/{agents-YN3Z3VOH.js → agents-EDCIINXG.js}

@@ -26,10 +26,11 @@ import {
   renderProtocolMd,
   renderThinAgent,
   writeAgentHandoff
-} from "./chunk-O4OQWVC7.js";
-import "./chunk-HUSXETPS.js";
+} from "./chunk-WCYVBZC4.js";
+import "./chunk-QE6RMJUS.js";
 import "./chunk-TNWFMRIA.js";
-import "./chunk-MHODNFIL.js";
+import "./chunk-47GWMUCR.js";
+import "./chunk-4BRO7BOJ.js";
 import "./chunk-O5SP6X5R.js";
 export {
   AGENT_INTEGRATIONS,

package/dist/chunk-47GWMUCR.js

@@ -0,0 +1,153 @@
+import {
+  interpolate
+} from "./chunk-4BRO7BOJ.js";
+
+// src/errors.ts
+var SddError = class extends Error {
+  code;
+  hint;
+  exitCode;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "SddError";
+    this.code = options?.code ?? "SDD_ERROR";
+    this.hint = options?.hint;
+    this.exitCode = options?.exitCode ?? 1;
+  }
+};
+function isSddError(err) {
+  return err instanceof SddError;
+}
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/env.ts
+function toProcessEnv(base, extra) {
+  const out = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (v !== void 0) out[k] = String(v);
+  }
+  if (extra) {
+    for (const [k, v] of Object.entries(extra)) {
+      if (v !== void 0) out[k] = String(v);
+    }
+  }
+  return out;
+}
+
+// src/version.ts
+var SDD_CORE_VERSION = "0.22.0" ? "0.22.0" : "0.0.0-dev";
+
+// src/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function mcpTimeoutMs() {
+  const raw = process.env.SDD_MCP_TIMEOUT_MS;
+  if (raw) {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return 3e4;
+}
+function contentToText(result) {
+  const parts = result.content ?? [];
+  return parts.map((p) => p.type === "text" ? p.text ?? "" : JSON.stringify(p)).join("\n").trim();
+}
+async function withTimeout(promise, ms, label) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new SddError(`MCP ${label} timed out after ${ms}ms`, {
+              code: "MCP_TIMEOUT",
+              hint: "Raise SDD_MCP_TIMEOUT_MS or fix the source server."
+            })
+          );
+        }, ms);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function withMcpSource(source, projectRoot, fn) {
+  const vars = { projectRoot };
+  const cwd = source.cwd ? interpolate(source.cwd, vars) : projectRoot;
+  const env = toProcessEnv(process.env, {
+    ...source.env,
+    SDD_PROJECT_ROOT: projectRoot
+  });
+  const transport = new StdioClientTransport({
+    command: source.command,
+    args: source.args,
+    cwd,
+    env
+  });
+  const client = new Client({
+    name: "sdd-mcp-client",
+    version: SDD_CORE_VERSION
+  });
+  const ms = mcpTimeoutMs();
+  await withTimeout(client.connect(transport), ms, `connect (${source.id})`);
+  try {
+    return await withTimeout(fn(client), ms, `call (${source.id})`);
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+async function listMcpSourceTools(source, projectRoot) {
+  return withMcpSource(source, projectRoot, async (client) => {
+    const listed = await client.listTools();
+    return listed.tools.map((t) => ({
+      name: t.name,
+      description: t.description
+    }));
+  });
+}
+async function callMcpSourceTool(source, projectRoot, tool, args) {
+  try {
+    if (source.tools?.length && !source.tools.includes(tool)) {
+      return {
+        ok: false,
+        text: "",
+        error: `Tool "${tool}" not in allowlist for source ${source.id}: ${source.tools.join(", ")}`
+      };
+    }
+    return await withMcpSource(source, projectRoot, async (client) => {
+      const result = await client.callTool({ name: tool, arguments: args });
+      const text = contentToText(result);
+      const isError = Boolean(result.isError);
+      return {
+        ok: !isError,
+        text: text || (isError ? "(empty error result)" : "(empty)"),
+        error: isError ? text || "tool returned isError" : void 0
+      };
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      text: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+export {
+  SddError,
+  isSddError,
+  errorMessage,
+  toProcessEnv,
+  SDD_CORE_VERSION,
+  mcpTimeoutMs,
+  withMcpSource,
+  listMcpSourceTools,
+  callMcpSourceTool
+};

package/dist/{chunk-HUSXETPS.js → chunk-QE6RMJUS.js}

@@ -6,8 +6,13 @@ import {
   shouldAutoSkip
 } from "./chunk-TNWFMRIA.js";
 import {
-  SddError
-} from "./chunk-MHODNFIL.js";
+  SddError,
+  callMcpSourceTool,
+  mcpTimeoutMs
+} from "./chunk-47GWMUCR.js";
+import {
+  loadMcpConfig
+} from "./chunk-4BRO7BOJ.js";
 import {
   activePointerPath,
   changesPathRel,
@@ -196,7 +201,9 @@ var SearchConfigSchema = z.object({
   k: z.number().int().min(1).max(100).default(20),
   embeddings: z.boolean().default(false),
   budgets: BudgetSchema.default({ default: 12e3 }),
-  exclude: z.array(z.string().min(1)).default([])
+  exclude: z.array(z.string().min(1)).default([]),
+  mcp_source: z.string().min(1).optional(),
+  mcp_tool: z.string().min(1).optional()
 });
 function budgetForStage(config, stage) {
   if (!stage) return config.budgets.default;
@@ -221,22 +228,13 @@ async function loadSearchConfig(projectRoot) {
 
 // src/search/pack.ts
 var EN_DASH = "\u2013";
-function searchPreamble(query, scope, budget, hybrid = false) {
-  if (hybrid) {
-    return `# Search
-Query: ${query}
-Scope: ${scope}
-Provider: builtin
-Mode: hybrid
-Budget: ${budget}
-
-`;
-  }
+function searchPreamble(query, scope, budget, hybrid = false, provider = "builtin") {
+  const mode = hybrid ? "Mode: hybrid\n" : "";
   return `# Search
 Query: ${query}
 Scope: ${scope}
-Provider: builtin
-Budget: ${budget}
+Provider: ${provider}
+${mode}Budget: ${budget}
 
 `;
 }
@@ -2331,6 +2329,173 @@ async function searchProject(projectRoot, query, options, runtime) {
   };
 }
 
+// src/search/mcp-provider.ts
+var McpSearchError = class extends Error {
+  constructor() {
+    super("Search provider is unavailable.");
+    this.name = "McpSearchError";
+  }
+};
+function emptyStats(considered = 0, reindexed = 0) {
+  return {
+    provider: "mcp",
+    files: 0,
+    chunks: 0,
+    lastIndexFilesConsidered: considered,
+    lastIndexFilesReindexed: reindexed,
+    lastIndexChunksReindexed: 0,
+    lastIndexChunksEmbedded: 0,
+    indexedCommit: null
+  };
+}
+function isSafeRelativePath(path) {
+  if (!path || path.startsWith("/") || path.startsWith("\\")) return false;
+  if (path.length >= 2 && path.charCodeAt(1) === 58) {
+    const c = path.charCodeAt(0);
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) return false;
+  }
+  const parts = path.replaceAll("\\", "/").split("/");
+  for (const part of parts) {
+    if (part.length === 0 || part === "." || part === "..") return false;
+  }
+  return true;
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new McpSearchError()), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      () => {
+        clearTimeout(timer);
+        reject(new McpSearchError());
+      }
+    );
+  });
+}
+function allowedPaths(paths, exclude) {
+  const kept = [];
+  for (const raw of paths) {
+    const path = raw.replaceAll("\\", "/");
+    if (!isSafeRelativePath(path) || exclude(path)) continue;
+    kept.push(path);
+  }
+  return kept;
+}
+function positive(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) return void 0;
+  return value;
+}
+function firstLine(body) {
+  const nl = body.indexOf("\n");
+  return nl === -1 ? body : body.slice(0, nl);
+}
+function asHit(value, scope, exclude) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const rec = value;
+  if (typeof rec.path !== "string") return void 0;
+  const path = rec.path.replaceAll("\\", "/");
+  if (!isSafeRelativePath(path) || exclude(path)) return void 0;
+  const startLine2 = positive(rec.startLine);
+  const endLine2 = positive(rec.endLine);
+  if (startLine2 === void 0 || endLine2 === void 0 || endLine2 < startLine2) return void 0;
+  if (typeof rec.symbol !== "string") return void 0;
+  const symbol = rec.symbol.trim();
+  if (!symbol || typeof rec.body !== "string") return void 0;
+  const signature = typeof rec.signature === "string" ? rec.signature : firstLine(rec.body);
+  const language = typeof rec.language === "string" ? rec.language : "";
+  const score = typeof rec.score === "number" && Number.isFinite(rec.score) ? rec.score : 0;
+  return { scope, path, startLine: startLine2, endLine: endLine2, symbol, score, signature, body: rec.body, language };
+}
+function parseHits(text, scope, exclude) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new McpSearchError();
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new McpSearchError();
+  const hits = parsed.hits;
+  if (!Array.isArray(hits)) throw new McpSearchError();
+  const out = [];
+  for (const hit of hits) {
+    const row = asHit(hit, scope, exclude);
+    if (row) out.push(row);
+  }
+  return out;
+}
+async function connect(input) {
+  const exclude = await loadExcluder(input.projectRoot, input.search.exclude);
+  let sources = [];
+  try {
+    const cfg = await loadMcpConfig(input.projectRoot);
+    sources = cfg.sources.filter((source2) => source2.enabled);
+  } catch {
+    throw new McpSearchError();
+  }
+  const named = input.search.mcp_source;
+  const source = named ? sources.find((item) => item.id === named) : sources.length === 1 ? sources[0] : void 0;
+  if (!source) throw new McpSearchError();
+  const tool = input.search.mcp_tool || source.invoke?.tool;
+  if (!tool) throw new McpSearchError();
+  if (source.tools?.length && !source.tools.includes(tool)) throw new McpSearchError();
+  const call = input.call ?? (async (req) => {
+    const result = await callMcpSourceTool(source, input.projectRoot, req.tool, req.args);
+    return { ok: result.ok, text: result.text };
+  });
+  return { sourceId: source.id, tool, exclude, call };
+}
+function openMcpSearchProvider(input) {
+  const timeoutMs = input.timeoutMs ?? mcpTimeoutMs();
+  let ready3;
+  async function load() {
+    if (ready3) return ready3;
+    ready3 = await connect(input);
+    return ready3;
+  }
+  return {
+    id: "mcp",
+    async index(changed) {
+      const session = await load();
+      if (!changed) return emptyStats();
+      const paths = allowedPaths(changed, session.exclude);
+      if (paths.length === 0) return emptyStats(changed.length);
+      const result = await withTimeout(
+        session.call({ sourceId: session.sourceId, tool: session.tool, args: { paths } }),
+        timeoutMs
+      );
+      if (!result.ok) throw new McpSearchError();
+      return emptyStats(changed.length, paths.length);
+    },
+    async search(query, options) {
+      const session = await load();
+      const args = { query, scope: options.scope };
+      const result = await withTimeout(
+        session.call({ sourceId: session.sourceId, tool: session.tool, args }),
+        timeoutMs
+      );
+      if (!result.ok) throw new McpSearchError();
+      const hits = parseHits(result.text, options.scope, session.exclude);
+      const preamble = searchPreamble(query, options.scope, options.budget, false, "mcp");
+      const packed = packHits({ preamble, hits, budget: options.budget });
+      return {
+        provider: "mcp",
+        query,
+        scope: options.scope,
+        budget: options.budget,
+        usedTokens: packed.usedTokens,
+        hits: packed.hits,
+        text: packed.text
+      };
+    },
+    stats() {
+      return Promise.resolve(emptyStats());
+    }
+  };
+}
+
 // src/search/registry.ts
 var extra = /* @__PURE__ */ new Map();
 function registerSearchProvider(provider) {
@@ -2347,13 +2512,18 @@ function joinWarning(left, right) {
 ${right}`;
   return left || right;
 }
-function resolveSearchProvider(projectRoot, config, search, runtime) {
+function resolveSearchProvider(projectRoot, config, search, runtime, run) {
   const builtin = createBuiltinProvider(projectRoot, config, runtime);
   const name = search.provider || "builtin";
   if (name === "builtin") return builtin;
   const registered = extra.get(name);
-  let active = registered ?? builtin;
-  let warning = registered ? void 0 : fallbackWarning(name);
+  let active = name === "mcp" ? openMcpSearchProvider({
+    projectRoot,
+    search,
+    call: run?.mcpCall,
+    timeoutMs: run?.mcpTimeoutMs
+  }) : registered ?? builtin;
+  let warning = name === "mcp" || registered ? void 0 : fallbackWarning(name);
   const mark = () => {
     warning = fallbackWarning(name);
     active = builtin;
@@ -2373,7 +2543,6 @@ function resolveSearchProvider(projectRoot, config, search, runtime) {
       try {
         const result = await active.search(query, options);
         result.warning = joinWarning(warning, result.warning);
-        result.provider = "builtin";
         return result;
       } catch (err) {
         if (active.id === "builtin") throw err;
@@ -2404,12 +2573,11 @@ async function buildRetrievedInner(projectRoot, config, title, stage, budget, ru
     return `Retrieved context skipped: ${safeMessage(err, projectRoot)}.`;
   }
   const limit = budget ?? budgetForStage(search, stage);
-  const provider = resolveSearchProvider(projectRoot, config, search, runtime);
+  const provider = createBuiltinProvider(projectRoot, config, runtime);
   try {
     await provider.index();
   } catch (err) {
-    const message = provider.id === "builtin" ? safeMessage(err, projectRoot) : fallbackWarning(search.provider);
-    return `Retrieved context skipped: ${message}.`;
+    return `Retrieved context skipped: ${safeMessage(err, projectRoot)}.`;
   }
   const request = {
     projectRoot,
@@ -2456,13 +2624,12 @@ async function buildRetrievedInner(projectRoot, config, title, stage, budget, ru
     }
     return packed.text;
   } catch (err) {
-    const message = search.provider === "builtin" ? safeMessage(err, projectRoot) : fallbackWarning(search.provider);
-    return `Retrieved context skipped: ${message}.`;
+    return `Retrieved context skipped: ${safeMessage(err, projectRoot)}.`;
   }
 }
-async function executeSearch(projectRoot, config, query, scope, budget) {
+async function executeSearch(projectRoot, config, query, scope, budget, run) {
   const search = await loadSearchConfig(projectRoot);
-  const provider = resolveSearchProvider(projectRoot, config, search);
+  const provider = resolveSearchProvider(projectRoot, config, search, void 0, run);
   await provider.index();
   const options = {
     scope,
@@ -2668,7 +2835,7 @@ function stringList(value) {
   }
   return out;
 }
-function parseRoleDocument(name, raw) {
+function splitFrontmatter(raw) {
   const text = raw.replace(/^\uFEFF/, "");
   const nl = text.indexOf("\n");
   if (nl < 0 || text.slice(0, nl).trim() !== "---") return null;
@@ -2682,14 +2849,22 @@ function parseRoleDocument(name, raw) {
     return null;
   }
   if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-  const rec = data;
+  return {
+    data,
+    body: rest.slice(close.index + close[0].length).trim()
+  };
+}
+function parseRoleDocument(name, raw) {
+  const split = splitFrontmatter(raw);
+  if (!split) return null;
+  const rec = split.data;
   const lists = emptyRoleLists();
   for (const [field2, key] of LIST_FIELDS) {
     const parsed = stringList(rec[key]);
     if (!parsed) return null;
     lists[field2] = parsed;
   }
-  const body = rest.slice(close.index + close[0].length).trim();
+  const body = split.body;
   return {
     name,
     label: asText(rec.label),
@@ -2701,7 +2876,7 @@ function parseRoleDocument(name, raw) {
     ...lists
   };
 }
-function renderRole(role) {
+function renderRole(role, routines) {
   const record = {
     name: role.name,
     label: role.label,
@@ -2710,6 +2885,7 @@ function renderRole(role) {
     pinned: role.pinned,
     hidden: role.hidden
   };
+  if (routines?.keep) record.routines = routines.value;
   for (const [field2, key] of LIST_FIELDS) {
     if (role[field2].length > 0) record[key] = role[field2];
   }
@@ -2748,8 +2924,15 @@ async function readRole(root, name) {
     return null;
   }
 }
-async function writeRole(root, role) {
-  await writeText(roleFilePath(root, role.name), renderRole(role));
+async function keptRoutines(root, name) {
+  const path = roleFilePath(root, name);
+  if (!await pathExists(path)) return void 0;
+  const split = splitFrontmatter(await readText(path));
+  if (!split || !Object.hasOwn(split.data, "routines")) return void 0;
+  return { keep: true, value: split.data.routines };
+}
+async function writeRole(root, role, routines) {
+  await writeText(roleFilePath(root, role.name), renderRole(role, routines));
 }
 async function createRole(root, input) {
   const name = canonicalRoleName(input.name);
@@ -2784,7 +2967,7 @@ async function editRole(root, nameInput, patch) {
   if (patch.description !== void 0) role.description = patch.description.trim();
   if (patch.askFirst !== void 0) role.askFirst = patch.askFirst;
   if (patch.stages !== void 0) role.stages = patch.stages;
-  await writeRole(root, role);
+  await writeRole(root, role, await keptRoutines(root, name));
   return ok();
 }
 async function setFlag(root, nameInput, flag) {
@@ -2793,7 +2976,7 @@ async function setFlag(root, nameInput, flag) {
   const role = await readRole(root, name);
   if (!role) return fail(ROLE_TEXT.notFound);
   role[flag] = true;
-  await writeRole(root, role);
+  await writeRole(root, role, await keptRoutines(root, name));
   return ok();
 }
 function pinRole(root, name) {
@@ -2836,7 +3019,7 @@ async function duplicateRole(root, nameInput) {
   const copyName = canonicalRoleName(`${name} copy`);
   if (!copyName) return fail(ROLE_TEXT.badName);
   if (await pathExists(roleFilePath(root, copyName))) return fail(ROLE_TEXT.exists);
-  await writeRole(root, { ...source, name: copyName });
+  await writeRole(root, { ...source, name: copyName }, await keptRoutines(root, name));
   return ok();
 }
 async function deleteRole(root, nameInput) {
@@ -3321,9 +3504,9 @@ async function buildAgentPrompt(ctx, config, projectRoot, budget, runtime) {
     parts.push("");
   }
   try {
-    const { loadMcpConfig } = await import("./sources-3TXUPU6V.js");
-    const { gatherMcpContextForChange, formatMcpContextForHandoff } = await import("./gather-ZKVMJW5L.js");
-    const mcpCfg = await loadMcpConfig(projectRoot);
+    const { loadMcpConfig: loadMcpConfig2 } = await import("./sources-3TXUPU6V.js");
+    const { gatherMcpContextForChange, formatMcpContextForHandoff } = await import("./gather-ZK722X65.js");
+    const mcpCfg = await loadMcpConfig2(projectRoot);
     if (mcpCfg.auto_fetch_on_handoff && mcpCfg.sources.length) {
       const fetched = await gatherMcpContextForChange(projectRoot, ctx);
       const block = formatMcpContextForHandoff(fetched.filter((r) => r.ok || r.error));
@@ -3414,6 +3597,7 @@ export {
   listScopeHits,
   rankScope,
   searchProject,
+  openMcpSearchProvider,
   registerSearchProvider,
   clearRegisteredSearchProviders,
   fallbackWarning,
@@ -3429,6 +3613,7 @@ export {
   conversationDir,
   memoryDir,
   allowFilePath,
+  splitFrontmatter,
   parseRoleDocument,
   rolesListingStage,
   readRole,