@ctxo/cli 0.14.0 → 0.15.0

package/README.md

@@ -36,7 +36,7 @@ It's not a skill gap. It's a **sensory gap**. The agent is navigating your codeb
 
 The core shift: your agent stops reacting to files it stumbles into and starts planning from a complete map. **Blast radius before the edit. Git intent before the bug fix. Importer list before the rename.**
 
-Ctxo indexes your repo once, kept fresh by file watchers and git hooks, into a deterministic graph: every symbol, every edge (imports, calls, extends, implements, uses, and the data edges reads, writes and executes), every relevant git commit with intent classified, every anti-pattern. All exposed through 14 semantic MCP tools.
+Ctxo indexes your repo once, kept fresh by file watchers and git hooks, into a deterministic graph: every symbol, every edge (imports, calls, extends, implements, uses, and the data edges reads, writes and executes), every relevant git commit with intent classified, every anti-pattern. All exposed through 14 semantic MCP tools, plus 2 domain tools with `@ctxo/domain`.
 
 One `get_blast_radius` call replaces an entire ripgrep/read spiral. One `get_pr_impact` replaces a full review session of "wait, what calls this?"
 
@@ -154,6 +154,15 @@ ctxo domain rules --write                 # path-scoped rules that point the age
 ctxo domain discover                      # propose tracker prefixes and test conventions from the repo
 ```
 
+With cards in place, `ctxo index` links each rule to the tests that pin it and the code that implements it, and the agent sees the rules while it works: `get_blast_radius` lists the rules a change may break and the cards to update, `get_why_context` the decisions behind them, `get_context_for_task` a card excerpt, `get_pr_impact` the contexts touched and the rules without tests. Two tools answer domain questions directly:
+
+| Tool | Answers |
+| --- | --- |
+| `get_domain_context` | The card of the context that owns a symbol or file: terms, rules with their tests and code, contracts, decisions |
+| `get_rule` | One rule by ID: the tests that pin it (and how each was found), the symbols that implement it, the decisions behind it |
+
+`get_ranked_context` with `scope: "domain"` searches the cards and the documents they link to.
+
 See [Ctxo domain conventions v1](docs/features/domain-knowledge.md#ctxo-domain-conventions-v1) for the registry, the card template and the adoption ladder.
 
 ## Supported Languages

package/dist/{chunk-ZL36YS2V.js → chunk-A4URKKPP.js}

@@ -3,7 +3,7 @@ import {
   DATA_EDGE_KINDS,
   createTestFileClassifier,
   filesWithTestAnnotations
-} from "./chunk-7HSA5JVP.js";
+} from "./chunk-I7RPXT6L.js";
 import {
   compareCodepoint
 } from "./chunk-72CEQEQD.js";
@@ -12,7 +12,7 @@ import {
   EDGE_KINDS,
   EdgeKindSchema,
   JsonIndexReader
-} from "./chunk-X4TVFJ4C.js";
+} from "./chunk-EC6INGPV.js";
 import {
   atomicWrite
 } from "./chunk-RFEXMBTG.js";
@@ -1816,184 +1816,10 @@ function fileOf(symbolId) {
   return symbolId.split("::")[0];
 }
 
-// src/core/search/symbol-tokenizer.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "get",
-  "set",
-  "is",
-  "has",
-  "can",
-  "do",
-  "the",
-  "a",
-  "an",
-  "of",
-  "to",
-  "in",
-  "for",
-  "on",
-  "with",
-  "at",
-  "by",
-  "from",
-  "as",
-  "into",
-  "not",
-  "no",
-  "or"
-]);
-var DEFAULT_OPTIONS = {
-  includeStopWords: false,
-  includeOriginal: true,
-  includeFilePath: false
-};
-var SymbolTokenizer = class _SymbolTokenizer {
-  options;
-  constructor(options) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-  }
-  /**
-   * Tokenize a symbol name into searchable tokens.
-   *
-   * Examples:
-   *   "getCoChangeMetrics"    → ["get", "co", "change", "metrics"]  (or without stop words: ["co", "change", "metrics"])
-   *   "SqliteStorageAdapter"  → ["sqlite", "storage", "adapter"]
-   *   "i_storage_port"        → ["i", "storage", "port"]
-   *   "BM25Scorer"            → ["bm", "25", "scorer"]
-   *   "DB_PASSWORD"           → ["db", "password"]
-   */
-  tokenize(symbolName, filePath) {
-    const splitTokens = _SymbolTokenizer.splitName(symbolName);
-    const lowered = splitTokens.map((t) => t.toLowerCase());
-    const tokens = this.options.includeStopWords ? lowered : lowered.filter((t) => !STOP_WORDS.has(t));
-    if (this.options.includeOriginal) {
-      const original = symbolName.toLowerCase();
-      if (!tokens.includes(original)) {
-        tokens.unshift(original);
-      }
-    }
-    if (this.options.includeFilePath && filePath) {
-      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
-      for (const pt of pathTokens) {
-        if (!tokens.includes(pt)) {
-          tokens.push(pt);
-        }
-      }
-    }
-    return tokens;
-  }
-  /**
-   * Tokenize a search query. Queries use stop words and don't include originals.
-   */
-  tokenizeQuery(query) {
-    const words = query.trim().split(/\s+/);
-    const tokens = [];
-    for (const word of words) {
-      const split = _SymbolTokenizer.splitName(word);
-      for (const t of split) {
-        const lowered = t.toLowerCase();
-        if (lowered.length > 0 && !tokens.includes(lowered)) {
-          tokens.push(lowered);
-        }
-      }
-    }
-    return tokens;
-  }
-  /**
-   * Split a name into constituent words based on naming convention boundaries.
-   *
-   * Rules:
-   *  1. Split on underscores and hyphens (snake_case, kebab-case)
-   *  2. Split on camelCase/PascalCase boundaries (uppercase after lowercase)
-   *  3. Split acronym boundaries (e.g., "HTMLParser" → ["HTML", "Parser"])
-   *  4. Split on digit ↔ letter boundaries
-   */
-  static splitName(name) {
-    if (!name || name.length === 0) return [];
-    const segments = name.split(/[_\-./\\]+/).filter((s) => s.length > 0);
-    const tokens = [];
-    for (const segment of segments) {
-      tokens.push(..._SymbolTokenizer.splitCamelCase(segment));
-    }
-    return tokens.filter((t) => t.length > 0);
-  }
-  /**
-   * Split a single segment on camelCase/PascalCase/digit boundaries.
-   */
-  static splitCamelCase(segment) {
-    const tokens = [];
-    let current = "";
-    for (let i = 0; i < segment.length; i++) {
-      const ch = segment[i];
-      const prev = i > 0 ? segment[i - 1] : "";
-      if (current.length > 0) {
-        const prevIsDigit = isDigit(prev);
-        const currIsDigit = isDigit(ch);
-        if (prevIsDigit !== currIsDigit) {
-          tokens.push(current);
-          current = ch;
-          continue;
-        }
-      }
-      if (current.length > 0 && isLower(prev) && isUpper(ch)) {
-        tokens.push(current);
-        current = ch;
-        continue;
-      }
-      if (current.length > 1 && isUpper(ch) === false && isUpper(prev) && !isDigit(ch)) {
-        const lastChar = current[current.length - 1];
-        if (isUpper(lastChar)) {
-          tokens.push(current.slice(0, -1));
-          current = lastChar + ch;
-          continue;
-        }
-      }
-      current += ch;
-    }
-    if (current.length > 0) {
-      tokens.push(current);
-    }
-    return tokens;
-  }
-  /**
-   * Extract searchable tokens from a file path.
-   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
-   */
-  static tokenizeFilePath(filePath) {
-    const withoutExt = filePath.replace(/\.[^.]+$/, "");
-    const segments = withoutExt.split(/[/\\]+/);
-    const tokens = [];
-    for (const seg of segments) {
-      const parts = seg.split(/[_\-.]+/).filter((s) => s.length > 0);
-      for (const p of parts) {
-        const lowered = p.toLowerCase();
-        if (lowered.length > 0 && !tokens.includes(lowered)) {
-          tokens.push(lowered);
-        }
-      }
-    }
-    return tokens;
-  }
-  /** Check if a token is a stop word */
-  static isStopWord(token) {
-    return STOP_WORDS.has(token.toLowerCase());
-  }
-};
-function isUpper(ch) {
-  return ch >= "A" && ch <= "Z";
-}
-function isLower(ch) {
-  return ch >= "a" && ch <= "z";
-}
-function isDigit(ch) {
-  return ch >= "0" && ch <= "9";
-}
-
 export {
   detectWorkspace,
   buildCoChangeMatrix,
   CoChangeReader,
-  SymbolTokenizer,
   CommunitySnapshotWriter,
   SqliteStorageAdapter,
   RevertDetector,
@@ -2007,4 +1833,4 @@ export {
   findCoChangedFilesForBlastRadius,
   ContextsViewReader
 };
-//# sourceMappingURL=chunk-ZL36YS2V.js.map
+//# sourceMappingURL=chunk-A4URKKPP.js.map

package/dist/{chunk-SRQZDGFZ.js → chunk-BBSJB4CG.js}

@@ -96,7 +96,7 @@ async function loadModulesFor(projectRoot, mode, options = {}) {
       import("./plugin-discovery-XRXI3IJF.js")
     ]);
     if (resolvePackageCandidates(DOMAIN_MODULE_PACKAGE, projectRoot, options.cliAnchor).length === 0) return [];
-    const { createModuleHost } = await import("./module-host-KNMKS62R.js");
+    const { createModuleHost } = await import("./module-host-KTGDODES.js");
     const { modules } = await loadCtxoModules(createModuleHost({ projectRoot, mode }), { cliAnchor: options.cliAnchor });
     return modules;
   } catch (err) {
@@ -125,4 +125,4 @@ export {
   loadModulesFor,
   runFastRoute
 };
-//# sourceMappingURL=chunk-SRQZDGFZ.js.map
+//# sourceMappingURL=chunk-BBSJB4CG.js.map

package/dist/{chunk-X4TVFJ4C.js → chunk-EC6INGPV.js}

@@ -266,4 +266,4 @@ export {
   isMarkedArtifact,
   JsonIndexReader
 };
-//# sourceMappingURL=chunk-X4TVFJ4C.js.map
+//# sourceMappingURL=chunk-EC6INGPV.js.map

package/dist/{chunk-7HSA5JVP.js → chunk-I7RPXT6L.js}

@@ -6,6 +6,197 @@ import {
   createLogger
 } from "./chunk-5DSKZJNN.js";
 
+// src/core/search/symbol-tokenizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "is",
+  "has",
+  "can",
+  "do",
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "not",
+  "no",
+  "or"
+]);
+var DEFAULT_OPTIONS = {
+  includeStopWords: false,
+  includeOriginal: true,
+  includeFilePath: false
+};
+var SymbolTokenizer = class _SymbolTokenizer {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Tokenize a symbol name into searchable tokens.
+   *
+   * Examples:
+   *   "getCoChangeMetrics"    → ["get", "co", "change", "metrics"]  (or without stop words: ["co", "change", "metrics"])
+   *   "SqliteStorageAdapter"  → ["sqlite", "storage", "adapter"]
+   *   "i_storage_port"        → ["i", "storage", "port"]
+   *   "BM25Scorer"            → ["bm", "25", "scorer"]
+   *   "DB_PASSWORD"           → ["db", "password"]
+   */
+  tokenize(symbolName, filePath) {
+    const splitTokens = _SymbolTokenizer.splitName(symbolName);
+    const lowered = splitTokens.map((t) => t.toLowerCase());
+    const tokens = this.options.includeStopWords ? lowered : lowered.filter((t) => !STOP_WORDS.has(t));
+    if (this.options.includeOriginal) {
+      const original = symbolName.toLowerCase();
+      if (!tokens.includes(original)) {
+        tokens.unshift(original);
+      }
+    }
+    if (this.options.includeFilePath && filePath) {
+      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
+      for (const pt of pathTokens) {
+        if (!tokens.includes(pt)) {
+          tokens.push(pt);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Tokenize prose (a document title or body). Words are runs of letters, digits, `_` and `-`; each word is
+   * split like a symbol name (camelCase, snake_case, rule IDs such as `LEND-03`) and lowercased. Stop words
+   * are dropped; repeats are kept, so BM25 sees the term frequency.
+   *
+   *   "A member holds LoanPolicy LEND-03" → ["member", "holds", "loan", "policy", "lend", "03"]
+   */
+  tokenizeText(text) {
+    const tokens = [];
+    for (const word of text.split(/[^\p{L}\p{N}_-]+/u)) {
+      if (word.length === 0) continue;
+      for (const part of _SymbolTokenizer.splitName(word)) {
+        const lowered = part.toLowerCase();
+        if (!STOP_WORDS.has(lowered)) tokens.push(lowered);
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Tokenize a search query. Queries use stop words and don't include originals.
+   */
+  tokenizeQuery(query) {
+    const words = query.trim().split(/\s+/);
+    const tokens = [];
+    for (const word of words) {
+      const split = _SymbolTokenizer.splitName(word);
+      for (const t of split) {
+        const lowered = t.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Split a name into constituent words based on naming convention boundaries.
+   *
+   * Rules:
+   *  1. Split on underscores and hyphens (snake_case, kebab-case)
+   *  2. Split on camelCase/PascalCase boundaries (uppercase after lowercase)
+   *  3. Split acronym boundaries (e.g., "HTMLParser" → ["HTML", "Parser"])
+   *  4. Split on digit ↔ letter boundaries
+   */
+  static splitName(name) {
+    if (!name || name.length === 0) return [];
+    const segments = name.split(/[_\-./\\]+/).filter((s) => s.length > 0);
+    const tokens = [];
+    for (const segment of segments) {
+      tokens.push(..._SymbolTokenizer.splitCamelCase(segment));
+    }
+    return tokens.filter((t) => t.length > 0);
+  }
+  /**
+   * Split a single segment on camelCase/PascalCase/digit boundaries.
+   */
+  static splitCamelCase(segment) {
+    const tokens = [];
+    let current = "";
+    for (let i = 0; i < segment.length; i++) {
+      const ch = segment[i];
+      const prev = i > 0 ? segment[i - 1] : "";
+      if (current.length > 0) {
+        const prevIsDigit = isDigit(prev);
+        const currIsDigit = isDigit(ch);
+        if (prevIsDigit !== currIsDigit) {
+          tokens.push(current);
+          current = ch;
+          continue;
+        }
+      }
+      if (current.length > 0 && isLower(prev) && isUpper(ch)) {
+        tokens.push(current);
+        current = ch;
+        continue;
+      }
+      if (current.length > 1 && isUpper(ch) === false && isUpper(prev) && !isDigit(ch)) {
+        const lastChar = current[current.length - 1];
+        if (isUpper(lastChar)) {
+          tokens.push(current.slice(0, -1));
+          current = lastChar + ch;
+          continue;
+        }
+      }
+      current += ch;
+    }
+    if (current.length > 0) {
+      tokens.push(current);
+    }
+    return tokens;
+  }
+  /**
+   * Extract searchable tokens from a file path.
+   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
+   */
+  static tokenizeFilePath(filePath) {
+    const withoutExt = filePath.replace(/\.[^.]+$/, "");
+    const segments = withoutExt.split(/[/\\]+/);
+    const tokens = [];
+    for (const seg of segments) {
+      const parts = seg.split(/[_\-.]+/).filter((s) => s.length > 0);
+      for (const p of parts) {
+        const lowered = p.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /** Check if a token is a stop word */
+  static isStopWord(token) {
+    return STOP_WORDS.has(token.toLowerCase());
+  }
+};
+function isUpper(ch) {
+  return ch >= "A" && ch <= "Z";
+}
+function isLower(ch) {
+  return ch >= "a" && ch <= "z";
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+
 // src/core/co-change/co-change-window.ts
 var SINCE_PATTERN = /^(\d+)([dwmy])$/;
 var SECONDS_PER_DAY = 86400;
@@ -1022,6 +1213,7 @@ var SymbolGraph = class {
 };
 
 export {
+  SymbolTokenizer,
   parseCoChangeSince,
   windowCutoff,
   selectWindow,
@@ -1046,4 +1238,4 @@ export {
   isDataResourceKind,
   SymbolGraph
 };
-//# sourceMappingURL=chunk-7HSA5JVP.js.map
+//# sourceMappingURL=chunk-I7RPXT6L.js.map