@esneiderbravo/speclaw 0.4.0 → 1.0.1

package/dist/modules/foundation/doctor.js

@@ -5,14 +5,18 @@ import { isMinimalMode, packageRoot } from "../../shared/exposure.js";
 import { isGitRepo } from "../../shared/git.js";
 import { readManifest } from "../../shared/manifest.js";
 import { pkgName, pkgVersion } from "../../shared/version.js";
-import { indexExists, openDb } from "../compass/db.js";
+import { indexExists, openDb, probeFts5Support } from "../compass/db.js";
+import { getEmbedder } from "../compass/embedder.js";
 import { specList } from "../lawbook/engine.js";
 import { doctorDriftCheck } from "../lawbook/drift.js";
 import { loadCeremonyConfig } from "../lawbook/levels.js";
+import { doctorOwnersChecks } from "../team/owners.js";
 import { globError, hasBackend, hasBatchBackend, readLawManifest } from "./laws.js";
+import { estimateAlwaysOnTokens } from "./compile-laws.js";
 import { redactValue } from "../../shared/redact.js";
 import { readDeprecatedCallCounts, scanRetiredToolReferences } from "../../shared/deprecation.js";
 import { CANONICAL_TOOLS, ALIAS_TARGETS, isCanonicalTool } from "../../shared/tool-catalog.js";
+import { discoverIntegrityPaths, lockfilePath, readLockfile, rootDigest } from "./lock.js";
 const STATUS_RANK = {
     skip: 0,
     ok: 1,
@@ -48,18 +52,29 @@ function detectInstallKind() {
 function enginesRequirement() {
     try {
         const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot(), "package.json"), "utf8"));
-        return pkg.engines?.node ?? ">=22";
+        return pkg.engines?.node ?? ">=22.16";
     }
     catch {
-        return ">=22";
+        return ">=22.16";
     }
 }
 function nodeSatisfies(required, version) {
-    const m = /^>=\s*(\d+)/.exec(required.trim());
+    const m = /^>=\s*(\d+)(?:\.(\d+))?/.exec(required.trim());
     if (!m)
         return true;
-    const major = parseInt(version.replace(/^v/, "").split(".")[0], 10);
-    return major >= parseInt(m[1], 10);
+    const parts = version
+        .replace(/^v/, "")
+        .split(".")
+        .map((x) => parseInt(x, 10));
+    const major = parts[0] ?? 0;
+    const minor = parts[1] ?? 0;
+    const needMajor = parseInt(m[1], 10);
+    const needMinor = m[2] !== undefined ? parseInt(m[2], 10) : 0;
+    if (major > needMajor)
+        return true;
+    if (major < needMajor)
+        return false;
+    return minor >= needMinor;
 }
 function libcLabel() {
     if (process.platform !== "linux")
@@ -179,6 +194,25 @@ function buildEnvironment(projectPath) {
         detail: git ? "repository" : "not a git repository",
         remedy: git ? undefined : "git init",
     });
+    const ftsOk = probeFts5Support();
+    addCheck(checks, {
+        id: "env.fts5",
+        title: "fts5",
+        status: ftsOk ? "ok" : "warn",
+        value: ftsOk,
+        detail: ftsOk
+            ? "node:sqlite FTS5 available"
+            : "FTS5 unavailable — hybrid search degrades to vector+name (need Node >=22.16)",
+        remedy: ftsOk ? undefined : "Upgrade to Node.js >=22.16",
+    });
+    const embedderId = getEmbedder().id;
+    addCheck(checks, {
+        id: "env.embedder",
+        title: "embedder",
+        status: "ok",
+        value: embedderId,
+        detail: `active embedder: ${embedderId}`,
+    });
     addCheck(checks, {
         id: "env.ast-engine",
         title: "ast engine",
@@ -369,12 +403,23 @@ function lawsCheck(projectPath) {
     }
     const withPath = manifest.laws.filter(hasBackend).length;
     const withBatch = manifest.laws.filter(hasBatchBackend).length;
+    const budget = estimateAlwaysOnTokens(manifest.laws);
+    if (budget.total > 2000) {
+        const top = budget.top.map((t) => `${t.id}(~${t.tokens})`).join(", ");
+        return {
+            id: "cfg.laws",
+            title: "laws",
+            status: "warn",
+            detail: `always-on laws ~${budget.total} tokens (budget 2000); top: ${top || "n/a"}`,
+            remedy: "Add scope globs to the largest always-on laws, then speclaw laws compile",
+        };
+    }
     return {
         id: "cfg.laws",
         title: "laws",
         status: "ok",
         value: manifest.laws.length,
-        detail: `${manifest.laws.length} declared · ${withPath} path · ${withBatch} deps/graph · 0 invalid`,
+        detail: `${manifest.laws.length} declared · ${withPath} path · ${withBatch} deps/graph · always-on ~${budget.total} tokens`,
     };
 }
 async function budgetCheck(projectPath) {
@@ -512,6 +557,154 @@ function specsOrphansCheck(projectPath) {
         remedy: `speclaw lawbook archive ${active[0]}`,
     };
 }
+function integrityChecks(projectPath) {
+    // Covers: req~doctor-integrity~1
+    const out = [];
+    const abs = lockfilePath(projectPath);
+    if (!fs.existsSync(abs)) {
+        out.push({
+            id: "cfg.integrity.lock",
+            title: "rule lockfile",
+            status: "warn",
+            detail: "no speclaw.lock — rule digests are not pinned",
+            remedy: "speclaw laws lock",
+        });
+    }
+    else {
+        try {
+            const lock = readLockfile(projectPath);
+            const matches = rootDigest(lock.files) === lock.root;
+            out.push({
+                id: "cfg.integrity.lock",
+                title: "rule lockfile",
+                status: matches ? "ok" : "warn",
+                value: matches,
+                detail: matches
+                    ? `speclaw.lock root matches (${Object.keys(lock.files).length} files)`
+                    : "speclaw.lock root does not match recomputed digests",
+                remedy: matches ? undefined : "speclaw laws lock",
+            });
+        }
+        catch (err) {
+            out.push({
+                id: "cfg.integrity.lock",
+                title: "rule lockfile",
+                status: "error",
+                detail: err.message,
+                remedy: "speclaw laws lock",
+            });
+        }
+    }
+    const imports = findExternalImports(projectPath, 4);
+    out.push({
+        id: "cfg.integrity.imports",
+        title: "external rule imports",
+        status: imports.length ? "warn" : "ok",
+        value: imports.length ? imports.slice(0, 8).join("; ") : null,
+        detail: imports.length
+            ? `${imports.length} external @import hop(s) (≤4): ${imports.slice(0, 5).join("; ")}`
+            : "no external @import / @~/ paths detected in rule files",
+        remedy: imports.length
+            ? "review imports that resolve outside the working directory"
+            : undefined,
+    });
+    const { files } = discoverIntegrityPaths(projectPath);
+    const outside = files.filter((f) => {
+        const n = f.split("\\").join("/");
+        return (n === ".clinerules" ||
+            n === ".windsurfrules" ||
+            n === "BUGBOT.md" ||
+            n === ".cursorrules" ||
+            n.startsWith("ai-specs/skills/") ||
+            n.startsWith(".claude/skills/"));
+    });
+    out.push({
+        id: "cfg.integrity.outside-pipeline",
+        title: "outside-pipeline rules",
+        status: "ok",
+        value: outside.length,
+        detail: outside.length > 0
+            ? `${outside.length} scan-only / outside-pipeline path(s): ${outside.slice(0, 6).join(", ")}`
+            : "no outside-pipeline rule files discovered",
+    });
+    return out;
+}
+/**
+ * Follow `@~/…`, absolute `@/…`, and `@import "…"` targets outside the project,
+ * transitively up to `maxHops`.
+ */
+/* node:coverage disable */
+function findExternalImports(projectPath, maxHops) {
+    const roots = [
+        "CLAUDE.md",
+        "AGENTS.md",
+        "LAWS.md",
+        ".cursorrules",
+        ".clinerules",
+        ".windsurfrules",
+    ];
+    const seen = new Set();
+    const out = [];
+    const queue = [];
+    for (const r of roots) {
+        const abs = path.join(projectPath, r);
+        if (fs.existsSync(abs))
+            queue.push({ file: abs, hop: 0 });
+    }
+    while (queue.length) {
+        const { file, hop } = queue.shift();
+        if (hop > maxHops || seen.has(file))
+            continue;
+        seen.add(file);
+        let text;
+        try {
+            text = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split(/\r?\n/)) {
+            const m = /@([~/][^\s)\]>"']+)/.exec(line) ??
+                /@import\s+["']([^"']+)["']/.exec(line) ??
+                /@([A-Za-z]:[^\s)\]>"']+)/.exec(line);
+            if (!m)
+                continue;
+            const target = m[1];
+            const resolved = resolveImportTarget(file, target);
+            if (!resolved)
+                continue;
+            const projectRoot = path.resolve(projectPath);
+            const outside = target.startsWith("~/") ||
+                path.isAbsolute(target) ||
+                !resolved.startsWith(projectRoot + path.sep);
+            if (outside) {
+                const label = `${path.relative(projectPath, file) || path.basename(file)} → ${target}`;
+                out.push(label);
+                if (hop < maxHops && fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+                    queue.push({ file: resolved, hop: hop + 1 });
+                }
+            }
+        }
+    }
+    return out;
+}
+function resolveImportTarget(fromFile, target) {
+    if (target.startsWith("~/")) {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        if (!home)
+            return null;
+        return path.resolve(home, target.slice(2));
+    }
+    if (target.startsWith("/") || /^[A-Za-z]:/.test(target))
+        return path.resolve(target);
+    if (target.startsWith("./") || target.startsWith("../")) {
+        return path.resolve(path.dirname(fromFile), target);
+    }
+    if (!target.includes("://"))
+        return path.resolve(path.dirname(fromFile), target);
+    return null;
+}
+/* node:coverage enable */
 /** Ceremony config validity + archived level histogram. */
 function ceremonyChecks(projectPath) {
     const out = [];
@@ -617,13 +810,16 @@ function configurationChecks(projectPath, initialised) {
             "cfg.index.freshness",
             "cfg.specs.orphans",
         ];
-        return ids.map((id) => ({
-            id,
-            title: id.replace(/^cfg\./, ""),
-            status: "skip",
-            detail: "project not initialised",
-            remedy: "speclaw init",
-        }));
+        return [
+            ...ids.map((id) => ({
+                id,
+                title: id.replace(/^cfg\./, ""),
+                status: "skip",
+                detail: "project not initialised",
+                remedy: "speclaw init",
+            })),
+            ...integrityChecks(projectPath),
+        ];
     }
     const checks = [];
     const manifest = readManifest(projectPath);
@@ -650,6 +846,7 @@ function configurationChecks(projectPath, initialised) {
         remedy: "speclaw update",
     });
     checks.push(lawsCheck(projectPath));
+    checks.push(...integrityChecks(projectPath));
     // budget + mcp + freshness + specs filled async by caller
     return checks;
 }
@@ -709,6 +906,15 @@ export async function doctor(projectPath, opts = {}) {
                 remedy: d.remedy,
             });
         }
+        for (const o of doctorOwnersChecks(projectPath)) {
+            addCheck(configuration, {
+                id: o.id,
+                title: o.title,
+                status: o.status,
+                detail: o.detail,
+                remedy: o.remedy,
+            });
+        }
         const configured = detectConfiguredAgents(projectPath);
         const mcpAgents = AGENTS.filter((a) => a.mcpFile && configured.includes(a.id));
         if (mcpAgents.length === 0) {

package/dist/modules/foundation/graph.js

@@ -1,6 +1,7 @@
+import { matchesScope } from "./laws.js";
 import { underPaths } from "./verify-model.js";
-/** Build the cross-file dependency graph, restricted to `paths` when given. */
-function buildGraph(db, paths, edgeKinds) {
+/** Build the cross-file dependency graph, restricted to `paths` and `scope`. */
+function buildGraph(db, paths, edgeKinds, scope) {
     const kindFilter = edgeKinds && edgeKinds.length > 0
         ? ` AND e.kind IN (${edgeKinds.map(() => "?").join(", ")})`
         : "";
@@ -16,6 +17,8 @@ function buildGraph(db, paths, edgeKinds) {
     for (const { src, dst } of rows) {
         if (!underPaths(src, paths) || !underPaths(dst, paths))
             continue;
+        if (!matchesScope(scope, src) || !matchesScope(scope, dst))
+            continue;
         const list = adj.get(src);
         if (list)
             list.push(dst);
@@ -205,8 +208,9 @@ function reachableFindings(law, rule, adj) {
  *   resolved graph, so a graph law never reports an unknown here).
  */
 export function runGraphLaw(db, law, paths) {
+    // Covers: req~graph-honours-scope~1
     const rule = law.verification.rule;
-    const adj = buildGraph(db, paths, rule.edgeKinds);
+    const adj = buildGraph(db, paths, rule.edgeKinds, law.scope);
     const findings = [];
     const wantReachable = rule.reachable === true && rule.from != null && rule.to != null;
     const wantCircular = rule.circular === true || (!rule.circular && !wantReachable);

package/dist/modules/foundation/import-rules.js

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readLawManifest, writeLawManifest } from "./laws.js";
+/**
+ * Import rulesync-style markdown rules under `.rulesync/` or `rulesync/` into
+ * draft semantic laws and append them to the manifest.
+ */
+export function importRulesFrom(projectPath, from) {
+    if (from !== "rulesync") {
+        throw new Error(`unsupported import source "${from}" — try rulesync`);
+    }
+    const candidates = [".rulesync", "rulesync", ".rulesync/rules", "rulesync/rules"];
+    let root = null;
+    for (const c of candidates) {
+        const abs = path.join(projectPath, c);
+        if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+            root = abs;
+            break;
+        }
+    }
+    if (!root) {
+        throw new Error("no rulesync rules directory found (.rulesync/ or rulesync/)");
+    }
+    const report = { imported: [], skipped: [] };
+    const existing = readLawManifest(projectPath) ?? { version: 1, laws: [] };
+    const have = new Set(existing.laws.map((l) => l.id));
+    const walk = (dir) => {
+        for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+            const abs = path.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                walk(abs);
+                continue;
+            }
+            if (!/\.(md|mdc)$/i.test(ent.name))
+                continue;
+            const rel = path.relative(projectPath, abs).split(path.sep).join("/");
+            const prose = fs.readFileSync(abs, "utf8").trim() || "(empty rule)";
+            const slug = ent.name
+                .replace(/\.(md|mdc)$/i, "")
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, "-")
+                .replace(/^-|-$/g, "");
+            const id = `law~import-rulesync-${slug}~1`;
+            if (have.has(id)) {
+                report.skipped.push(id);
+                continue;
+            }
+            const law = {
+                id,
+                title: `Imported: ${ent.name}`,
+                severity: "warn",
+                scope: [],
+                prose,
+                verification: { kind: "semantic" },
+                enforcement: "feedback",
+                source: { file: rel, line: 1 },
+                status: "draft",
+            };
+            existing.laws.push(law);
+            have.add(id);
+            report.imported.push(id);
+        }
+    };
+    walk(root);
+    writeLawManifest(projectPath, existing);
+    return report;
+}