codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/budget-service.js

@@ -0,0 +1,528 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var budget_service_exports = {};
+__export(budget_service_exports, {
+  OPEN_TURN_FLUSH_MS: () => OPEN_TURN_FLUSH_MS,
+  TURN_GAP_MS: () => import_turn_gap.TURN_GAP_MS,
+  WARN_AT: () => WARN_AT,
+  acknowledgeBudgetChange: () => acknowledgeBudgetChange,
+  budgetState: () => budgetState,
+  checkBudget: () => checkBudget,
+  closeTurn: () => closeTurn,
+  flaggedBudgetChanges: () => flaggedBudgetChanges,
+  flushIdleTurns: () => flushIdleTurns,
+  forecast: () => forecast,
+  getBudget: () => getBudget,
+  getBudgetReport: () => getBudgetReport,
+  getUnattributedTokenReports: () => getUnattributedTokenReports,
+  isFlaggedActor: () => isFlaggedActor,
+  isTurnClosed: () => isTurnClosed,
+  listBudgetChanges: () => listBudgetChanges,
+  listOpenTurns: () => listOpenTurns,
+  markBudgetNotified: () => markBudgetNotified,
+  minutesBetween: () => minutesBetween,
+  noteItemFocus: () => noteItemFocus,
+  recordActivity: () => recordActivity,
+  recordTokens: () => recordTokens,
+  resetBudgetState: () => resetBudgetState,
+  runBudgetSweep: () => runBudgetSweep,
+  setBudget: () => setBudget,
+  startBudgetSweep: () => startBudgetSweep,
+  stopBudgetSweep: () => stopBudgetSweep
+});
+module.exports = __toCommonJS(budget_service_exports);
+var import_database = require("./database");
+var import_turn_gap = require("../../shared/lib/turn-gap");
+var import_persistence = require("./persistence");
+var import_pricing = require("./pricing");
+const OPEN_TURN_FLUSH_MS = 2 * 6e4;
+const WARN_AT = 0.8;
+function isFlaggedActor(actorType) {
+  return actorType !== "human";
+}
+function isTurnClosed(turn, now, gapMs = import_turn_gap.TURN_GAP_MS) {
+  return now - turn.lastActivityAt > gapMs;
+}
+function forecast(spent, completionRatio, floor = 0.1) {
+  if (spent <= 0) return null;
+  if (completionRatio === null || completionRatio < floor) return null;
+  if (completionRatio >= 1) return spent;
+  return spent / completionRatio;
+}
+function budgetState(report) {
+  const b = report.budget;
+  if (!b || b.minutes === null && b.costUsd === null) return "none";
+  if (b.exempt) return "exempt";
+  const fractions = [];
+  if (b.minutes !== null && b.minutes > 0) fractions.push(report.spentMinutes / b.minutes);
+  if (b.costUsd !== null && b.costUsd > 0 && report.spentCostUsd !== null) {
+    fractions.push(report.spentCostUsd / b.costUsd);
+  }
+  if (fractions.length === 0) return "none";
+  const worst = Math.max(...fractions);
+  if (worst >= 1) return "over";
+  if (worst >= WARN_AT) return "warn";
+  return "ok";
+}
+function minutesBetween(startedAt, endedAt) {
+  return Math.max(0, endedAt - startedAt) / 6e4;
+}
+const openTurns = /* @__PURE__ */ new Map();
+let unattributedTokenReports = 0;
+function getUnattributedTokenReports() {
+  return unattributedTokenReports;
+}
+function resetBudgetState() {
+  openTurns.clear();
+  unattributedTokenReports = 0;
+}
+function listOpenTurns() {
+  return [...openTurns.values()];
+}
+function emptyTokens() {
+  return { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 };
+}
+function recordActivity(params) {
+  const now = params.timestamp ?? Date.now();
+  const existing = openTurns.get(params.sessionId);
+  if (existing && !isTurnClosed(existing, now)) {
+    existing.lastActivityAt = now;
+    if (params.planUid) existing.planUid = params.planUid;
+    if (params.itemUid) existing.itemUid = params.itemUid;
+    if (params.agentType) existing.agentType = params.agentType;
+    if (params.agentModel) existing.agentModel = params.agentModel;
+    return;
+  }
+  if (existing) closeTurn(params.sessionId, existing.lastActivityAt);
+  openTurns.set(params.sessionId, {
+    sessionId: params.sessionId,
+    planUid: params.planUid ?? null,
+    itemUid: params.itemUid ?? null,
+    agentType: params.agentType ?? null,
+    agentModel: params.agentModel ?? null,
+    startedAt: now,
+    lastActivityAt: now,
+    tokens: emptyTokens()
+  });
+}
+function noteItemFocus(sessionId, itemUid, planUid) {
+  const turn = openTurns.get(sessionId);
+  if (!turn) return;
+  turn.itemUid = itemUid;
+  if (planUid) turn.planUid = planUid;
+}
+function recordTokens(params) {
+  const turn = openTurns.get(params.sessionId);
+  if (!turn) {
+    unattributedTokenReports += 1;
+    return;
+  }
+  turn.tokens.inputTokens += params.tokens.inputTokens ?? 0;
+  turn.tokens.outputTokens += params.tokens.outputTokens ?? 0;
+  turn.tokens.cacheWriteTokens = (turn.tokens.cacheWriteTokens ?? 0) + (params.tokens.cacheWriteTokens ?? 0);
+  turn.tokens.cacheReadTokens = (turn.tokens.cacheReadTokens ?? 0) + (params.tokens.cacheReadTokens ?? 0);
+  if (params.model) turn.agentModel = params.model;
+}
+function closeTurn(sessionId, endedAt) {
+  const turn = openTurns.get(sessionId);
+  if (!turn) return null;
+  openTurns.delete(sessionId);
+  if (!turn.planUid) return null;
+  const entry = {
+    planUid: turn.planUid,
+    itemUid: turn.itemUid,
+    sessionId: turn.sessionId,
+    agentType: turn.agentType,
+    agentModel: turn.agentModel,
+    startedAt: turn.startedAt,
+    endedAt: endedAt ?? turn.lastActivityAt,
+    tokens: turn.tokens,
+    costUsd: (0, import_pricing.costOf)(turn.agentModel, turn.tokens)
+  };
+  persistEntry(entry);
+  return entry;
+}
+function flushIdleTurns(now = Date.now()) {
+  const flushed = [];
+  for (const [sessionId, turn] of [...openTurns.entries()]) {
+    if (now - turn.lastActivityAt > OPEN_TURN_FLUSH_MS) {
+      const entry = closeTurn(sessionId, turn.lastActivityAt);
+      if (entry) flushed.push(entry);
+    }
+  }
+  return flushed;
+}
+function persistEntry(entry) {
+  try {
+    const db = (0, import_database.getDb)();
+    db.run(
+      `INSERT INTO item_time_entries
+         (plan_uid, item_uid, session_id, agent_type, agent_model, started_at, ended_at,
+          input_tokens, output_tokens, cache_write_tokens, cache_read_tokens, cost_usd, pricing_version)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entry.planUid,
+        entry.itemUid,
+        entry.sessionId,
+        entry.agentType,
+        entry.agentModel,
+        entry.startedAt,
+        entry.endedAt,
+        entry.tokens.inputTokens,
+        entry.tokens.outputTokens,
+        entry.tokens.cacheWriteTokens ?? 0,
+        entry.tokens.cacheReadTokens ?? 0,
+        entry.costUsd,
+        import_pricing.PRICING_VERSION
+      ]
+    );
+    (0, import_persistence.markDirty)();
+  } catch (err) {
+    console.warn("[Budget] Failed to persist a time entry:", err);
+  }
+}
+function getBudget(planUid) {
+  try {
+    const db = (0, import_database.getDb)();
+    const res = db.exec(
+      `SELECT plan_uid, minutes, cost_usd, exempt, notified_at FROM plan_budgets WHERE plan_uid = ?`,
+      [planUid]
+    );
+    const row = res[0]?.values[0];
+    if (!row) return null;
+    return {
+      planUid: row[0],
+      minutes: row[1] ?? null,
+      costUsd: row[2] ?? null,
+      exempt: Boolean(row[3]),
+      notifiedAt: row[4] ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function setBudget(params) {
+  const db = (0, import_database.getDb)();
+  const existing = getBudget(params.planUid);
+  const next = {
+    planUid: params.planUid,
+    minutes: params.minutes !== void 0 ? params.minutes : existing?.minutes ?? null,
+    costUsd: params.costUsd !== void 0 ? params.costUsd : existing?.costUsd ?? null,
+    exempt: params.exempt !== void 0 ? params.exempt : existing?.exempt ?? false,
+    // Raising a ceiling clears the warning watermark, so the next 80%
+    // crossing warns again rather than staying silent forever.
+    notifiedAt: null
+  };
+  db.run(
+    `INSERT INTO plan_budgets (plan_uid, minutes, cost_usd, exempt, notified_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(plan_uid) DO UPDATE SET
+       minutes = excluded.minutes,
+       cost_usd = excluded.cost_usd,
+       exempt = excluded.exempt,
+       notified_at = excluded.notified_at,
+       updated_at = excluded.updated_at`,
+    [next.planUid, next.minutes, next.costUsd, next.exempt ? 1 : 0, null, Date.now()]
+  );
+  const ceiling = (b) => ({ minutes: b.minutes, costUsd: b.costUsd, exempt: b.exempt });
+  const before = existing ? ceiling(existing) : null;
+  const after = ceiling(next);
+  if (params.by && JSON.stringify(before) !== JSON.stringify(after)) {
+    db.run(
+      `INSERT INTO plan_budget_changes (plan_uid, actor, actor_type, channel, before_json, after_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        next.planUid,
+        params.by.actor,
+        params.by.actorType,
+        params.by.channel,
+        before ? JSON.stringify(before) : null,
+        JSON.stringify(after),
+        Date.now()
+      ]
+    );
+  }
+  (0, import_persistence.markDirty)();
+  return next;
+}
+function toChange(r) {
+  const actorType = r[3];
+  const acknowledgedAt = r[8] ?? null;
+  return {
+    id: r[0],
+    planUid: r[1],
+    actor: r[2],
+    actorType,
+    channel: r[4],
+    before: r[5] ? JSON.parse(r[5]) : null,
+    after: JSON.parse(r[6]),
+    at: r[7],
+    flagged: isFlaggedActor(actorType) && acknowledgedAt === null,
+    acknowledgedAt,
+    acknowledgedBy: r[9] ?? null
+  };
+}
+const CHANGE_COLUMNS = "id, plan_uid, actor, actor_type, channel, before_json, after_json, created_at, acknowledged_at, acknowledged_by";
+function listBudgetChanges(planUid, limit = 50) {
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT ${CHANGE_COLUMNS} FROM plan_budget_changes WHERE plan_uid = ? ORDER BY created_at DESC, id DESC LIMIT ?`,
+      [planUid, limit]
+    );
+    return (res[0]?.values ?? []).map(toChange);
+  } catch {
+    return [];
+  }
+}
+function flaggedBudgetChanges(planUid) {
+  return listBudgetChanges(planUid, 500).filter((c) => c.flagged).reverse();
+}
+function acknowledgeBudgetChange(planUid, id, by) {
+  const db = (0, import_database.getDb)();
+  db.run(
+    `UPDATE plan_budget_changes SET acknowledged_at = ?, acknowledged_by = ?
+     WHERE plan_uid = ? AND id = ? AND acknowledged_at IS NULL`,
+    [Date.now(), by, planUid, id]
+  );
+  (0, import_persistence.markDirty)();
+  const res = db.exec(`SELECT ${CHANGE_COLUMNS} FROM plan_budget_changes WHERE plan_uid = ? AND id = ?`, [planUid, id]);
+  const row = res[0]?.values[0];
+  return row ? toChange(row) : null;
+}
+function markBudgetNotified(planUid, at = Date.now()) {
+  try {
+    (0, import_database.getDb)().run(`UPDATE plan_budgets SET notified_at = ? WHERE plan_uid = ?`, [at, planUid]);
+    (0, import_persistence.markDirty)();
+  } catch {
+  }
+}
+function rollup(planUid) {
+  const out = {
+    spentMinutes: 0,
+    spentCostUsd: null,
+    byAgent: /* @__PURE__ */ new Map(),
+    byItem: /* @__PURE__ */ new Map(),
+    pricingVersions: /* @__PURE__ */ new Set()
+  };
+  let res;
+  try {
+    res = (0, import_database.getDb)().exec(
+      `SELECT item_uid, agent_type, started_at, ended_at, cost_usd, pricing_version
+       FROM item_time_entries WHERE plan_uid = ?`,
+      [planUid]
+    );
+  } catch {
+    return out;
+  }
+  for (const row of res[0]?.values ?? []) {
+    const itemUid = row[0];
+    const agentType = row[1] ?? "unknown";
+    const minutes = minutesBetween(row[2], row[3]);
+    const cost = row[4];
+    const priced = row[5];
+    if (cost !== null && priced) out.pricingVersions.add(priced);
+    out.spentMinutes += minutes;
+    if (cost !== null) out.spentCostUsd = (out.spentCostUsd ?? 0) + cost;
+    const agent = out.byAgent.get(agentType) ?? { minutes: 0, costUsd: null };
+    agent.minutes += minutes;
+    if (cost !== null) agent.costUsd = (agent.costUsd ?? 0) + cost;
+    out.byAgent.set(agentType, agent);
+    if (itemUid) out.byItem.set(itemUid, (out.byItem.get(itemUid) ?? 0) + minutes);
+  }
+  return out;
+}
+function itemEstimates(planUid) {
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT uid, status, estimate_minutes, estimate_cost_usd FROM plan_items WHERE plan_uid = ?`,
+      [planUid]
+    );
+    return (res[0]?.values ?? []).map((r) => ({
+      uid: r[0],
+      status: r[1] ?? null,
+      estimateMinutes: r[2] ?? null,
+      estimateCostUsd: r[3] ?? null
+    }));
+  } catch {
+    return [];
+  }
+}
+function getBudgetReport(planUid) {
+  const spent = rollup(planUid);
+  const items = itemEstimates(planUid);
+  const estimateMinutes = items.reduce(
+    (acc, i) => i.estimateMinutes === null ? acc : (acc ?? 0) + i.estimateMinutes,
+    null
+  );
+  const estimateCostUsd = items.reduce(
+    (acc, i) => i.estimateCostUsd === null ? acc : (acc ?? 0) + i.estimateCostUsd,
+    null
+  );
+  const actionable = items.filter((i) => i.status !== null);
+  const resolved = actionable.filter((i) => i.status === "done" || i.status === "skipped").length;
+  const completionRatio = actionable.length > 0 ? resolved / actionable.length : null;
+  const pricingVersions = [...spent.pricingVersions].sort();
+  const overruns = items.filter((i) => i.estimateMinutes !== null && (spent.byItem.get(i.uid) ?? 0) > i.estimateMinutes).map((i) => ({
+    itemUid: i.uid,
+    estimateMinutes: i.estimateMinutes,
+    spentMinutes: spent.byItem.get(i.uid) ?? 0
+  })).sort((a, b) => b.spentMinutes - b.estimateMinutes - (a.spentMinutes - a.estimateMinutes));
+  return {
+    planUid,
+    budget: getBudget(planUid),
+    spentMinutes: spent.spentMinutes,
+    spentCostUsd: spent.spentCostUsd,
+    estimateMinutes,
+    estimateCostUsd,
+    forecastMinutes: forecast(spent.spentMinutes, completionRatio),
+    forecastCostUsd: spent.spentCostUsd === null ? null : forecast(spent.spentCostUsd, completionRatio),
+    completionRatio,
+    byAgent: [...spent.byAgent.entries()].map(([agentType, v]) => ({ agentType, ...v })),
+    overruns,
+    // The version the TOTAL was priced under, not the one in force now.
+    // With nothing priced yet, the current table is the honest answer:
+    // it is what the next row will use.
+    pricingVersion: pricingVersions.length === 0 ? import_pricing.PRICING_VERSION : pricingVersions.length === 1 ? pricingVersions[0] : "mixed",
+    pricingVersions,
+    flaggedChanges: flaggedBudgetChanges(planUid)
+  };
+}
+function checkBudget(planUid) {
+  const report = getBudgetReport(planUid);
+  const state = budgetState(report);
+  switch (state) {
+    case "over":
+      return {
+        allowed: false,
+        state,
+        reason: "This plan is past its budget. Stop and ask the human to raise the ceiling or exempt the plan.",
+        report
+      };
+    case "warn":
+      return {
+        allowed: true,
+        state,
+        reason: "This plan is past 80% of its budget. Finish what is in flight; do not start more.",
+        report
+      };
+    case "exempt":
+      return { allowed: true, state, reason: "This plan is exempt from its budget.", report };
+    case "ok":
+      return { allowed: true, state, reason: "Within budget.", report };
+    default:
+      return { allowed: true, state, reason: "No budget set for this plan.", report };
+  }
+}
+let sweepTimer = null;
+function plansWithBudgets() {
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT plan_uid FROM plan_budgets WHERE (minutes IS NOT NULL OR cost_usd IS NOT NULL) AND exempt = 0`
+    );
+    return (res[0]?.values ?? []).map((r) => r[0]);
+  } catch {
+    return [];
+  }
+}
+async function runBudgetSweep(now = Date.now()) {
+  flushIdleTurns(now);
+  for (const planUid of plansWithBudgets()) {
+    try {
+      const report = getBudgetReport(planUid);
+      const state = budgetState(report);
+      if (state !== "warn" && state !== "over") continue;
+      if (report.budget?.notifiedAt) continue;
+      const spentCost = report.spentCostUsd;
+      const parts = [];
+      if (report.budget?.minutes) {
+        parts.push(`${report.spentMinutes.toFixed(0)}m of ${report.budget.minutes}m`);
+      }
+      if (report.budget?.costUsd && spentCost !== null) {
+        parts.push(`$${spentCost.toFixed(2)} of $${report.budget.costUsd.toFixed(2)}`);
+      }
+      const { postChannelEvent } = await Promise.resolve().then(() => __toESM(require("./channel-event-service")));
+      const { dispatchChannelEvent } = await Promise.resolve().then(() => __toESM(require("./channel-dispatcher-service")));
+      const event = postChannelEvent({
+        planUid,
+        eventType: "need-decision",
+        payload: {
+          message: state === "over" ? `This plan is over budget (${parts.join(", ")}). Raise the ceiling, exempt the plan, or stop.` : `This plan has passed 80% of its budget (${parts.join(", ")}).`
+        },
+        author: "codetrellis",
+        authorType: "system"
+      });
+      markBudgetNotified(planUid, now);
+      await dispatchChannelEvent(event);
+    } catch (err) {
+      console.warn(`[Budget] Sweep failed for plan ${planUid}:`, err);
+    }
+  }
+}
+function startBudgetSweep(intervalMs = 6e4) {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    void runBudgetSweep();
+  }, intervalMs);
+  sweepTimer.unref?.();
+}
+function stopBudgetSweep() {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OPEN_TURN_FLUSH_MS,
+  TURN_GAP_MS,
+  WARN_AT,
+  acknowledgeBudgetChange,
+  budgetState,
+  checkBudget,
+  closeTurn,
+  flaggedBudgetChanges,
+  flushIdleTurns,
+  forecast,
+  getBudget,
+  getBudgetReport,
+  getUnattributedTokenReports,
+  isFlaggedActor,
+  isTurnClosed,
+  listBudgetChanges,
+  listOpenTurns,
+  markBudgetNotified,
+  minutesBetween,
+  noteItemFocus,
+  recordActivity,
+  recordTokens,
+  resetBudgetState,
+  runBudgetSweep,
+  setBudget,
+  startBudgetSweep,
+  stopBudgetSweep
+});

package/src/backend/services/callsites/base.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+module.exports = __toCommonJS(base_exports);

package/src/backend/services/callsites/csharp.js

@@ -0,0 +1,148 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csharp_exports = {};
+__export(csharp_exports, {
+  csharpCallsites: () => csharpCallsites
+});
+module.exports = __toCommonJS(csharp_exports);
+var import_shared = require("./shared");
+const ROUTE_ATTR_RE = /\[\s*Route\s*\(\s*"([^"]*)"\s*\)\s*\]/;
+const CLASS_RE = /\b(?:class|record)\s+(\w+)/;
+const HTTP_ATTR_RE = /\[\s*Http(Get|Post|Put|Patch|Delete|Head|Options)\s*(?:\(\s*"([^"]*)"\s*\))?\s*\]/g;
+const METHOD_DECL_RE = /\b(?:public|internal|protected|private)\s+[\w<>,[\]?\s]*?\b(\w+)\s*\(/;
+const MAP_VERB_RE = /(\w+)\s*\.\s*Map(Get|Post|Put|Patch|Delete|Head|Options)\s*\(\s*"([^"]*)"/g;
+const MAP_METHODS_RE = /(\w+)\s*\.\s*MapMethods\s*\(\s*"([^"]*)"\s*,\s*[^)]*?\{([^}]*)\}/g;
+const MAP_GROUP_RE = /(?:var|\w[\w<>.]*)\s+(\w+)\s*=\s*(\w+)\s*\.\s*MapGroup\s*\(\s*"([^"]*)"/;
+const CLIENT_CALL_RE = /(\w+)\s*\.\s*((Get|Post|Put|Patch|Delete)(?:Async|FromJsonAsync|AsJsonAsync|StringAsync|ByteArrayAsync|StreamAsync))(?:<[^>]*>)?\s*\(\s*(?:new\s+Uri\s*\(\s*)?[$@]*"([^"]*)"/g;
+const REQUEST_MESSAGE_RE = /new\s+HttpRequestMessage\s*\(\s*HttpMethod\s*\.\s*(Get|Post|Put|Patch|Delete|Head|Options)\s*,\s*[$@]*"([^"]*)"/g;
+const REFIT_ATTR_RE = /\[\s*(?<!Http)(Get|Post|Put|Patch|Delete|Head|Options)\s*\(\s*"([^"]*)"\s*\)\s*\]/g;
+const csharpCallsites = {
+  language: "csharp",
+  extract(content, _filePath) {
+    return [...extractRoutes(content), ...extractOutbound(content)];
+  }
+};
+function controllerToken(className) {
+  return className.replace(/Controller$/, "").toLowerCase();
+}
+function expandTokens(pattern, className, actionName) {
+  let p = pattern;
+  if (className) p = p.replace(/\[controller\]/gi, controllerToken(className));
+  if (actionName) p = p.replace(/\[action\]/gi, actionName.toLowerCase());
+  return p;
+}
+function extractRoutes(content) {
+  const lines = content.split("\n").map((l) => (0, import_shared.stripLineComment)(l, "//"));
+  const out = [];
+  const groupPrefix = /* @__PURE__ */ new Map();
+  for (let sweep = 0; sweep < 2; sweep++) {
+    for (const line of lines) {
+      const m = MAP_GROUP_RE.exec(line);
+      if (!m) continue;
+      const [, name, parent, literal] = m;
+      groupPrefix.set(name, (0, import_shared.joinPath)(groupPrefix.get(parent) ?? "", literal));
+    }
+  }
+  const blockStack = [];
+  let depth = 0;
+  let className = null;
+  let classPrefix = "";
+  let pendingRoute = null;
+  let pendingVerbs = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    const depthBefore = depth;
+    depth += (0, import_shared.countBraces)(line);
+    const blockPrefix = (0, import_shared.unwindBlocks)(blockStack, depthBefore);
+    const routeAttr = ROUTE_ATTR_RE.exec(line);
+    const classDecl = CLASS_RE.exec(line);
+    if (classDecl) {
+      className = classDecl[1];
+      classPrefix = pendingRoute ? expandTokens(pendingRoute, className, null) : "";
+      pendingRoute = null;
+      pendingVerbs = [];
+      continue;
+    }
+    if (routeAttr) {
+      pendingRoute = routeAttr[1];
+    }
+    HTTP_ATTR_RE.lastIndex = 0;
+    let m;
+    while (m = HTTP_ATTR_RE.exec(line)) {
+      pendingVerbs.push({ verb: m[1], literal: m[2] ?? null, line: lineNo });
+    }
+    if (pendingVerbs.length > 0) {
+      const decl = METHOD_DECL_RE.exec(line);
+      if (decl) {
+        const actionName = decl[1];
+        for (const pending of pendingVerbs) {
+          const tail = pending.literal ?? pendingRoute ?? "";
+          const full = (0, import_shared.joinPath)(classPrefix, expandTokens(tail, className, actionName));
+          out.push((0, import_shared.route)(pending.line, pending.verb, full || "/", `[Http${pending.verb}]`));
+        }
+        pendingVerbs = [];
+        pendingRoute = null;
+      }
+      continue;
+    }
+    MAP_VERB_RE.lastIndex = 0;
+    while (m = MAP_VERB_RE.exec(line)) {
+      const [, recv, verb, literal] = m;
+      const prefix = groupPrefix.get(recv) ?? blockPrefix;
+      out.push((0, import_shared.route)(lineNo, verb, (0, import_shared.joinPath)(prefix, literal), `${recv}.Map${verb}`));
+    }
+    MAP_METHODS_RE.lastIndex = 0;
+    while (m = MAP_METHODS_RE.exec(line)) {
+      const [, recv, literal, verbList] = m;
+      const prefix = groupPrefix.get(recv) ?? blockPrefix;
+      const verbs = verbList.split(",").map((s) => s.replace(/["'\s]/g, "").toUpperCase()).filter((s) => import_shared.VERB_SET.has(s));
+      for (const verb of verbs) {
+        out.push((0, import_shared.route)(lineNo, verb, (0, import_shared.joinPath)(prefix, literal), `${recv}.MapMethods`));
+      }
+    }
+  }
+  return out;
+}
+function extractOutbound(content) {
+  const out = [];
+  let m;
+  CLIENT_CALL_RE.lastIndex = 0;
+  while (m = CLIENT_CALL_RE.exec(content)) {
+    const [, recv, fullName, verb, url] = m;
+    if (!(0, import_shared.isLikelyApiPath)(url)) continue;
+    out.push((0, import_shared.call)((0, import_shared.lineOf)(content, m.index), verb, url, `${recv}.${fullName}`));
+  }
+  REQUEST_MESSAGE_RE.lastIndex = 0;
+  while (m = REQUEST_MESSAGE_RE.exec(content)) {
+    const [, verb, url] = m;
+    if (!(0, import_shared.isLikelyApiPath)(url)) continue;
+    out.push((0, import_shared.call)((0, import_shared.lineOf)(content, m.index), verb, url, "new HttpRequestMessage"));
+  }
+  REFIT_ATTR_RE.lastIndex = 0;
+  while (m = REFIT_ATTR_RE.exec(content)) {
+    const [, verb, url] = m;
+    if (!(0, import_shared.isLikelyApiPath)(url)) continue;
+    out.push((0, import_shared.call)((0, import_shared.lineOf)(content, m.index), verb, url, `[${verb}] (Refit)`));
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  csharpCallsites
+});