@ctxo/cli 0.13.1 → 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?"
 
@@ -141,6 +141,30 @@ ctxo contexts --json   # the full contexts-view.json
 
 Agents get the same view from `get_architectural_overlay(mode: "contexts")`, and one candidate in full with `candidate: <id>`.
 
+## Cards that go stale
+
+An agent changes the lending rules in code, and the card that describes them stays as it was. Name your bounded contexts in a registry, and Ctxo checks the structure, never the meaning: a context's code changed in the session without a card update or a `Domain-Unchanged` commit trailer, a rule ID that no card defines, a card link that no longer resolves, an edge that crosses a context boundary outside its contracts. The opt-in `@ctxo/domain` package adds the commands and a Claude Code guard; Ctxo never writes the cards.
+
+```shell
+ctxo install domain                       # the opt-in @ctxo/domain package
+ctxo init --domain                        # registry skeleton, fold guard, skill, domain config
+ctxo contexts-touched --since origin/main # which named contexts a branch changed, and which are resolved
+ctxo verify-domain --since origin/main    # CI gate: registry, cards, rule IDs, loader rules, boundaries
+ctxo domain rules --write                 # path-scoped rules that point the agent at the card
+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
 
 | Language | Plugin | Tier | Notes |
@@ -156,6 +180,7 @@ Install via the CLI shortcut:
 ```bash
 ctxo install typescript go csharp   # syntax or full tier auto-detected
 ctxo install sql                    # T-SQL plugin (alias tsql)
+ctxo install domain                 # opt-in domain knowledge layer (@ctxo/domain)
 ctxo install java                   # installs syntax tier; adds full-tier analyzer when JRE 11+ detected
 ctxo install java --full-tier       # force full-tier analyzer install
 ctxo install java --syntax-only     # skip analyzer, syntax tier only

package/dist/chunk-2Q76LH2H.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import {
+  createLogger
+} from "./chunk-5DSKZJNN.js";
+
+// src/adapters/language/plugin-discovery.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { pathToFileURL } from "url";
+import { SUPPORTED_API_VERSIONS } from "@ctxo/plugin-api";
+var log = createLogger("ctxo:plugin-discovery");
+var OFFICIAL_PREFIX = "@ctxo/lang-";
+var COMMUNITY_PREFIX = "ctxo-lang-";
+function readManifestDeps(manifestPath) {
+  try {
+    const raw = readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    const all = {
+      ...manifest.dependencies,
+      ...manifest.devDependencies,
+      ...manifest.peerDependencies
+    };
+    return Object.keys(all).filter(
+      (name) => name.startsWith(OFFICIAL_PREFIX) || name.startsWith(COMMUNITY_PREFIX)
+    );
+  } catch (err) {
+    log.warn(`Failed to read manifest ${manifestPath}: ${err.message}`);
+    return [];
+  }
+}
+function isLocalSpecifier(spec) {
+  return spec.startsWith(".") || spec.startsWith("/") || isAbsolute(spec);
+}
+function pickEsmEntry(exportsField) {
+  if (!exportsField) return void 0;
+  if (typeof exportsField === "string") return exportsField;
+  if (typeof exportsField !== "object") return void 0;
+  const table = exportsField;
+  const dot = "." in table ? table["."] : exportsField;
+  if (typeof dot === "string") return dot;
+  if (!dot || typeof dot !== "object") return void 0;
+  for (const key of ["import", "node", "default"]) {
+    const nested = dot[key];
+    if (typeof nested === "string") return nested;
+    if (nested && typeof nested === "object") {
+      for (const inner of ["default", "import", "node"]) {
+        const v = nested[inner];
+        if (typeof v === "string") return v;
+      }
+    }
+  }
+  return void 0;
+}
+var cliFallbackRequire = createRequire(import.meta.url);
+function resolvePluginPackageJson(specifier, projectRequire) {
+  try {
+    return projectRequire.resolve(`${specifier}/package.json`);
+  } catch (primary) {
+    try {
+      return cliFallbackRequire.resolve(`${specifier}/package.json`);
+    } catch {
+      throw primary;
+    }
+  }
+}
+function readPackageJsonVia(specifier, req) {
+  const files = [];
+  try {
+    files.push(req.resolve(`${specifier}/package.json`));
+  } catch {
+    for (const base of req.resolve.paths(specifier) ?? []) {
+      files.push(join(base, specifier, "package.json"));
+    }
+  }
+  for (const file of files) {
+    try {
+      return { pkgDir: dirname(file), raw: readFileSync(file, "utf-8") };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageCandidates(specifier, projectRoot, cliAnchor) {
+  const lookups = [
+    { source: "project", req: createRequire(join(projectRoot, "package.json")) },
+    {
+      source: "cli",
+      req: cliAnchor === void 0 ? cliFallbackRequire : createRequire(join(cliAnchor, "package.json"))
+    }
+  ];
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { source, req } of lookups) {
+    const read = readPackageJsonVia(specifier, req);
+    if (!read) continue;
+    try {
+      const real = realpathSync(read.pkgDir);
+      if (seen.has(real)) continue;
+      seen.add(real);
+      const pkg = JSON.parse(read.raw);
+      const entry = pickEsmEntry(pkg.exports) ?? pkg.module ?? pkg.main ?? "index.js";
+      found.push({
+        name: pkg.name ?? specifier,
+        version: pkg.version ?? "0.0.0",
+        pkgDir: real,
+        entryUrl: pathToFileURL(resolve(real, entry)).href,
+        source
+      });
+    } catch (err) {
+      log.warn(`Skipped ${specifier} candidate in ${read.pkgDir}: ${err.message}`);
+    }
+  }
+  return found;
+}
+function resolvePluginEntryUrl(specifier, manifestRequire) {
+  const pkgJsonPath = resolvePluginPackageJson(specifier, manifestRequire);
+  const pkgDir = dirname(pkgJsonPath);
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+  const entry = pickEsmEntry(pkgJson.exports) ?? pkgJson.module ?? pkgJson.main ?? "index.js";
+  return pathToFileURL(resolve(pkgDir, entry)).href;
+}
+async function tryLoad(specifier, baseDir, manifestRequire) {
+  try {
+    const target = isLocalSpecifier(specifier) ? pathToFileURL(resolve(baseDir, specifier)).href : resolvePluginEntryUrl(specifier, manifestRequire);
+    const mod = await import(target);
+    const candidate = mod.default ?? mod.plugin ?? mod;
+    if (!candidate || typeof candidate !== "object") {
+      return { specifier, reason: "module export is not an object" };
+    }
+    if (!SUPPORTED_API_VERSIONS.includes(candidate.apiVersion)) {
+      return {
+        specifier,
+        reason: `unsupported apiVersion ${String(candidate.apiVersion)} (supported: ${SUPPORTED_API_VERSIONS.join(", ")})`
+      };
+    }
+    if (typeof candidate.createAdapter !== "function") {
+      return { specifier, reason: "missing createAdapter()" };
+    }
+    if (typeof candidate.id !== "string" || candidate.id.length === 0) {
+      return { specifier, reason: "missing or empty id" };
+    }
+    if (!Array.isArray(candidate.extensions)) {
+      return { specifier, reason: "extensions must be an array" };
+    }
+    if (candidate.tier !== "syntax" && candidate.tier !== "full") {
+      return { specifier, reason: `invalid tier ${String(candidate.tier)}` };
+    }
+    return candidate;
+  } catch (err) {
+    return { specifier, reason: err.message };
+  }
+}
+async function discoverPlugins(options) {
+  const { manifestPath } = options;
+  if (!existsSync(manifestPath)) {
+    log.info(`Manifest not found at ${manifestPath} \u2014 no plugins discovered`);
+    return { plugins: [], failures: [] };
+  }
+  const baseDir = dirname(manifestPath);
+  const specifiers = options.explicit ?? readManifestDeps(manifestPath);
+  const manifestRequire = createRequire(pathToFileURL(manifestPath).href);
+  const plugins = [];
+  const failures = [];
+  for (const spec of specifiers) {
+    if (options.shouldSkipSpecifier?.(spec)) {
+      log.info(`Skipping plugin ${spec} (matched ignoreProjects)`);
+      continue;
+    }
+    const result = await tryLoad(spec, baseDir, manifestRequire);
+    if ("apiVersion" in result) {
+      plugins.push({ plugin: result, specifier: spec });
+    } else {
+      failures.push(result);
+      log.warn(`Skipped plugin ${spec}: ${result.reason}`);
+    }
+  }
+  return { plugins, failures };
+}
+
+export {
+  resolvePluginPackageJson,
+  resolvePackageCandidates,
+  discoverPlugins
+};
+//# sourceMappingURL=chunk-2Q76LH2H.js.map

package/dist/chunk-72CEQEQD.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// src/cli/cli-paths.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+function findCliPackageJson() {
+  let dir = import.meta.dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, "package.json");
+    if (existsSync(pkg)) return pkg;
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function getVersion() {
+  const pkg = findCliPackageJson();
+  if (pkg === void 0) return "unknown";
+  try {
+    const json = JSON.parse(readFileSync(pkg, "utf-8"));
+    return json.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getCliPackageRoot() {
+  const pkg = findCliPackageJson();
+  return pkg !== void 0 ? dirname(pkg) : dirname(import.meta.dirname);
+}
+function locateGitRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 12; i++) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/core/compare-codepoint.ts
+function compareCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export {
+  compareCodepoint,
+  getVersion,
+  getCliPackageRoot,
+  locateGitRoot
+};
+//# sourceMappingURL=chunk-72CEQEQD.js.map