trellis 2.1.7 → 3.0.2

package/dist/index-yp88he8n.js

@@ -0,0 +1,316 @@
+// @bun
+// src/core/query/types.ts
+function isVariable(t) {
+  return t.kind === "variable";
+}
+function isLiteral(t) {
+  return t.kind === "literal";
+}
+function variable(name) {
+  return { kind: "variable", name };
+}
+function literal(value) {
+  return { kind: "literal", value };
+}
+
+// src/core/query/engine.ts
+class QueryEngine {
+  store;
+  rules = new Map;
+  maxRuleDepth = 32;
+  constructor(store) {
+    this.store = store;
+  }
+  addRule(rule) {
+    const existing = this.rules.get(rule.name) ?? [];
+    existing.push(rule);
+    this.rules.set(rule.name, existing);
+  }
+  removeRule(name) {
+    this.rules.delete(name);
+  }
+  execute(query) {
+    const start = performance.now();
+    let results = this._evaluatePatterns(query.where, [new Map]);
+    for (const filter of query.filters) {
+      results = results.filter((b) => this._evalFilter(filter, b));
+    }
+    if (query.aggregates.length > 0) {
+      results = this._aggregate(results, query.aggregates, query.select);
+    }
+    if (query.orderBy.length > 0) {
+      results = this._order(results, query.orderBy);
+    }
+    if (query.offset > 0)
+      results = results.slice(query.offset);
+    if (query.limit > 0)
+      results = results.slice(0, query.limit);
+    const projected = this._project(results, query.select);
+    return {
+      bindings: projected,
+      executionTime: performance.now() - start,
+      count: projected.length
+    };
+  }
+  _evaluatePatterns(patterns, bindings) {
+    let current = bindings;
+    for (const pattern of patterns) {
+      if (current.length === 0)
+        break;
+      current = this._evaluatePattern(pattern, current);
+    }
+    return current;
+  }
+  _evaluatePattern(pattern, bindings) {
+    switch (pattern.kind) {
+      case "fact":
+        return this._evalFactPattern(pattern, bindings);
+      case "link":
+        return this._evalLinkPattern(pattern, bindings);
+      case "not":
+        return this._evalNotPattern(pattern, bindings);
+      case "or":
+        return this._evalOrPattern(pattern, bindings);
+      case "rule":
+        return this._evalRuleApplication(pattern, bindings);
+    }
+  }
+  _evalFactPattern(p, bindings) {
+    const results = [];
+    for (const b of bindings) {
+      const eResolved = this._resolve(p.entity, b);
+      const aResolved = this._resolve(p.attribute, b);
+      const vResolved = this._resolve(p.value, b);
+      let facts;
+      if (eResolved !== undefined && aResolved !== undefined) {
+        facts = this.store.getFactsByEntity(String(eResolved)).filter((f) => f.a === aResolved);
+      } else if (eResolved !== undefined) {
+        facts = this.store.getFactsByEntity(String(eResolved));
+      } else if (aResolved !== undefined && vResolved !== undefined) {
+        facts = this.store.getFactsByValue(String(aResolved), vResolved);
+      } else if (aResolved !== undefined) {
+        facts = this.store.getFactsByAttribute(String(aResolved));
+      } else {
+        facts = this.store.getAllFacts();
+      }
+      if (vResolved !== undefined) {
+        facts = facts.filter((f) => f.v === vResolved);
+      }
+      for (const fact of facts) {
+        const nb = new Map(b);
+        if (this._bind(p.entity, fact.e, nb) && this._bind(p.attribute, fact.a, nb) && this._bind(p.value, fact.v, nb)) {
+          results.push(nb);
+        }
+      }
+    }
+    return results;
+  }
+  _evalLinkPattern(p, bindings) {
+    const results = [];
+    for (const b of bindings) {
+      const srcResolved = this._resolve(p.source, b);
+      const attrResolved = this._resolve(p.attribute, b);
+      const tgtResolved = this._resolve(p.target, b);
+      let links;
+      if (srcResolved !== undefined && attrResolved !== undefined) {
+        links = this.store.getLinksByEntityAndAttribute(String(srcResolved), String(attrResolved));
+      } else if (srcResolved !== undefined) {
+        links = this.store.getLinksByEntity(String(srcResolved));
+      } else if (attrResolved !== undefined) {
+        links = this.store.getLinksByAttribute(String(attrResolved));
+      } else {
+        links = this.store.getAllLinks();
+      }
+      if (tgtResolved !== undefined) {
+        links = links.filter((l) => l.e2 === tgtResolved);
+      }
+      for (const link of links) {
+        const nb = new Map(b);
+        if (this._bind(p.source, link.e1, nb) && this._bind(p.attribute, link.a, nb) && this._bind(p.target, link.e2, nb)) {
+          results.push(nb);
+        }
+      }
+    }
+    return results;
+  }
+  _evalNotPattern(p, bindings) {
+    return bindings.filter((b) => {
+      const matches = this._evaluatePattern(p.pattern, [b]);
+      return matches.length === 0;
+    });
+  }
+  _evalOrPattern(p, bindings) {
+    const results = [];
+    for (const branch of p.branches) {
+      const branchResults = this._evaluatePatterns(branch, bindings);
+      results.push(...branchResults);
+    }
+    return this._dedup(results);
+  }
+  _evalRuleApplication(p, bindings, depth = 0) {
+    if (depth > this.maxRuleDepth)
+      return [];
+    const ruleDefs = this.rules.get(p.name);
+    if (!ruleDefs)
+      return [];
+    const results = [];
+    for (const b of bindings) {
+      for (const rule of ruleDefs) {
+        const ruleBindings = new Map(b);
+        let ok = true;
+        for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+          const resolved = this._resolve(p.args[i], b);
+          if (resolved !== undefined) {
+            ruleBindings.set(rule.params[i], resolved);
+          } else if (isVariable(p.args[i])) {}
+        }
+        if (!ok)
+          continue;
+        let bodyResults = this._evaluatePatterns(rule.body, [ruleBindings]);
+        for (const f of rule.filters) {
+          bodyResults = bodyResults.filter((rb) => this._evalFilter(f, rb));
+        }
+        for (const rb of bodyResults) {
+          const nb = new Map(b);
+          for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+            if (isVariable(p.args[i])) {
+              const val = rb.get(rule.params[i]);
+              if (val !== undefined)
+                nb.set(p.args[i].name, val);
+            }
+          }
+          results.push(nb);
+        }
+      }
+    }
+    return this._dedup(results);
+  }
+  _evalFilter(filter, b) {
+    const left = this._resolve(filter.left, b);
+    const right = this._resolve(filter.right, b);
+    if (left === undefined || right === undefined)
+      return false;
+    switch (filter.op) {
+      case "=":
+        return left === right;
+      case "!=":
+        return left !== right;
+      case "<":
+        return left < right;
+      case "<=":
+        return left <= right;
+      case ">":
+        return left > right;
+      case ">=":
+        return left >= right;
+      case "contains":
+        return String(left).includes(String(right));
+      case "startsWith":
+        return String(left).startsWith(String(right));
+      case "endsWith":
+        return String(left).endsWith(String(right));
+      case "matches":
+        return new RegExp(String(right)).test(String(left));
+      default:
+        return false;
+    }
+  }
+  _aggregate(bindings, aggregates, groupBy) {
+    const aggVarNames = new Set(aggregates.map((a) => a.as));
+    const groupVars = groupBy.filter((v) => !aggVarNames.has(v));
+    const groups = new Map;
+    for (const b of bindings) {
+      const key = groupVars.map((v) => String(b.get(v) ?? "")).join("\x00");
+      const group = groups.get(key) ?? [];
+      group.push(b);
+      groups.set(key, group);
+    }
+    const results = [];
+    for (const [, group] of groups) {
+      const nb = new Map(group[0]);
+      for (const agg of aggregates) {
+        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== undefined);
+        nb.set(agg.as, this._computeAggregate(agg.op, vals));
+      }
+      results.push(nb);
+    }
+    return results;
+  }
+  _computeAggregate(op, vals) {
+    switch (op) {
+      case "count":
+        return vals.length;
+      case "sum":
+        return vals.reduce((s, v) => s + (Number(v) || 0), 0);
+      case "avg":
+        return vals.length ? vals.reduce((s, v) => s + (Number(v) || 0), 0) / vals.length : 0;
+      case "min":
+        return vals.reduce((m, v) => v < m ? v : m, vals[0]);
+      case "max":
+        return vals.reduce((m, v) => v > m ? v : m, vals[0]);
+      case "collect":
+        return JSON.stringify(vals);
+      default:
+        return vals.length;
+    }
+  }
+  _order(bindings, orderBy) {
+    return [...bindings].sort((a, b) => {
+      for (const o of orderBy) {
+        const va = a.get(o.variable);
+        const vb = b.get(o.variable);
+        if (va === vb)
+          continue;
+        if (va === undefined)
+          return 1;
+        if (vb === undefined)
+          return -1;
+        const cmp = va < vb ? -1 : 1;
+        return o.direction === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  _project(bindings, select) {
+    return bindings.map((b) => {
+      const row = {};
+      if (select.length === 0) {
+        for (const [k, v] of b)
+          row[k] = v;
+      } else {
+        for (const s of select) {
+          const v = b.get(s);
+          if (v !== undefined)
+            row[s] = v;
+        }
+      }
+      return row;
+    });
+  }
+  _resolve(term, bindings) {
+    if (isLiteral(term))
+      return term.value;
+    return bindings.get(term.name);
+  }
+  _bind(term, value, bindings) {
+    if (isLiteral(term))
+      return term.value === value;
+    const existing = bindings.get(term.name);
+    if (existing !== undefined)
+      return existing === value;
+    bindings.set(term.name, value);
+    return true;
+  }
+  _dedup(bindings) {
+    const seen = new Set;
+    return bindings.filter((b) => {
+      const key = [...b.entries()].sort(([a], [b2]) => a.localeCompare(b2)).map(([k, v]) => `${k}=${v}`).join("\x00");
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+  }
+}
+
+export { isVariable, isLiteral, variable, literal, QueryEngine };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TrellisVCS — Graph-native, code-first version control
+ *
+ * @module trellisvcs
+ *
+ * Public API surface. Import {@link TrellisVcsEngine} as the main entry point,
+ * plus core VCS types, the {@link FileWatcher}, and the {@link Ingestion}
+ * pipeline.
+ *
+ * For sub-modules, import directly from:
+ *   - `./garden/index.js`   — Idea Garden cluster detection + query
+ *   - `./semantic/index.js` — Semantic parsing + diff/merge
+ *   - `./sync/index.js`     — Peer sync + CRDT reconciler
+ *   - `./identity/index.js` — Ed25519 identity + governance
+ */
+export { TrellisVcsEngine } from './engine.js';
+export * from './vcs/index.js';
+export { FileWatcher } from './watcher/fs-watcher.js';
+export { Ingestion } from './watcher/ingestion.js';
+export { TrellisKernel } from './core/kernel/trellis-kernel.js';
+export { SqliteKernelBackend } from './core/persist/sqlite-backend.js';
+export type { KernelConfig, MutateResult, EntityRecord, } from './core/kernel/trellis-kernel.js';
+export { inferProjectContext, loadProfile, saveProfile, hasProfile, writeAgentScaffold, } from './scaffold/index.js';
+export type { ProjectContext, InferenceConfidence, UserProfile, ScaffoldInput, } from './scaffold/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,aAAa,GACd,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,19 +1,20 @@
 // @bun
-import {
-  VcsMiddleware
-} from "./index-k5kf7sd0.js";
 import {
   FileWatcher,
   Ingestion,
   TrellisVcsEngine,
+  hasProfile,
+  inferProjectContext,
   init_engine,
   init_fs_watcher,
-  init_ingestion
-} from "./index-22jx9qsz.js";
+  init_ingestion,
+  loadProfile,
+  saveProfile,
+  writeAgentScaffold
+} from "./index-q31hfjja.js";
 import {
-  SqliteKernelBackend,
-  TrellisKernel
-} from "./index-hybgxe40.js";
+  VcsMiddleware
+} from "./index-hmdbnd4n.js";
 import {
   BlobStore,
   addCriterion,
@@ -52,7 +53,7 @@ import {
   triageIssue,
   unblockIssue,
   updateIssue
-} from "./index-3ejh8k6v.js";
+} from "./index-0q7wbasy.js";
 import"./index-65z0xfjw.js";
 import {
   DEFAULT_CONFIG,
@@ -68,6 +69,12 @@ import {
   issueEntityId,
   milestoneEntityId
 } from "./index-v9b4hqa7.js";
+import {
+  SqliteKernelBackend,
+  TrellisKernel
+} from "./index-0zk3fx2s.js";
+import"./index-yhwjgfvj.js";
+import"./index-yp88he8n.js";
 import"./index-a76rekgs.js";
 
 // src/index.ts
@@ -75,6 +82,7 @@ init_engine();
 init_fs_watcher();
 init_ingestion();
 export {
+  writeAgentScaffold,
   updateIssue,
   unblockIssue,
   triageIssue,
@@ -83,6 +91,7 @@ export {
   switchBranch,
   startIssue,
   setCriterionStatus,
+  saveProfile,
   saveBranchState,
   runCriteria,
   resumeIssue,
@@ -90,6 +99,7 @@ export {
   pauseIssue,
   myersDiff,
   milestoneEntityId,
+  loadProfile,
   loadBranchState,
   listMilestones,
   listIssues,
@@ -98,6 +108,8 @@ export {
   issueEntityId,
   isVcsOpKind,
   isVcsOp,
+  inferProjectContext,
+  hasProfile,
   getIssue,
   getActiveIssues,
   generateUnifiedDiff,

package/dist/links/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Linked Markdown
+ *
+ * Wiki-link parser, entity reference resolver, and bidirectional
+ * reference index for [[...]] syntax in markdown and doc-comments.
+ *
+ * @see TRL-11
+ */
+export { parseFileRefs, parseMarkdownRefs, parseDocCommentRefs, parseRefContent, inferNamespace, } from './parser.js';
+export { resolveRef, resolveRefs, createResolverContext } from './resolver.js';
+export type { ResolverContext, Enginelike } from './resolver.js';
+export { buildRefIndex, updateFileInIndex, removeFileFromIndex, getOutgoingRefs, getBacklinks, getReferencedEntities, getFilesWithRefs, getIndexStats, } from './ref-index.js';
+export { StaleRefRegistry, buildRenameProposal, applyRenameProposal, handleSymbolDeletion, handleFileDeletion, getDiagnostics, processSemanticPatches, } from './lifecycle.js';
+export type { StaleRef, RefDiagnostic, LifecycleEvent } from './lifecycle.js';
+export type { EntityRef, RefSource, RefContext, RefNamespace, ResolvedRef, RefState, RefIndex, RefUpdateProposal, RefRewrite, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/links/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/links/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC/E,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC9E,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,iBAAiB,EACjB,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/links/lifecycle.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Ref Lifecycle — Rename Prompts & Stale Detection
+ *
+ * Handles the three-tier diagnostic model for wiki-link references:
+ * - Resolved: target exists and resolves
+ * - Stale (warning): target was renamed or deleted, known provenance
+ * - Broken (error): target never existed
+ *
+ * On symbol rename → build a RefUpdateProposal for user confirmation.
+ * On symbol delete → mark affected refs as stale (no file modification).
+ *
+ * @see TRL-14
+ */
+import type { RefIndex, RefSource, RefUpdateProposal, RefState } from './types.js';
+export interface StaleRef {
+    /** The entity ID that became stale */
+    entityId: string;
+    /** Why it became stale */
+    reason: 'renamed' | 'deleted';
+    /** The op hash that caused the staleness */
+    causeOpHash?: string;
+    /** For renames: the new name */
+    newTarget?: string;
+    /** Timestamp when it became stale */
+    timestamp: string;
+    /** Sources that reference this stale entity */
+    sources: RefSource[];
+}
+/**
+ * In-memory stale ref registry.
+ * Maps entity ID → StaleRef.
+ */
+export declare class StaleRefRegistry {
+    private staleRefs;
+    /**
+     * Mark an entity as stale due to rename or deletion.
+     */
+    markStale(entityId: string, reason: 'renamed' | 'deleted', sources: RefSource[], opts?: {
+        causeOpHash?: string;
+        newTarget?: string;
+    }): StaleRef;
+    /**
+     * Remove stale status (e.g. after user accepts rename update).
+     */
+    clearStale(entityId: string): void;
+    /**
+     * Check if an entity is stale.
+     */
+    isStale(entityId: string): boolean;
+    /**
+     * Get stale info for an entity.
+     */
+    getStale(entityId: string): StaleRef | undefined;
+    /**
+     * Get all stale refs.
+     */
+    getAllStale(): StaleRef[];
+    /**
+     * Get stale refs filtered by reason.
+     */
+    getByReason(reason: 'renamed' | 'deleted'): StaleRef[];
+}
+/**
+ * Build a RefUpdateProposal when a symbol is renamed.
+ * Scans the ref index for all references to the old symbol name
+ * and produces a list of rewrites.
+ *
+ * Does NOT modify any files — returns a proposal for user confirmation.
+ */
+export declare function buildRenameProposal(index: RefIndex, filePath: string, oldName: string, newName: string): RefUpdateProposal;
+/**
+ * Apply a RefUpdateProposal by rewriting files.
+ * Reads each affected file, applies the rewrites, and writes back.
+ *
+ * Returns the list of files that were actually modified.
+ */
+export declare function applyRenameProposal(proposal: RefUpdateProposal, rootPath: string): string[];
+/**
+ * Handle a symbol deletion by marking all referencing refs as stale.
+ * Does NOT modify any files.
+ *
+ * Returns the StaleRef entry for diagnostic display.
+ */
+export declare function handleSymbolDeletion(index: RefIndex, registry: StaleRefRegistry, filePath: string, symbolName: string, causeOpHash?: string): StaleRef | null;
+/**
+ * Handle a file deletion by marking all refs to that file (and its symbols) as stale.
+ */
+export declare function handleFileDeletion(index: RefIndex, registry: StaleRefRegistry, filePath: string, causeOpHash?: string): StaleRef | null;
+export type RefDiagnostic = {
+    entityId: string;
+    state: RefState;
+    source: RefSource;
+    message: string;
+};
+/**
+ * Produce diagnostics for all refs in the index.
+ * Combines stale registry info with broken ref detection.
+ */
+export declare function getDiagnostics(index: RefIndex, registry: StaleRefRegistry, resolvedEntityIds: Set<string>): RefDiagnostic[];
+import type { SemanticPatch } from '../semantic/types.js';
+export interface LifecycleEvent {
+    type: 'rename-proposal' | 'stale-detected';
+    filePath: string;
+    proposal?: RefUpdateProposal;
+    staleRef?: StaleRef;
+}
+/**
+ * Process semantic patches and produce lifecycle events.
+ * This is the main integration point — call this when sdiff detects changes.
+ */
+export declare function processSemanticPatches(patches: SemanticPatch[], filePath: string, index: RefIndex, registry: StaleRefRegistry, causeOpHash?: string): LifecycleEvent[];
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/links/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/links/lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/links/parser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Wiki-Link Parser
+ *
+ * Parses [[...]] references from markdown files and doc-comments
+ * in source code. Supports namespaced and bare syntax with smart
+ * namespace inference.
+ *
+ * @see TRL-11
+ */
+import type { EntityRef, RefNamespace } from './types.js';
+/**
+ * Parse all [[...]] references from a file's content.
+ * Detects context (markdown vs doc-comment) based on file extension.
+ */
+export declare function parseFileRefs(content: string, filePath: string): EntityRef[];
+/**
+ * Parse all [[...]] references from markdown content.
+ */
+export declare function parseMarkdownRefs(content: string, filePath: string): EntityRef[];
+/**
+ * Parse [[...]] references from doc-comments in source code.
+ * Extracts comment blocks first, then scans them for wiki-links.
+ */
+export declare function parseDocCommentRefs(content: string, filePath: string, ext?: string): EntityRef[];
+interface ParsedRef {
+    namespace: RefNamespace;
+    target: string;
+    anchor?: string;
+    alias?: string;
+}
+/**
+ * Parse the inner content of a [[...]] wiki-link.
+ *
+ * Supported forms:
+ *   - "namespace:target"           → explicit namespace
+ *   - "namespace:target|alias"     → explicit namespace + alias
+ *   - "namespace:target#anchor"    → explicit namespace + anchor
+ *   - "target"                     → infer namespace
+ *   - "target|alias"               → infer namespace + alias
+ *   - "path#anchor"                → symbol ref
+ *   - "path#anchor|alias"          → symbol ref + alias
+ */
+export declare function parseRefContent(raw: string): ParsedRef | null;
+/**
+ * Infer the namespace from bare ref content.
+ *
+ * Rules (in order):
+ *   1. TRL-\d+ pattern → issue
+ *   2. DEC-\d+ pattern → decision
+ *   3. Has anchor (#) → symbol
+ *   4. Contains '/' or has known file extension → file
+ *   5. Otherwise → null (namespace required)
+ */
+export declare function inferNamespace(target: string, anchor?: string): RefNamespace | null;
+export {};
+//# sourceMappingURL=parser.d.ts.map

package/dist/links/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/links/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAc,YAAY,EAAa,MAAM,YAAY,CAAC;AAqCjF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAS5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAEhF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,GACX,SAAS,EAAE,CAWb;AA2DD,UAAU,SAAS;IACjB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAqC7D;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAiBnF"}

package/dist/links/ref-index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bidirectional Reference Index
+ *
+ * Builds and maintains a bidirectional index of [[...]] references:
+ * - outgoing: source file → EntityRefs it contains
+ * - incoming: target entity ID → RefSources that reference it
+ *
+ * Supports incremental updates when files change.
+ *
+ * @see TRL-13
+ */
+import type { EntityRef, RefIndex, RefSource } from './types.js';
+import type { ResolverContext } from './resolver.js';
+/**
+ * Build a complete RefIndex by scanning all provided file contents.
+ */
+export declare function buildRefIndex(files: Array<{
+    path: string;
+    content: string;
+}>, ctx: ResolverContext): RefIndex;
+/**
+ * Update the index for a single file that was added or modified.
+ * Removes old entries for the file, then re-parses and re-indexes.
+ */
+export declare function updateFileInIndex(index: RefIndex, filePath: string, content: string, ctx: ResolverContext): void;
+/**
+ * Remove all refs originating from a file (e.g. when the file is deleted).
+ */
+export declare function removeFileFromIndex(index: RefIndex, filePath: string): void;
+/**
+ * Get all outgoing refs from a file.
+ */
+export declare function getOutgoingRefs(index: RefIndex, filePath: string): EntityRef[];
+/**
+ * Get all incoming refs (backlinks) for an entity.
+ * Accepts either a raw entity ID (e.g. "issue:TRL-5") or a target string.
+ */
+export declare function getBacklinks(index: RefIndex, entityId: string): RefSource[];
+/**
+ * Get all entity IDs that have at least one backlink.
+ */
+export declare function getReferencedEntities(index: RefIndex): string[];
+/**
+ * Get all files that contain at least one ref.
+ */
+export declare function getFilesWithRefs(index: RefIndex): string[];
+/**
+ * Get total counts for the index.
+ */
+export declare function getIndexStats(index: RefIndex): {
+    totalFiles: number;
+    totalRefs: number;
+    totalEntities: number;
+};
+//# sourceMappingURL=ref-index.d.ts.map

package/dist/links/ref-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-index.d.ts","sourceRoot":"","sources":["../../src/links/ref-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAMrD;;GAEG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EAC/C,GAAG,EAAE,eAAe,GACnB,QAAQ,CAYV;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,eAAe,GACnB,IAAI,CAON;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAsB3E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAE9E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAE3E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,EAAE,CAE/D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,EAAE,CAE1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,CAUA"}