@appchy/jarvis 0.1.37 → 0.1.39

package/dist/data/chunk-AKQQC5IT.mjs

@@ -0,0 +1,1224 @@
+import {
+  localFiles
+} from "./chunk-RRJ6KKYL.mjs";
+
+// ../../packages/data/src/graph.ts
+var GraphStore = class {
+  nodeById = /* @__PURE__ */ new Map();
+  typeIndex = /* @__PURE__ */ new Map();
+  edgeList = [];
+  pending = [];
+  outAdj = /* @__PURE__ */ new Map();
+  inAdj = /* @__PURE__ */ new Map();
+  hopAdj = /* @__PURE__ */ new Map();
+  addNode(input, owner) {
+    const node = {
+      id: input.id,
+      type: input.type,
+      metadata: input.metadata ?? {},
+      ...input.spec !== void 0 ? { spec: input.spec } : {},
+      owner
+    };
+    const prior = this.nodeById.get(node.id);
+    if (prior && prior.type !== node.type) this.unindexType(prior);
+    this.nodeById.set(node.id, node);
+    let byName = this.typeIndex.get(node.type);
+    if (!byName) {
+      byName = /* @__PURE__ */ new Map();
+      this.typeIndex.set(node.type, byName);
+    }
+    byName.set(node.id, node);
+  }
+  /** Drop a node from its type bucket, removing the bucket once empty. */
+  unindexType(node) {
+    const byName = this.typeIndex.get(node.type);
+    if (!byName) return;
+    byName.delete(node.id);
+    if (byName.size === 0) this.typeIndex.delete(node.type);
+  }
+  addEdge(input, owner) {
+    this.pending.push({ input, owner });
+  }
+  /** Remove a node and every edge touching it, updating the type index + adjacency. Generic (a node
+   *  is a node) — the memory-overlay delete path uses it to keep an in-session graph consistent with a
+   *  persisted removal, mirroring `addNode`. A no-op if the id is absent. */
+  removeNode(id) {
+    const node = this.nodeById.get(id);
+    if (!node) return;
+    this.nodeById.delete(id);
+    this.unindexType(node);
+    this.edgeList = this.edgeList.filter((e) => e.from !== id && e.to !== id);
+    this.rebuildAdjacency();
+  }
+  /** Merge one namespaced annotation into an existing node's metadata (enrichers). Isolated —
+   * a no-op if the node is absent, never throws (namespacing the key is the caller's job). */
+  annotate(req, _owner) {
+    const node = this.nodeById.get(req.nodeId);
+    if (!node) return;
+    node.metadata[req.key] = req.value;
+  }
+  /** Resolve pending edges (refs + inverses), rebuild adjacency. Returns any diagnostics. */
+  stitch() {
+    const diagnostics = [];
+    const pending = this.pending;
+    this.pending = [];
+    for (const { input, owner } of pending) {
+      const to = this.resolveTarget(input.to);
+      if (to === void 0) {
+        diagnostics.push({
+          severity: "warn",
+          code: "UNRESOLVED_REF",
+          message: `edge ${input.from} -[${input.relation}]-> ${describeRef(input.to)} has no matching node`,
+          plugin: owner
+        });
+        continue;
+      }
+      this.edgeList.push(this.edge(input.from, to, input.relation, input.metadata, owner));
+      if (input.inverse !== void 0) {
+        this.edgeList.push(this.edge(to, input.from, input.inverse, input.metadata, owner));
+      }
+    }
+    this.rebuildAdjacency();
+    return diagnostics;
+  }
+  // --- ReadonlyGraph ---
+  nodes(type) {
+    if (type === void 0) return [...this.nodeById.values()];
+    const byName = this.typeIndex.get(type);
+    return byName ? [...byName.values()] : [];
+  }
+  node(id) {
+    return this.nodeById.get(id);
+  }
+  edges(query) {
+    if (!query) return this.edgeList;
+    const candidates = query.from !== void 0 ? this.outAdj.get(query.from) ?? [] : query.to !== void 0 ? this.inAdj.get(query.to) ?? [] : this.edgeList;
+    return candidates.filter(
+      (e) => (query.from === void 0 || e.from === query.from) && (query.to === void 0 || e.to === query.to) && (query.relation === void 0 || e.relation === query.relation)
+    );
+  }
+  hops(id) {
+    return this.hopAdj.get(id) ?? [];
+  }
+  neighbors(id, query = {}) {
+    const direction = query.direction ?? "both";
+    const collected = /* @__PURE__ */ new Map();
+    const consider = (edges, endpoint) => {
+      if (!edges) return;
+      for (const e of edges) {
+        if (query.relation !== void 0 && e.relation !== query.relation) continue;
+        const other = this.nodeById.get(endpoint(e));
+        if (other) collected.set(other.id, other);
+      }
+    };
+    if (direction === "out" || direction === "both") consider(this.outAdj.get(id), (e) => e.to);
+    if (direction === "in" || direction === "both") consider(this.inAdj.get(id), (e) => e.from);
+    const result = [...collected.values()];
+    return query.limit !== void 0 ? result.slice(0, query.limit) : result;
+  }
+  /** Snapshot for serialization (graph.json ⊕ overlay). */
+  toJSON() {
+    return { nodes: [...this.nodeById.values()], edges: this.edgeList };
+  }
+  /** Populate from a persisted snapshot — `toJSON`'s inverse. Nodes/edges arrive already resolved and
+   *  owner-stamped, so they load straight in (no ref resolution, no `stitch`). The MCP serve path
+   *  presents this frozen built graph without re-running any producer. Replaces all state. */
+  load(trace) {
+    this.nodeById.clear();
+    this.typeIndex.clear();
+    this.edgeList = [...trace.edges];
+    this.pending = [];
+    for (const node of trace.nodes) {
+      this.nodeById.set(node.id, node);
+      let byName = this.typeIndex.get(node.type);
+      if (!byName) {
+        byName = /* @__PURE__ */ new Map();
+        this.typeIndex.set(node.type, byName);
+      }
+      byName.set(node.id, node);
+    }
+    this.rebuildAdjacency();
+  }
+  // --- internals ---
+  resolveTarget(to) {
+    if (typeof to === "string") {
+      return this.nodeById.has(to) ? to : void 0;
+    }
+    const byName = this.typeIndex.get(to.type);
+    if (!byName) return void 0;
+    if (byName.has(to.name)) return to.name;
+    for (const node of byName.values()) {
+      if (node.metadata.name === to.name || node.metadata.title === to.name) return node.id;
+    }
+    return void 0;
+  }
+  edge(from, to, relation, metadata, owner) {
+    return { from, to, relation, ...metadata ? { metadata } : {}, owner };
+  }
+  rebuildAdjacency() {
+    this.outAdj = /* @__PURE__ */ new Map();
+    this.inAdj = /* @__PURE__ */ new Map();
+    this.hopAdj = /* @__PURE__ */ new Map();
+    for (const e of this.edgeList) {
+      pushInto(this.outAdj, e.from, e);
+      pushInto(this.inAdj, e.to, e);
+      const metadata = e.metadata ? { metadata: e.metadata } : {};
+      pushInto(this.hopAdj, e.from, {
+        to: e.to,
+        relation: e.relation,
+        dir: "out",
+        owner: e.owner,
+        ...metadata
+      });
+      pushInto(this.hopAdj, e.to, {
+        to: e.from,
+        relation: e.relation,
+        dir: "in",
+        owner: e.owner,
+        ...metadata
+      });
+    }
+  }
+};
+function pushInto(map2, key, item) {
+  const list = map2.get(key);
+  if (list) list.push(item);
+  else map2.set(key, [item]);
+}
+function describeRef(to) {
+  return typeof to === "string" ? to : `${to.type}:${to.name}`;
+}
+
+// ../../packages/data/src/provenance.ts
+var DERIVED_FROM = "data.derivedFrom";
+var TIER = "data.tier";
+
+// ../../packages/data/src/map/ledger.ts
+var RESERVED = [
+  "type",
+  "title",
+  "status",
+  "createdAt",
+  "updatedAt",
+  "summary",
+  "searchText"
+];
+function formatLedger(ledgers) {
+  const width = Math.max(0, ...ledgers.map((one) => one.name.length));
+  return ledgers.map((one) => `  ${one.name.padEnd(width)}  ${tally(one)}`).join("\n");
+}
+function tally(ledger) {
+  const edges = Object.entries(ledger.edges).sort(([a], [b]) => a.localeCompare(b)).map(([relation, count2]) => `${relation} ${count2}`).join(" \xB7 ");
+  const missing = RESERVED.filter((key) => ledger.reserved[key] === 0);
+  return [
+    `${ledger.items} items \u2192 ${ledger.nodes} nodes`,
+    edges,
+    missing.length > 0 ? `no ${missing.join("/")}` : ""
+  ].filter(Boolean).join("   ");
+}
+
+// ../../packages/data/src/map/mint.ts
+function mintId(req) {
+  const declared = req.declared?.trim();
+  if (declared) return declared;
+  const parent = req.parent;
+  if (parent) return `${parent.id}/${slug(within(req.ref, parent.ref))}`;
+  return `${req.map}:${slug(req.ref)}`;
+}
+function within(ref, parent) {
+  return ref.startsWith(parent) ? ref.slice(parent.length) : ref;
+}
+function slug(ref) {
+  return ref.replace(/\.[^./\\]+$/, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// ../../packages/data/src/map/status.ts
+var ALIASES = {
+  open: "open",
+  todo: "open",
+  "to-do": "open",
+  queue: "open",
+  queued: "open",
+  backlog: "open",
+  planned: "open",
+  new: "open",
+  ready: "open",
+  "in-progress": "in-progress",
+  inprogress: "in-progress",
+  doing: "in-progress",
+  wip: "in-progress",
+  active: "in-progress",
+  current: "in-progress",
+  started: "in-progress",
+  done: "done",
+  complete: "done",
+  completed: "done",
+  shipped: "done",
+  released: "done",
+  closed: "done",
+  merged: "done",
+  archived: "done",
+  dropped: "dropped",
+  cancelled: "dropped",
+  canceled: "dropped",
+  wontfix: "dropped",
+  "wont-fix": "dropped",
+  abandoned: "dropped",
+  superseded: "dropped"
+};
+function categoryOf(raw) {
+  if (raw === void 0) return "unknown";
+  return ALIASES[raw.trim().toLowerCase()] ?? "unknown";
+}
+
+// ../../packages/data/src/map/run.ts
+async function runEntries(req) {
+  const maps = req.entries.filter((one) => one.entry === "map");
+  const connects = req.entries.filter((one) => one.entry === "connect");
+  const run = {
+    graph: req.graph,
+    repoRoot: req.repoRoot,
+    report: req.report,
+    code: freeze(req.graph),
+    minted: /* @__PURE__ */ new Map()
+  };
+  const scopes = [];
+  for (const spec of maps) {
+    const scope = await find(run, spec);
+    if (scope) scopes.push(scope);
+  }
+  await Promise.all(scopes.map((scope) => shape(run, scope)));
+  for (const scope of scopes) await mint(run, scope);
+  for (const scope of scopes) link(run, scope);
+  for (const spec of connects) await join(run, spec);
+  for (const diagnostic of silence(scopes)) run.report(diagnostic);
+  return scopes.map((scope) => scope.ledger);
+}
+async function find(run, spec) {
+  const ctx = finderContext(run, spec.name);
+  const listed = await guard(run, spec.name, () => spec.from.list(ctx));
+  if (listed === void 0) return void 0;
+  const kept = [];
+  for (const item of listed) {
+    const checked = await validate(run, spec, item);
+    if (checked) kept.push(checked);
+  }
+  return {
+    spec,
+    entries: kept.map((item) => ({ item, record: {}, items: [] })),
+    ledger: { name: spec.name, items: kept.length, nodes: 0, edges: {}, reserved: {} }
+  };
+}
+async function validate(run, spec, item) {
+  const schema = spec.from.schema;
+  if (!schema) return item;
+  const checked = await guard(
+    run,
+    spec.name,
+    async () => await schema["~standard"].validate(item.data)
+  );
+  if (checked === void 0) return void 0;
+  if (checked.issues) {
+    run.report({
+      severity: "error",
+      code: "MAP_SCHEMA",
+      message: `${spec.name}: ${item.ref} does not match its schema \u2014 ${issueText(checked.issues)}. Keys present: ${keyText(item.data)}`,
+      plugin: spec.name,
+      ...item.file !== void 0 ? { file: item.file } : {}
+    });
+    return void 0;
+  }
+  return { ...item, data: checked.value };
+}
+async function shape(run, scope) {
+  const ctx = mapContext(run, scope.spec.name);
+  const kept = [];
+  for (const entry of scope.entries) {
+    const record = await guard(run, scope.spec.name, () => scope.spec.how(entry.item, ctx));
+    if (record === void 0) continue;
+    entry.record = record;
+    entry.items = nest(record.items ?? [], {
+      ref: entry.item.ref,
+      ...entry.item.file !== void 0 ? { file: entry.item.file } : {}
+    });
+    kept.push(entry);
+  }
+  scope.entries = kept;
+  scope.ledger.items = kept.length;
+  count(scope);
+}
+function nest(items, parent) {
+  return items.map((record) => ({
+    record,
+    parent,
+    items: nest(record.items ?? [], {
+      ref: record.ref ?? "",
+      ...record.file !== void 0 ? { file: record.file } : {}
+    })
+  }));
+}
+function count(scope) {
+  const records = scope.entries.flatMap((entry) => [
+    entry.record,
+    ...flat(entry.items).map((one) => one.record)
+  ]);
+  for (const key of RESERVED) {
+    scope.ledger.reserved[key] = records.filter((record) => record[key] !== void 0).length;
+  }
+}
+function flat(items) {
+  return items.flatMap((one) => [one, ...flat(one.items)]);
+}
+async function mint(run, scope) {
+  for (const entry of scope.entries) {
+    entry.id = await place(run, scope, {
+      record: entry.record,
+      ref: entry.item.ref,
+      ...entry.item.file !== void 0 ? { file: entry.item.file } : {},
+      ...entry.item.span !== void 0 ? { span: entry.item.span } : {}
+    });
+    for (const child of entry.items) await inner(run, scope, child, entry.id, entry.item.ref);
+  }
+}
+async function inner(run, scope, node, parentId, parentRef) {
+  const record = node.record;
+  const file = record.file ?? (record.span !== void 0 ? node.parent.file : void 0);
+  if (record.type !== void 0 && record.id === void 0 && record.ref === void 0) {
+    run.report({
+      severity: "error",
+      code: "MAP_ERROR",
+      message: `${scope.spec.name}: a nested "${record.type}" record inside ${parentRef} spells neither \`id\` nor \`ref\`, so it has no id to mint`,
+      plugin: scope.spec.name
+    });
+    return;
+  }
+  node.id = await place(run, scope, {
+    record,
+    ref: record.ref ?? "",
+    ...file !== void 0 ? { file } : {},
+    ...record.span !== void 0 ? { span: record.span } : {},
+    ...parentId !== void 0 ? { parent: { id: parentId, ref: parentRef } } : {}
+  });
+  for (const child of node.items) await inner(run, scope, child, node.id, record.ref ?? "");
+}
+async function place(run, scope, req) {
+  if (req.record.type === void 0) return void 0;
+  const id = mintId({
+    map: scope.spec.name,
+    ref: req.ref,
+    declared: req.record.id,
+    ...req.parent !== void 0 ? { parent: req.parent } : {}
+  });
+  const fresh = { owner: scope.spec.name, record: req.record, ref: req.ref };
+  const prior = run.minted.get(id);
+  const kept = prior ? await fold(run, scope, id, prior, fresh) : fresh;
+  if (kept === void 0) return id;
+  run.minted.set(id, kept);
+  run.graph.addNode(toNodeInput(id, kept.record, req), kept.owner);
+  if (prior === void 0) scope.ledger.nodes += 1;
+  return id;
+}
+async function fold(run, scope, id, prior, fresh) {
+  const dedupe = scope.spec.dedupe ?? "error";
+  if (dedupe === "first") return void 0;
+  if (dedupe === "last") return fresh;
+  if (dedupe === "error") {
+    run.report({
+      severity: "error",
+      code: "MAP_COLLISION",
+      message: `two records mint the id "${id}" \u2014 ${prior.owner}'s ${prior.ref} and ${scope.spec.name}'s ${fresh.ref}. The store keys by id alone, so one of them would simply stop existing; set \`dedupe\` on the map that should decide.`,
+      plugin: scope.spec.name
+    });
+    return void 0;
+  }
+  const merged = await guard(run, scope.spec.name, () => dedupe(prior.record, fresh.record));
+  return merged ? { owner: scope.spec.name, record: merged, ref: fresh.ref } : void 0;
+}
+function toNodeInput(id, record, req) {
+  const free = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "items" || key === "links" || key === "rel" || key === "inverse" || key === "ref")
+      continue;
+    if (RESERVED.includes(key) || key === "id") continue;
+    const json = jsonOf(value);
+    if (json !== void 0) free[key] = json;
+  }
+  return {
+    id,
+    type: record.type ?? "",
+    metadata: {
+      ...free,
+      title: record.title ?? humanize(req.ref),
+      ...req.file !== void 0 ? { sourceFile: req.file } : {},
+      ...req.span !== void 0 ? { sourceSpan: req.span } : {},
+      // What a record was found INSIDE, as data and not just as an edge: the edge's relation is
+      // config-named, so a reader that has not been told the name cannot recognise it, and telling a
+      // document's own node from the ones minted inside it is a question every presenter asks.
+      ...req.parent !== void 0 ? { [DERIVED_FROM]: req.parent.id } : {},
+      ...record.status !== void 0 ? { status: record.status, statusCategory: categoryOf(record.status) } : {},
+      ...record.createdAt !== void 0 ? { createdAt: record.createdAt } : {},
+      ...record.updatedAt !== void 0 ? { updatedAt: record.updatedAt } : {},
+      ...record.summary !== void 0 ? { excerpt: record.summary } : {},
+      ...record.searchText !== void 0 ? { embedText: record.searchText } : {}
+    }
+  };
+}
+function jsonOf(value) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const one of value) {
+      const json = jsonOf(one);
+      if (json !== void 0) out.push(json);
+    }
+    return out;
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, held] of Object.entries(value)) {
+      const json = jsonOf(held);
+      if (json !== void 0) out[key] = json;
+    }
+    return out;
+  }
+  return void 0;
+}
+function link(run, scope) {
+  for (const entry of scope.entries) {
+    apply(run, scope, entry.record, entry.id, entry.item.ref);
+    for (const child of entry.items) descend(run, scope, child, entry.id);
+  }
+}
+function descend(run, scope, node, parentId) {
+  if (parentId !== void 0 && node.id !== void 0) {
+    emit(run, scope, {
+      from: parentId,
+      rel: node.record.rel,
+      to: node.id,
+      ...node.record.inverse !== void 0 ? { inverse: node.record.inverse } : {}
+    });
+  }
+  apply(run, scope, node.record, node.id, node.record.ref ?? "");
+  for (const child of node.items) descend(run, scope, child, node.id);
+}
+function apply(run, scope, record, id, ref) {
+  for (const request of record.links ?? []) {
+    const from = request.from ?? id;
+    if (from === void 0) {
+      run.report({
+        severity: "error",
+        code: "MAP_ERROR",
+        message: `${scope.spec.name}: a "${request.rel}" edge leaves "${ref}", which minted no node \u2014 give the record a \`type\`, or name the id the edge leaves from`,
+        plugin: scope.spec.name
+      });
+      continue;
+    }
+    emit(run, scope, { ...request, from });
+  }
+}
+function emit(run, scope, request) {
+  run.graph.addEdge(
+    {
+      from: request.from,
+      to: request.to,
+      relation: request.rel,
+      ...request.inverse !== void 0 ? { inverse: request.inverse } : {},
+      ...request.meta !== void 0 ? { metadata: request.meta } : {}
+    },
+    scope.spec.name
+  );
+  scope.ledger.edges[request.rel] = (scope.ledger.edges[request.rel] ?? 0) + 1;
+}
+async function join(run, spec) {
+  const ctx = finderContext(run, spec.name);
+  const graph = {
+    nodes: (type) => run.graph.nodes(type),
+    node: (id) => run.graph.node(id),
+    edges: (query) => run.graph.edges(query),
+    link: (request) => run.graph.addEdge(
+      {
+        from: request.from,
+        to: request.to,
+        relation: request.rel,
+        ...request.inverse !== void 0 ? { inverse: request.inverse } : {},
+        ...request.meta !== void 0 ? { metadata: request.meta } : {}
+      },
+      spec.name
+    ),
+    report: ctx.report
+  };
+  await guard(run, spec.name, () => spec.run(graph, ctx));
+}
+function silence(scopes) {
+  const asserted = scopes.filter((scope) => !(scope.spec.lens ?? scope.spec.from.lens));
+  if (asserted.length === 0) return [];
+  const silent = asserted.filter((scope) => scope.ledger.items === 0);
+  if (silent.length === 0) return [];
+  const severity = silent.length === asserted.length ? "error" : "warn";
+  return silent.map((scope) => ({
+    severity,
+    code: "MAP_EMPTY",
+    message: `map "${scope.spec.name}" found no items \u2014 ${scope.spec.from.name} matches nothing in this repo`,
+    plugin: scope.spec.name
+  }));
+}
+function freeze(graph) {
+  const nodes = [...graph.nodes()];
+  const byType = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    byId.set(node.id, node);
+    const held = byType.get(node.type);
+    if (held) held.push(node);
+    else byType.set(node.type, [node]);
+  }
+  const edges = [...graph.edges()];
+  return {
+    nodes: (type) => type === void 0 ? nodes : byType.get(type) ?? [],
+    node: (id) => byId.get(id),
+    edges: (query) => query === void 0 ? edges : edges.filter(
+      (edge) => (query.from === void 0 || edge.from === query.from) && (query.to === void 0 || edge.to === query.to) && (query.relation === void 0 || edge.relation === query.relation)
+    )
+  };
+}
+function finderContext(run, owner) {
+  return {
+    repoRoot: run.repoRoot,
+    report: (diagnostic) => run.report({ ...diagnostic, plugin: owner })
+  };
+}
+function mapContext(run, owner) {
+  return { ...finderContext(run, owner), code: run.code };
+}
+async function guard(run, owner, fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    run.report({ severity: "error", code: "MAP_ERROR", message: reason(err), plugin: owner });
+    return void 0;
+  }
+}
+function reason(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function issueText(issues) {
+  return issues.slice(0, 3).map((issue) => {
+    const path = (issue.path ?? []).map((step) => String(typeof step === "object" ? step.key : step)).join(".");
+    return path ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+function keyText(data) {
+  if (typeof data !== "object" || data === null) return "(none)";
+  const keys = Object.keys(data);
+  return keys.length ? keys.join(", ") : "(none)";
+}
+function humanize(ref) {
+  const base = (ref.split("/").pop() ?? ref).replace(/\.[^.]+$/, "");
+  return base.split(/[-_\s]+/).filter(Boolean).map((word) => `${(word[0] ?? "").toUpperCase()}${word.slice(1)}`).join(" ");
+}
+
+// ../../packages/data/src/engine.ts
+var PanicError = class extends Error {
+  constructor(plugin, message) {
+    super(message);
+    this.plugin = plugin;
+    this.name = "PanicError";
+  }
+  plugin;
+};
+async function buildGraph(config2) {
+  const graph = new GraphStore();
+  const diagnostics = [];
+  const logger = createLogger();
+  const code = createCodeBackend(config2.backend);
+  let ledger = [];
+  const allPlugins = config2.plugins;
+  try {
+    await runPlugin(config2.backend.name, diagnostics, async () => {
+      const ctx = createCtx(config2.backend.name, graph, config2, code, logger, diagnostics);
+      const codeGraph = await config2.backend.load(ctx);
+      for (const node of codeGraph.nodes) graph.addNode(node, config2.backend.name);
+      for (const edge of codeGraph.edges) graph.addEdge(edge, config2.backend.name);
+    });
+    diagnostics.push(...graph.stitch());
+    const sources = order(allPlugins.filter(isSource));
+    await Promise.all(
+      sources.map(
+        (s) => runPlugin(
+          s.name,
+          diagnostics,
+          () => s.apply(createCtx(s.name, graph, config2, code, logger, diagnostics))
+        )
+      )
+    );
+    diagnostics.push(...graph.stitch());
+    diagnostics.push(...silentSources(sources, graph, diagnostics));
+    ledger = await runEntries({
+      entries: allPlugins.filter(isMapping),
+      graph,
+      repoRoot: config2.repoRoot,
+      report: (d) => diagnostics.push(d)
+    });
+    diagnostics.push(...graph.stitch());
+    const linkers = order(allPlugins.filter(isLinker));
+    for (const l of linkers) {
+      await runPlugin(
+        l.name,
+        diagnostics,
+        () => l.apply(createCtx(l.name, graph, config2, code, logger, diagnostics))
+      );
+      diagnostics.push(...graph.stitch());
+    }
+    const enrichers = order(allPlugins.filter(isEnricher));
+    await Promise.all(
+      enrichers.map(
+        (e) => runPlugin(
+          e.name,
+          diagnostics,
+          () => e.apply(createCtx(e.name, graph, config2, code, logger, diagnostics))
+        )
+      )
+    );
+    diagnostics.push(...graph.stitch());
+  } catch (err) {
+    if (err instanceof PanicError) {
+      diagnostics.push({
+        severity: "error",
+        code: "PANIC",
+        message: err.message,
+        plugin: err.plugin
+      });
+    } else {
+      throw err;
+    }
+  }
+  return { graph, diagnostics, ledger };
+}
+function silentSources(sources, graph, reported) {
+  const asserted = sources.filter((s) => !s.optional);
+  if (asserted.length === 0) return [];
+  const produced = new Set(graph.nodes().map((n) => n.owner));
+  const spoke = new Set(reported.map((d) => d.plugin));
+  const silent = asserted.filter((s) => !produced.has(s.name) && !spoke.has(s.name));
+  if (silent.length === 0) return [];
+  const severity = silent.length === asserted.length ? "error" : "warn";
+  return silent.map((s) => ({
+    severity,
+    code: "SOURCE_EMPTY",
+    message: `source "${s.name}" produced no nodes \u2014 its include patterns match nothing in this repo`,
+    plugin: s.name
+  }));
+}
+async function runEnforcers(config2, graph) {
+  const diagnostics = [];
+  const logger = createLogger();
+  const code = createCodeBackend(config2.backend);
+  const enforcers = config2.plugins.filter(isEnforcer);
+  try {
+    await Promise.all(
+      enforcers.map(
+        (e) => runPlugin(
+          e.name,
+          diagnostics,
+          () => e.check(createEnforcerCtx(e, graph, config2, code, logger, diagnostics))
+        )
+      )
+    );
+  } catch (err) {
+    if (err instanceof PanicError) {
+      diagnostics.push({
+        severity: "error",
+        code: "PANIC",
+        message: err.message,
+        plugin: err.plugin
+      });
+    } else {
+      throw err;
+    }
+  }
+  return diagnostics;
+}
+function createCtx(owner, graph, config2, code, logger, diagnostics) {
+  return {
+    config: config2,
+    graph,
+    code,
+    addNode: (node) => graph.addNode(node, owner),
+    addEdge: (edge) => graph.addEdge(edge, owner),
+    annotate: (req) => graph.annotate(req, owner),
+    report: (d) => diagnostics.push({ ...d, plugin: owner }),
+    logger,
+    panic: (message) => {
+      throw new PanicError(owner, message);
+    }
+  };
+}
+function createEnforcerCtx(e, graph, config2, code, logger, diagnostics) {
+  return {
+    config: config2,
+    graph,
+    code,
+    logger,
+    report: (r) => {
+      const nodeId = typeof r.node === "string" ? r.node : r.node?.id;
+      diagnostics.push({
+        severity: r.severity ?? "error",
+        code: r.code ?? e.name,
+        message: r.message,
+        plugin: e.name,
+        ...nodeId !== void 0 ? { nodeId } : {},
+        ...r.file !== void 0 ? { file: r.file } : {},
+        ...r.line !== void 0 ? { line: r.line } : {},
+        ...r.data !== void 0 ? { data: r.data } : {}
+      });
+    }
+  };
+}
+function createCodeBackend(b) {
+  return { getNativeContext: () => b.native?.() ?? { type: b.name } };
+}
+async function runPlugin(name, diagnostics, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    if (err instanceof PanicError) throw err;
+    diagnostics.push({
+      severity: "error",
+      code: "PLUGIN_ERROR",
+      message: err instanceof Error ? err.message : String(err),
+      plugin: name
+    });
+  }
+}
+function order(plugins) {
+  const band = (p) => p.enforce === "pre" ? 0 : p.enforce === "post" ? 2 : 1;
+  return plugins.map((p, i) => ({ p, i })).sort((a, b) => band(a.p) - band(b.p) || a.i - b.i).map(({ p }) => p);
+}
+function isSource(p) {
+  return "seam" in p && p.seam === "source";
+}
+function isLinker(p) {
+  return "seam" in p && p.seam === "linker";
+}
+function isEnforcer(p) {
+  return "seam" in p && p.seam === "enforcer";
+}
+function isEnricher(p) {
+  return "seam" in p && p.seam === "enricher";
+}
+function isMapping(p) {
+  return "entry" in p && (p.entry === "map" || p.entry === "connect");
+}
+function createLogger() {
+  return {
+    info: (m) => process.stderr.write(`[data] ${m}
+`),
+    warn: (m) => process.stderr.write(`[data:warn] ${m}
+`),
+    error: (m) => process.stderr.write(`[data:error] ${m}
+`)
+  };
+}
+
+// ../../packages/data/src/diagnostics.ts
+var ICON = { error: "\u2717", warn: "!", info: "\xB7" };
+function printDiagnostics(diagnostics) {
+  for (const d of diagnostics) {
+    const where = d.file ? ` (${d.file}${d.line !== void 0 ? `:${d.line}` : ""})` : d.nodeId !== void 0 ? ` [${d.nodeId}]` : "";
+    const by = d.plugin ? `  \xB7${d.plugin}` : "";
+    console.log(`  ${ICON[d.severity] ?? "\xB7"} ${d.code}: ${d.message}${where}${by}`);
+  }
+}
+function summarize(diagnostics) {
+  return {
+    errors: diagnostics.filter((d) => d.severity === "error").length,
+    warns: diagnostics.filter((d) => d.severity === "warn").length
+  };
+}
+
+// ../../packages/data/src/parse.ts
+function sections(body, at) {
+  const found = [...body.matchAll(everywhere(at))];
+  return found.flatMap((match, index) => {
+    const id = match[1]?.trim();
+    if (!id) return [];
+    const start = match.index ?? 0;
+    const end = found[index + 1]?.index ?? body.length;
+    const heading = (match[0].split(/\r?\n/)[0] ?? "").replace(/^#{1,6}\s+/, "").trim();
+    return [{ id, heading, span: [start, end], text: body.slice(start, end) }];
+  });
+}
+function matches(body, at) {
+  return [...body.matchAll(everywhere(at))].flatMap((match, index) => {
+    const found = match.groups;
+    if (!found) return [];
+    const groups = {};
+    for (const [key, value] of Object.entries(found)) {
+      if (value !== void 0) groups[key] = value.trim();
+    }
+    const id = groups["id"] ?? String(index);
+    if (!id) return [];
+    const start = match.index ?? 0;
+    return [
+      { id, groups, text: match[0], span: [start, start + match[0].length] }
+    ];
+  });
+}
+function values(data, key) {
+  const held = data?.[key];
+  const list = Array.isArray(held) ? held : held === void 0 || held === null ? [] : [held];
+  return list.map((raw) => String(raw).trim()).filter(Boolean);
+}
+function everywhere(re) {
+  let flags = re.flags;
+  if (!flags.includes("g")) flags += "g";
+  if (!flags.includes("m")) flags += "m";
+  return new RegExp(re.source, flags);
+}
+
+// ../../packages/data/src/scan.ts
+function buildIdRegex(req) {
+  if (req.tokens.length === 0) return null;
+  const escaped = req.tokens.map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const before = req.notAnExtension ? "[A-Za-z0-9_.]" : "[A-Za-z0-9_]";
+  return new RegExp(`(?<!${before})(${escaped.join("|")})(?![A-Za-z0-9_])`, req.loose ? "gi" : "g");
+}
+function countOccurrences(text, regex, resolveToken) {
+  const occurrences = /* @__PURE__ */ new Map();
+  for (const line of text.split(/\r?\n/)) {
+    regex.lastIndex = 0;
+    let m;
+    while ((m = regex.exec(line)) !== null) {
+      const token = m[1];
+      const target = token === void 0 ? void 0 : resolveToken(token);
+      if (target === void 0) continue;
+      occurrences.set(target, (occurrences.get(target) ?? 0) + 1);
+    }
+  }
+  return occurrences;
+}
+function stripExampleSpans(text) {
+  return text.replace(/"[^"\n]*"/g, " ").replace(/`[^`\n]*`/g, " ");
+}
+
+// ../../packages/data/src/edges.ts
+var COVERAGE_VIA = { colocation: "colocation", import: "import" };
+var IMPORT_RELATIONS = ["imports", "imports_from"];
+
+// ../../packages/data/src/confidence.ts
+var FUZZY_RELATIONS = /* @__PURE__ */ new Set([
+  "relates_to",
+  "touches",
+  "touchedBy",
+  "bridges",
+  "bridgedBy"
+]);
+var FUZZY_EDGE_META = "data.confidence";
+function isPrecise(edge, backendName) {
+  const backendOwned = edge.metadata?.["data.federated.backendOwned"] === true || edge.owner === backendName;
+  const declaredFuzzy = edge.metadata?.[FUZZY_EDGE_META] === "fuzzy";
+  return !backendOwned && !declaredFuzzy && !FUZZY_RELATIONS.has(edge.relation);
+}
+function edgeMatchesConfidence(edge, backendName, confidence) {
+  if (confidence === "all") return true;
+  return confidence === "precise" ? isPrecise(edge, backendName) : !isPrecise(edge, backendName);
+}
+
+// ../../packages/data/src/code.ts
+function filesOf(graph, req) {
+  const index = { code: /* @__PURE__ */ new Map(), docs: /* @__PURE__ */ new Map() };
+  for (const node of graph.nodes()) {
+    const file = asString(node.metadata.sourceFile);
+    if (file === void 0) continue;
+    const side = node.owner === req.backend ? index.code : index.docs;
+    const held = side.get(file);
+    if (held) held.push(node);
+    else side.set(file, [node]);
+  }
+  return index;
+}
+function lineOf(value) {
+  if (typeof value !== "string") return Infinity;
+  const found = /\d+/.exec(value);
+  return found ? Number(found[0]) : Infinity;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// ../../packages/data/src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { createJiti } from "jiti";
+var CONFIG_NAMES = [
+  "jarvis.config.ts",
+  "jarvis.config.mts",
+  "jarvis.config.mjs",
+  "jarvis.config.js",
+  "jarvis.config.cjs"
+];
+async function loadConfig(cwd) {
+  let dir = resolve(cwd);
+  for (; ; ) {
+    for (const name of CONFIG_NAMES) {
+      const path = resolve(dir, name);
+      if (existsSync(path)) {
+        const config2 = await importConfig(path);
+        validateConfig(config2, path);
+        return {
+          ...config2,
+          persistence: config2.persistence ?? localFiles(),
+          repoRoot: dir
+        };
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    `No jarvis.config.{ts,js,mjs} found from ${cwd}. A repo maps its world in one, at its root.`
+  );
+}
+async function importConfig(path) {
+  const jiti = createJiti(import.meta.url, { moduleCache: false, alias: selfAlias() });
+  const mod = await jiti.import(path);
+  const config2 = mod.default ?? mod;
+  return config2;
+}
+var PACKAGE_NAME = "@jarvis/data";
+function packageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    if (existsSync(resolve(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return dir;
+    dir = parent;
+  }
+}
+function selfAlias() {
+  const root = packageRoot();
+  const pkg = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  if (pkg.name !== PACKAGE_NAME) {
+    const vendored = process.env[VENDOR_ENV];
+    if (!vendored) {
+      throw new Error(
+        `${PACKAGE_NAME} is running inside "${pkg.name ?? "an unnamed package"}" and cannot locate its own modules. A host that bundles the engine must set ${VENDOR_ENV} to the directory holding its built copy.`
+      );
+    }
+    return toVendorAlias(vendored);
+  }
+  const alias = {};
+  for (const [subpath, entry] of Object.entries(pkg.exports ?? {})) {
+    const target = typeof entry === "string" ? entry : entry.default;
+    if (!target) continue;
+    alias[toSpecifier(subpath)] = resolve(root, target);
+  }
+  return alias;
+}
+var VENDOR_ENV = "JARVIS_DATA_VENDOR";
+var VENDOR_SUBPATHS = [
+  "mcp",
+  "backends",
+  "embedders",
+  "finders",
+  "linkers",
+  "persistences",
+  "rerankers",
+  "stores"
+];
+function toVendorAlias(dir) {
+  const alias = { [PACKAGE_NAME]: resolve(dir, "index.mjs") };
+  for (const sub of VENDOR_SUBPATHS) alias[`${PACKAGE_NAME}/${sub}`] = resolve(dir, `${sub}.mjs`);
+  return alias;
+}
+function toSpecifier(subpath) {
+  return subpath === "." ? PACKAGE_NAME : `${PACKAGE_NAME}/${subpath.replace(/^\.\//, "")}`;
+}
+function validateConfig(value, path) {
+  const fail = (msg) => {
+    throw new Error(`${path}: ${msg}`);
+  };
+  if (typeof value !== "object" || value === null) fail("config must export an object");
+  const c = value;
+  const backend2 = c.backend;
+  if (!backend2 || backend2.seam !== "backend")
+    fail("`backend` must be a backend plugin (e.g. graphify({...}))");
+  if (c.persistence !== void 0) {
+    const persistence2 = c.persistence;
+    if (persistence2.seam !== "persistence")
+      fail("`persistence` must be a persistence plugin (e.g. localFiles())");
+  }
+  if (!Array.isArray(c.plugins)) fail("`plugins` must be an array");
+  for (const p of c.plugins) {
+    const routable = p?.entry === "map" || p?.entry === "connect" || p?.seam === "source" || p?.seam === "linker" || p?.seam === "enforcer" || p?.seam === "enricher" || p?.seam === "remote";
+    if (!routable) {
+      fail(
+        `every entry must be a map or a connect, or a source/linker/enforcer/enricher/remote (got ${JSON.stringify(p)})`
+      );
+    }
+  }
+  const search = c.search;
+  if (search !== void 0) {
+    if (typeof search.embedder?.embed !== "function")
+      fail("`search.embedder` must be an embedder (e.g. localEmbeddings())");
+    if (search.store !== void 0 && typeof search.store.query !== "function")
+      fail("`search.store` must be a vector store");
+    if (search.reranker !== void 0 && typeof search.reranker.rerank !== "function")
+      fail("`search.reranker` must be a reranker (e.g. localReranker())");
+  }
+}
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+// ../../packages/data/src/vector.ts
+function normalize(vector) {
+  let sum = 0;
+  for (const x of vector) sum += x * x;
+  const mag = Math.sqrt(sum);
+  return mag > 0 ? vector.map((x) => x / mag) : vector;
+}
+function dot(a, b) {
+  let sum = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x !== void 0 && y !== void 0) sum += x * y;
+  }
+  return sum;
+}
+
+// ../../packages/data/src/memory.ts
+var MEMORY_OWNER = "memory";
+function emptyStore() {
+  return { version: 1, memories: [], audit: [] };
+}
+async function readMemoryStore(config2) {
+  const ctx = { repoRoot: config2.repoRoot };
+  try {
+    const raw = await config2.persistence.load(ctx, "memory");
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      if (parsed.version === 1 && Array.isArray(parsed.memories) && Array.isArray(parsed.audit)) {
+        return parsed;
+      }
+    }
+  } catch {
+  }
+  return emptyStore();
+}
+async function writeMemoryStore(config2, store2) {
+  const ctx = { repoRoot: config2.repoRoot };
+  await config2.persistence.save(ctx, "memory", `${JSON.stringify(store2, null, 2)}
+`);
+}
+function deleteMemory(store2, id) {
+  const index = store2.memories.findIndex((m) => m.id === id);
+  if (index < 0) return void 0;
+  const [removed] = store2.memories.splice(index, 1);
+  return removed;
+}
+function memoryNode(rec) {
+  return {
+    id: rec.id,
+    type: rec.type,
+    metadata: { title: rec.text, "data.origin": "agent", origin: "agent" }
+  };
+}
+function resolveLinkTarget(graph, backendName, to) {
+  const direct = graph.node(to);
+  if (direct) return direct.id;
+  let suffixMatch;
+  for (const n of graph.nodes()) {
+    if (n.owner !== backendName) continue;
+    const f = n.metadata.sourceFile;
+    if (typeof f !== "string") continue;
+    if (f === to) return n.id;
+    if (suffixMatch === void 0 && (f.endsWith(`/${to}`) || f.endsWith(to))) suffixMatch = n.id;
+  }
+  return suffixMatch;
+}
+async function applyMemoryOverlay(config2, graph, options = {}) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const store2 = await readMemoryStore(config2);
+  const backendName = config2.backend.name;
+  const flipped = [];
+  let orphanedCount = 0;
+  for (const rec of store2.memories) {
+    graph.addNode(memoryNode(rec), MEMORY_OWNER);
+    let anyResolved = false;
+    for (const link2 of rec.links) {
+      const targetId = resolveLinkTarget(graph, backendName, link2.to);
+      if (targetId === void 0) continue;
+      graph.addEdge({ from: rec.id, to: targetId, relation: link2.relation }, MEMORY_OWNER);
+      anyResolved = true;
+    }
+    const wasOrphaned = rec.orphaned === true;
+    const nowOrphaned = rec.links.length > 0 && !anyResolved;
+    if (nowOrphaned !== wasOrphaned) flipped.push(rec);
+    rec.orphaned = nowOrphaned;
+    if (nowOrphaned) orphanedCount++;
+  }
+  graph.stitch();
+  if (flipped.length > 0) {
+    for (const rec of flipped) {
+      store2.audit.push({
+        at: now(),
+        actor: "system",
+        action: "reconcile",
+        id: rec.id,
+        rationale: rec.orphaned ? "no link target resolved on rebuild" : "a link target resolved again"
+      });
+    }
+    await writeMemoryStore(config2, store2);
+  }
+  return { loaded: store2.memories.length, orphaned: orphanedCount };
+}
+
+export {
+  GraphStore,
+  DERIVED_FROM,
+  TIER,
+  RESERVED,
+  formatLedger,
+  mintId,
+  slug,
+  categoryOf,
+  buildGraph,
+  runEnforcers,
+  printDiagnostics,
+  summarize,
+  sections,
+  matches,
+  values,
+  everywhere,
+  buildIdRegex,
+  countOccurrences,
+  stripExampleSpans,
+  COVERAGE_VIA,
+  IMPORT_RELATIONS,
+  FUZZY_RELATIONS,
+  FUZZY_EDGE_META,
+  isPrecise,
+  edgeMatchesConfidence,
+  filesOf,
+  lineOf,
+  asString,
+  loadConfig,
+  validateConfig,
+  readJson,
+  normalize,
+  dot,
+  readMemoryStore,
+  writeMemoryStore,
+  deleteMemory,
+  memoryNode,
+  applyMemoryOverlay
+};