@cortexkit/pi-magic-context 0.44.4 → 0.46.0

package/dist/index-phh7e055.js

@@ -0,0 +1,290 @@
+// ../plugin/src/shared/harness-provider-map.ts
+var CANONICAL_TO_PI_PROVIDER = {
+  openai: "openai-codex",
+  google: "google-antigravity"
+};
+var PI_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google"
+};
+var CANONICAL_TO_OMP_PROVIDER = {
+  openai: "openai-codex",
+  google: "google-antigravity",
+  opencode: "opencode-zen"
+};
+var OMP_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google",
+  "opencode-zen": "opencode"
+};
+var CANONICAL_MODEL_IDENTITY_ALIASES = {
+  "github-copilot/gpt-6-astra": "openai/gpt-6-astra"
+};
+function remapProviderPrefix(ref, map) {
+  if (typeof ref !== "string")
+    return ref;
+  const slash = ref.indexOf("/");
+  if (slash <= 0)
+    return ref;
+  const provider = ref.slice(0, slash);
+  if (!Object.hasOwn(map, provider))
+    return ref;
+  return `${map[provider]}${ref.slice(slash)}`;
+}
+function canonicalModelIdentity(ref) {
+  const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+  return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
+}
+function piModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+function resolveModelRefForPi(ref) {
+  return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}
+function modelRefLookupOrder(ref) {
+  const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+  return [
+    ...new Set([
+      canonical,
+      ref,
+      resolveModelRefForPi(canonical),
+      resolveModelRefForOmp(canonical)
+    ])
+  ];
+}
+function ompModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
+}
+function resolveModelRefForOmp(ref) {
+  return remapProviderPrefix(ompModelRefToCanonical(ref), CANONICAL_TO_OMP_PROVIDER);
+}
+
+// ../plugin/src/shared/historian-tool-template.ts
+class Parser {
+  source;
+  pos = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  error() {
+    throw new Error(`Invalid tool expansion template at character ${this.pos + 1}`);
+  }
+  take(value) {
+    if (!this.source.startsWith(value, this.pos))
+      return false;
+    this.pos += value.length;
+    return true;
+  }
+  field() {
+    const match = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(this.source.slice(this.pos));
+    if (!match)
+      return this.error();
+    this.pos += match[0].length;
+    return match[0];
+  }
+  quoted() {
+    const start = this.pos;
+    if (!this.take('"'))
+      return this.error();
+    while (this.pos < this.source.length) {
+      if (this.take("\\")) {
+        this.pos++;
+        continue;
+      }
+      if (this.take('"')) {
+        try {
+          return JSON.parse(this.source.slice(start, this.pos));
+        } catch {
+          return this.error();
+        }
+      }
+      this.pos++;
+    }
+    return this.error();
+  }
+  integer() {
+    const match = /^\d+/.exec(this.source.slice(this.pos));
+    if (!match)
+      return this.error();
+    this.pos += match[0].length;
+    const n = Number(match[0]);
+    if (!Number.isSafeInteger(n))
+      return this.error();
+    return n;
+  }
+  expression(relative) {
+    const steps = [];
+    if (!(relative && this.take("."))) {
+      const root = this.field();
+      if (!relative && root !== "input" && root !== "output")
+        return this.error();
+      steps.push({ field: root });
+    }
+    while (true) {
+      if (this.take("[")) {
+        if (this.take("*]."))
+          steps.push({ project: this.field() });
+        else {
+          const index = this.integer();
+          if (!this.take("]"))
+            return this.error();
+          steps.push({ index });
+        }
+      } else if (this.source[this.pos] === "." && !/^\.(each\(|join\(|count(?:\.|\})|truncate\()/.test(this.source.slice(this.pos))) {
+        this.pos++;
+        steps.push({ field: this.field() });
+        if (this.source[this.pos] === "(")
+          return this.error();
+      } else
+        break;
+    }
+    const expression = { steps, cap: 300 };
+    if (this.take(".each(")) {
+      if (relative)
+        return this.error();
+      expression.each = parseTemplate(this.quoted(), true);
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (this.take(".join(")) {
+      expression.join = this.quoted();
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (this.take(".count")) {
+      if (expression.each || expression.join !== undefined)
+        return this.error();
+      expression.count = true;
+    }
+    if (this.take(".truncate(")) {
+      expression.cap = this.integer();
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (!this.take("}"))
+      return this.error();
+    return expression;
+  }
+  template(relative) {
+    const nodes = [];
+    while (this.pos < this.source.length) {
+      const next = this.source.indexOf("${", this.pos);
+      if (next < 0) {
+        nodes.push(this.source.slice(this.pos));
+        break;
+      }
+      nodes.push(this.source.slice(this.pos, next));
+      this.pos = next + 2;
+      nodes.push(this.expression(relative));
+    }
+    return nodes;
+  }
+}
+function parseTemplate(source, relative = false) {
+  return new Parser(source).template(relative);
+}
+function toolTemplateError(source) {
+  try {
+    parseTemplate(source);
+    return;
+  } catch (error) {
+    return error.message;
+  }
+}
+var templates = new Map;
+function compiled(source) {
+  if (!templates.has(source)) {
+    try {
+      templates.set(source, parseTemplate(source));
+    } catch {
+      templates.set(source, null);
+    }
+  }
+  return templates.get(source) ?? null;
+}
+function oneLine(value) {
+  return value.replace(/[\r\n\u2028\u2029]+/g, " ");
+}
+function truncate(value, cap) {
+  const chars = Array.from(oneLine(value));
+  return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+}
+function scalar(value) {
+  if (value === undefined)
+    return "";
+  return typeof value === "string" ? value : compactJson(value);
+}
+function compactJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map((v) => compactJson(v)).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${compactJson(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+}
+function field(value, key) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+}
+function render(nodes, root) {
+  return nodes.map((node) => {
+    if (typeof node === "string")
+      return node;
+    let value = root;
+    let list = false;
+    for (const step of node.steps) {
+      if ("field" in step)
+        value = list && Array.isArray(value) ? value.map((item) => field(item, step.field)) : field(value, step.field);
+      else if ("index" in step)
+        value = Array.isArray(value) ? value[step.index] : undefined;
+      else {
+        value = Array.isArray(value) ? value.map((item) => field(item, step.project)) : undefined;
+        list = true;
+      }
+    }
+    if (node.count)
+      return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+    if (node.each || list || node.join !== undefined) {
+      if (!Array.isArray(value))
+        return "";
+      const elements = value.slice(0, 10).map((item) => truncate(node.each ? render(node.each, item) : scalar(item), 300));
+      if (value.length > 10)
+        elements.push(`… +${value.length - 10} more`);
+      return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+    }
+    return truncate(scalar(value), node.cap);
+  }).join("");
+}
+function renderToolTemplate(source, input, output) {
+  const nodes = compiled(source);
+  if (!nodes)
+    return null;
+  const text = typeof output === "string" ? output : output === undefined ? "" : compactJson(output);
+  let structured = output;
+  if (typeof output === "string") {
+    try {
+      const parsed = JSON.parse(output);
+      structured = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    } catch {
+      structured = undefined;
+    }
+  }
+  const root = { input, output: structured };
+  const bareOutputNodes = nodes.map((node) => typeof node !== "string" && node.steps.length === 1 && ("field" in node.steps[0]) && node.steps[0].field === "output" && !node.each && !node.count && node.join === undefined ? truncate(text ?? "", node.cap) : node);
+  return truncate(render(bareOutputNodes, root), 1000);
+}
+
+// ../plugin/src/shared/protected-tools-policy.ts
+var DEFAULT_PROTECTED_TOOLS = {
+  todowrite: 1,
+  ctx_reduce: 3
+};
+function normalizeProtectedToolName(name) {
+  return (name ?? "").toLowerCase().replace(/^mcp_/, "");
+}
+function mergeProtectedTools(...maps) {
+  return Object.fromEntries([DEFAULT_PROTECTED_TOOLS, ...maps].flatMap((map) => Object.entries(map ?? {}).map(([name, count]) => [
+    normalizeProtectedToolName(name),
+    count
+  ])));
+}
+
+export { canonicalModelIdentity, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, ompModelRefToCanonical, resolveModelRefForOmp, toolTemplateError, renderToolTemplate, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools };

package/dist/index-q1yc6bs0.js

@@ -0,0 +1,104 @@
+// ../plugin/src/shared/rpc-notifications.ts
+var queue = [];
+var nextNotificationId = 1;
+var sinks = new Set;
+function registerNotificationSink2(sink) {
+  sinks.add(sink);
+  return () => {
+    sinks.delete(sink);
+  };
+}
+function notificationMatchesSink(notification, sink) {
+  if (notification.sessionId === undefined)
+    return true;
+  if (sink.sessionId !== undefined)
+    return notification.sessionId === sink.sessionId;
+  return sink.protocol !== 2;
+}
+function pushNotification2(type, payload, sessionId) {
+  const notification = { id: nextNotificationId++, type, payload, sessionId };
+  queue.push(notification);
+  for (const sink of sinks) {
+    if (!notificationMatchesSink(notification, sink))
+      continue;
+    try {
+      sink.send(notification);
+    } catch {}
+  }
+  if (queue.length > 100) {
+    const reservedIds = new Set;
+    const reservedScopes = new Set;
+    for (let i = queue.length - 1;i >= 0 && reservedScopes.size < 25; i -= 1) {
+      const candidate = queue[i];
+      const scope = candidate.sessionId ?? "\x00global";
+      if (reservedScopes.has(scope))
+        continue;
+      reservedScopes.add(scope);
+      reservedIds.add(candidate.id);
+    }
+    const evictionIndex = queue.findIndex((candidate) => !reservedIds.has(candidate.id));
+    queue.splice(evictionIndex >= 0 ? evictionIndex : 0, 1);
+  }
+}
+function acknowledgeNotifications2(ids) {
+  const acknowledged = new Set(ids.filter((id) => Number.isSafeInteger(id) && id > 0));
+  if (acknowledged.size === 0)
+    return;
+  queue = queue.filter((notification) => !acknowledged.has(notification.id));
+}
+function __resetNotificationStateForTests2() {
+  queue = [];
+  nextNotificationId = 1;
+  sinks.clear();
+}
+function cursor(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function drainNotifications2(lastReceivedId = 0, sessionId, options = {}) {
+  const sessionCursor = cursor(lastReceivedId);
+  if (options.globalOnly) {
+    queue = queue.filter((notification) => notification.sessionId !== undefined || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === undefined && notification.id > sessionCursor);
+  }
+  if (options.sessionOnly) {
+    if (sessionId === undefined)
+      return [];
+    queue = queue.filter((notification) => notification.sessionId !== sessionId || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === sessionId && notification.id > sessionCursor);
+  }
+  if (sessionId !== undefined && options.globalLastReceivedId !== undefined) {
+    const globalCursor = cursor(options.globalLastReceivedId);
+    queue = queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      if (notification.sessionId === sessionId)
+        return notification.id > sessionCursor;
+      return true;
+    });
+    return queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      return notification.sessionId === sessionId && notification.id > sessionCursor;
+    });
+  }
+  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
+  if (sessionCursor > 0) {
+    queue = queue.filter((notification) => !(notification.id <= sessionCursor && matchesClient(notification)));
+  }
+  return queue.filter((notification) => notification.id > sessionCursor && matchesClient(notification));
+}
+function isTuiConnected2(sessionId) {
+  if (sinks.size === 0)
+    return false;
+  if (sessionId === undefined)
+    return true;
+  for (const sink of sinks) {
+    if (sink.sessionId === sessionId)
+      return true;
+    if (sink.sessionId === undefined && sink.protocol !== 2)
+      return true;
+  }
+  return false;
+}
+
+export { registerNotificationSink2, pushNotification2, acknowledgeNotifications2, __resetNotificationStateForTests2, drainNotifications2, isTuiConnected2 };