kibi-cli 2.0.0 → 2.1.0

package/dist/plugins/resolve-package.js

@@ -0,0 +1,262 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PluginValidationError } from "kibi-plugin-sdk";
+import { readProjectPackageJson, } from "./project-config.js";
+// implements REQ-capability-plugin-activation-disclosure-v1
+export class PluginResolutionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "PluginResolutionError";
+        this.code = code;
+    }
+}
+function readJson(path) {
+    return JSON.parse(fs.readFileSync(path, "utf8"));
+}
+function nextAncestorDirectory(current) {
+    const parent = dirname(current);
+    return parent === current ? undefined : parent;
+}
+function isWithinRoot(rootPath, candidatePath) {
+    const relativePath = relative(resolve(rootPath), resolve(candidatePath));
+    return (relativePath === "" ||
+        (!relativePath.startsWith("..") && !isAbsolute(relativePath)));
+}
+/**
+ * Bare npm package names only. Paths, URLs, subpaths, and aliases are rejected.
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function isBarePackageName(packageName) {
+    const trimmed = packageName.trim();
+    if (!trimmed || trimmed !== packageName)
+        return false;
+    if (trimmed.startsWith(".") ||
+        trimmed.startsWith("/") ||
+        trimmed.includes(":") ||
+        trimmed.includes("\\") ||
+        trimmed.includes("..")) {
+        return false;
+    }
+    // Reject subpath imports (`pkg/sub`) and Windows drive paths.
+    if (trimmed.includes("/") && !trimmed.startsWith("@"))
+        return false;
+    if (trimmed.startsWith("@")) {
+        const parts = trimmed.split("/");
+        if (parts.length !== 2 || !parts[0] || !parts[1])
+            return false;
+        if (parts[1].includes("/"))
+            return false;
+    }
+    return true;
+}
+// implements REQ-capability-plugin-activation-disclosure-v1, REQ-capability-plugin-observable-behavior-v1
+export function assertBarePackageName(packageName) {
+    if (!isBarePackageName(packageName)) {
+        throw new PluginResolutionError("INVALID_PACKAGE_REFERENCE", `Plugin package '${packageName}' must be a bare package name; paths, URLs, and subpaths are rejected`);
+    }
+}
+// implements REQ-capability-plugin-activation-disclosure-v1, REQ-capability-plugin-observable-behavior-v1
+export function hasDeclaredProjectDependency(workspaceRoot, packageName, manifest) {
+    const packageJson = manifest ?? readProjectPackageJson(workspaceRoot);
+    return [
+        packageJson.dependencies,
+        packageJson.devDependencies,
+        packageJson.optionalDependencies,
+    ].some((dependencies) => Boolean(dependencies &&
+        typeof dependencies === "object" &&
+        dependencies[packageName]));
+}
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function hasConsumerNodeModulesLink(workspaceRoot, packageName, packageRoot) {
+    try {
+        const linkPath = join(workspaceRoot, "node_modules", ...packageName.split("/"));
+        const linkedRoot = fs.realpathSync(linkPath);
+        return (isWithinRoot(linkedRoot, packageRoot) ||
+            isWithinRoot(packageRoot, linkedRoot));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Same project-scope policy as packages/cursor/bin/launch-kibi-mcp.mjs:
+ * within workspace OR node_modules symlink OR Yarn PnP active resolver.
+ * Rejects NODE_PATH / global / ambient packages.
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1, REQ-capability-plugin-observable-behavior-v1
+export function isProjectScopedPackage(workspaceRoot, packageName, packageRoot) {
+    if (isWithinRoot(workspaceRoot, packageRoot))
+        return true;
+    return (hasConsumerNodeModulesLink(workspaceRoot, packageName, packageRoot) ||
+        Boolean(process.versions.pnp));
+}
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function packageJsonForResolvedFile(startPath, expectedPackageName) {
+    let current = resolve(startPath);
+    try {
+        if (!fs.statSync(current).isDirectory())
+            current = dirname(current);
+    }
+    catch {
+        current = dirname(current);
+    }
+    let cursor = current;
+    while (cursor !== undefined) {
+        const packageJsonPath = join(cursor, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = readJson(packageJsonPath);
+                if (packageJson.name === expectedPackageName) {
+                    return { packageJsonPath, packageRoot: cursor, packageJson };
+                }
+            }
+            catch {
+                // Keep walking if a parent package manifest is malformed.
+            }
+        }
+        cursor = nextAncestorDirectory(cursor);
+    }
+    return null;
+}
+/**
+ * Confine a resolved entry to the realpath'd package root. Rejects
+ * `exports`/`main` traversal and symlink escapes.
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function assertResolvedEntryInsidePackageRoot(packageRoot, entryPath) {
+    let realRoot;
+    try {
+        realRoot = fs.realpathSync(packageRoot);
+    }
+    catch {
+        throw new PluginResolutionError("PACKAGE_NOT_FOUND", `Plugin package root '${packageRoot}' is not readable`);
+    }
+    let realEntry;
+    try {
+        const stats = fs.statSync(entryPath);
+        if (!stats.isFile()) {
+            throw new PluginResolutionError("PACKAGE_ENTRY_NOT_FILE", `Plugin package entry '${entryPath}' is not a regular file`);
+        }
+        realEntry = fs.realpathSync(entryPath);
+    }
+    catch (error) {
+        if (error instanceof PluginResolutionError)
+            throw error;
+        throw new PluginResolutionError("PACKAGE_ENTRY_NOT_FOUND", `Plugin package entry '${entryPath}' does not exist`);
+    }
+    if (!isWithinRoot(realRoot, realEntry)) {
+        throw new PluginResolutionError("PACKAGE_ENTRY_OUTSIDE_ROOT", `Resolved plugin entry '${realEntry}' is outside package root '${realRoot}'`);
+    }
+    return realEntry;
+}
+function candidateFromManifest(packageJson) {
+    const exportsField = packageJson.exports;
+    if (typeof exportsField === "string")
+        return exportsField;
+    if (exportsField &&
+        typeof exportsField === "object" &&
+        !Array.isArray(exportsField)) {
+        const rootExport = exportsField["."];
+        if (typeof rootExport === "string")
+            return rootExport;
+        if (rootExport &&
+            typeof rootExport === "object" &&
+            !Array.isArray(rootExport)) {
+            const conditional = rootExport;
+            if (typeof conditional.import === "string")
+                return conditional.import;
+            if (typeof conditional.default === "string")
+                return conditional.default;
+            if (typeof conditional.require === "string")
+                return conditional.require;
+        }
+    }
+    if (typeof packageJson.module === "string")
+        return packageJson.module;
+    if (typeof packageJson.main === "string")
+        return packageJson.main;
+    return undefined;
+}
+function resolvePackageEntryWithNode(packageRoot, packageJson, packageName, consumerRequire) {
+    let resolved;
+    try {
+        resolved = consumerRequire.resolve(packageName);
+    }
+    catch {
+        resolved = undefined;
+    }
+    if (resolved === undefined) {
+        const candidate = candidateFromManifest(packageJson);
+        if (candidate) {
+            resolved = resolve(packageRoot, candidate);
+        }
+    }
+    if (resolved === undefined) {
+        throw new PluginResolutionError("PACKAGE_ENTRY_NOT_FOUND", `Node could not resolve the root export of '${packageName}' from ${packageRoot}`);
+    }
+    const entryPath = assertResolvedEntryInsidePackageRoot(packageRoot, resolved);
+    return { entryPath, entryUrl: pathToFileURL(entryPath).href };
+}
+/**
+ * Resolve a declared project-local plugin package through the workspace
+ * package.json require graph. NODE_PATH / global / path / URL references fail.
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function resolveProjectLocalPackage(workspaceRoot, packageName) {
+    assertBarePackageName(packageName);
+    const root = resolve(workspaceRoot);
+    const manifest = readProjectPackageJson(root);
+    if (!hasDeclaredProjectDependency(root, packageName, manifest)) {
+        throw new PluginResolutionError("UNDECLARED_DEPENDENCY", `Plugin package '${packageName}' must be listed in dependencies, devDependencies, or optionalDependencies of ${join(root, "package.json")}`);
+    }
+    const consumerRequire = createRequire(join(root, "package.json"));
+    let packageInfo = null;
+    try {
+        packageInfo = packageJsonForResolvedFile(consumerRequire.resolve(`${packageName}/package.json`), packageName);
+    }
+    catch {
+        try {
+            packageInfo = packageJsonForResolvedFile(consumerRequire.resolve(packageName), packageName);
+        }
+        catch {
+            packageInfo = null;
+        }
+    }
+    if (!packageInfo) {
+        throw new PluginResolutionError("PACKAGE_NOT_FOUND", `No project-local package '${packageName}' was found for ${root}. Install it in that workspace and retry.`);
+    }
+    if (!isProjectScopedPackage(root, packageName, packageInfo.packageRoot)) {
+        throw new PluginResolutionError("PACKAGE_OUTSIDE_WORKSPACE", `Resolved '${packageName}' outside the consumer workspace: ${packageInfo.packageRoot}. Install it in ${root}; global, NODE_PATH, and ambient packages are not supported.`);
+    }
+    const { entryPath, entryUrl } = resolvePackageEntryWithNode(packageInfo.packageRoot, packageInfo.packageJson, packageName, consumerRequire);
+    return {
+        packageName,
+        packageRoot: packageInfo.packageRoot,
+        packageJsonPath: packageInfo.packageJsonPath,
+        packageJson: packageInfo.packageJson,
+        entryPath,
+        entryUrl,
+    };
+}
+/** Re-export for callers that catch SDK validation failures as resolution errors. */
+export { PluginValidationError };

package/dist/plugins/source-analysis-service.d.ts

@@ -0,0 +1,44 @@
+import { type PluginProviderStamp, type SourceAnalysisResult, type SymbolExtractorV1 } from "kibi-plugin-sdk";
+import type { CapabilityModeResolution, CapabilityRegistry } from "./registry.js";
+export type HostSourceAnalysisShadowComparison = Readonly<{
+    pluginId: string;
+    stamp: PluginProviderStamp;
+    symbolCount: number;
+    language: string;
+    ok: boolean;
+    error?: string;
+}>;
+export type HostSourceAnalysisResult = SourceAnalysisResult & Readonly<{
+    providerId: string | null;
+    stamp: PluginProviderStamp | null;
+    fallbackUsed: boolean;
+    diagnostics: readonly string[];
+    /** Shadow extractor comparisons; never affect canonical symbols. */
+    shadowComparisons: readonly HostSourceAnalysisShadowComparison[];
+}>;
+export type SourceAnalysisServiceOptions = Readonly<{
+    registry: CapabilityRegistry;
+    /** Injectable resolution for tests. */
+    resolveExtractors?: () => Promise<CapabilityModeResolution<SymbolExtractorV1>>;
+}>;
+export declare function createConservativeFallbackAnalysis(filePath: string, fallbackReason: string): HostSourceAnalysisResult;
+/**
+ * Host-validated symbol analysis over registry providers with conservative
+ * text fallback. Mode semantics:
+ * - replace: first choice for claimed files; builtin fallback on failure
+ * - augment: builtin first for supported files; additional extractors for
+ *   unsupported files in activation order
+ * - shadow: always run when configured/applicable; never canonical
+ */
+export declare class SourceAnalysisService {
+    private readonly registry;
+    private readonly resolveExtractors;
+    constructor(options: SourceAnalysisServiceOptions);
+    analyzeText(filePath: string, content: string): Promise<HostSourceAnalysisResult>;
+}
+/**
+ * Analyze using a pre-resolved extractor mode set (useful for tests).
+ */
+export declare function analyzeWithResolution(resolution: CapabilityModeResolution<SymbolExtractorV1>, filePath: string, content: string): Promise<HostSourceAnalysisResult>;
+export declare function createSourceAnalysisService(options: SourceAnalysisServiceOptions): SourceAnalysisService;
+//# sourceMappingURL=source-analysis-service.d.ts.map

package/dist/plugins/source-analysis-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-analysis-service.d.ts","sourceRoot":"","sources":["../../src/plugins/source-analysis-service.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EAGvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EACV,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AA4BvB,MAAM,MAAM,kCAAkC,GAAG,QAAQ,CAAC;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAGH,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,GACzD,QAAQ,CAAC;IACP,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,oEAAoE;IACpE,iBAAiB,EAAE,SAAS,kCAAkC,EAAE,CAAC;CAClE,CAAC,CAAC;AAGL,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,uCAAuC;IACvC,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAC/B,wBAAwB,CAAC,iBAAiB,CAAC,CAC5C,CAAC;CACH,CAAC,CAAC;AAgBH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACrB,wBAAwB,CAkB1B;AAuBD;;;;;;;GAOG;AAEH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAEhC;gBAEU,OAAO,EAAE,4BAA4B;IAO3C,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC;CAiIrC;AAED;;GAEG;AAEH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,wBAAwB,CAAC,iBAAiB,CAAC,EACvD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CAQnC;AAGD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,4BAA4B,GACpC,qBAAqB,CAEvB"}

package/dist/plugins/source-analysis-service.js

@@ -0,0 +1,232 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import * as path from "node:path";
+import { toSourceAnalysisProvider, validateSourceAnalysisResultForPath, } from "kibi-plugin-sdk";
+const SOURCE_LANGUAGE_EXTENSIONS = {
+    ".c": "c",
+    ".cc": "cpp",
+    ".cjs": "javascript",
+    ".cpp": "cpp",
+    ".cs": "csharp",
+    ".cts": "typescript",
+    ".go": "go",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".java": "java",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".kt": "kotlin",
+    ".mjs": "javascript",
+    ".mts": "typescript",
+    ".php": "php",
+    ".py": "python",
+    ".rb": "ruby",
+    ".rs": "rust",
+    ".swift": "swift",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+};
+function detectSourceLanguage(filePath) {
+    return (SOURCE_LANGUAGE_EXTENSIONS[path.extname(filePath).toLowerCase()] ??
+        "unknown");
+}
+function inferModuleTitle(filePath) {
+    const extension = path.extname(filePath);
+    const basename = path.basename(filePath, extension);
+    return basename.length > 0 ? basename : path.basename(filePath);
+}
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function createConservativeFallbackAnalysis(filePath, fallbackReason) {
+    const language = detectSourceLanguage(filePath);
+    return {
+        sourceFile: filePath,
+        language,
+        providerId: null,
+        stamp: null,
+        fallbackUsed: true,
+        diagnostics: [`conservative fallback: ${fallbackReason}`],
+        shadowComparisons: [],
+        module: {
+            title: inferModuleTitle(filePath),
+            language,
+            analysisMode: "fallback",
+            fallbackReason,
+        },
+        symbols: [],
+    };
+}
+function dedupeSymbols(symbols) {
+    const seen = new Set();
+    const output = [];
+    for (const symbol of symbols) {
+        const key = [
+            symbol.name,
+            symbol.kind,
+            symbol.startLine,
+            symbol.startColumn,
+            symbol.endLine,
+            symbol.endColumn,
+        ].join("\0");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        output.push(symbol);
+    }
+    return output;
+}
+/**
+ * Host-validated symbol analysis over registry providers with conservative
+ * text fallback. Mode semantics:
+ * - replace: first choice for claimed files; builtin fallback on failure
+ * - augment: builtin first for supported files; additional extractors for
+ *   unsupported files in activation order
+ * - shadow: always run when configured/applicable; never canonical
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export class SourceAnalysisService {
+    registry;
+    resolveExtractors;
+    constructor(options) {
+        this.registry = options.registry;
+        this.resolveExtractors =
+            options.resolveExtractors ??
+                (() => this.registry.resolveSymbolExtractors());
+    }
+    async analyzeText(filePath, content) {
+        const resolution = await this.resolveExtractors();
+        const diagnostics = [];
+        const tryAnalyze = (extractor, stamp) => {
+            const provider = toSourceAnalysisProvider(extractor);
+            if (!provider.supportsFile(filePath))
+                return null;
+            try {
+                const raw = provider.analyzeText(filePath, content);
+                const validated = validateSourceAnalysisResultForPath(raw, filePath);
+                return {
+                    ...validated,
+                    symbols: dedupeSymbols(validated.symbols),
+                    providerId: extractor.id,
+                    stamp,
+                    fallbackUsed: false,
+                    diagnostics,
+                    shadowComparisons: [],
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                diagnostics.push(`extractor '${extractor.id}' failed: ${message}`);
+                return null;
+            }
+        };
+        const runShadow = (canonical) => {
+            if (resolution.shadow.length === 0) {
+                return { ...canonical, diagnostics: [...diagnostics] };
+            }
+            const shadowComparisons = [];
+            for (const entry of resolution.shadow) {
+                const provider = toSourceAnalysisProvider(entry.capability);
+                if (!provider.supportsFile(filePath))
+                    continue;
+                try {
+                    const validated = validateSourceAnalysisResultForPath(provider.analyzeText(filePath, content), filePath);
+                    shadowComparisons.push({
+                        pluginId: entry.pluginId,
+                        stamp: entry.stamp,
+                        symbolCount: validated.symbols.length,
+                        language: validated.language,
+                        ok: true,
+                    });
+                    diagnostics.push(`shadow extractor '${entry.pluginId}' produced ${validated.symbols.length} non-canonical symbol(s)`);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    shadowComparisons.push({
+                        pluginId: entry.pluginId,
+                        stamp: entry.stamp,
+                        symbolCount: 0,
+                        language: detectSourceLanguage(filePath),
+                        ok: false,
+                        error: message,
+                    });
+                    diagnostics.push(`shadow extractor '${entry.pluginId}' failed: ${message}`);
+                }
+            }
+            return {
+                ...canonical,
+                diagnostics: [...diagnostics],
+                shadowComparisons,
+            };
+        };
+        let canonical = null;
+        if (resolution.replace) {
+            const replaced = tryAnalyze(resolution.replace.capability, resolution.replace.stamp);
+            if (replaced) {
+                canonical = replaced;
+            }
+            else {
+                diagnostics.push(`replace extractor '${resolution.replace.pluginId}' did not claim or failed; trying builtin`);
+                const builtin = tryAnalyze(resolution.builtin.capability, {
+                    ...resolution.builtin.stamp,
+                    fallbackUsed: true,
+                });
+                if (builtin) {
+                    canonical = { ...builtin, fallbackUsed: true };
+                }
+                else {
+                    canonical = createConservativeFallbackAnalysis(filePath, "provider_error");
+                }
+            }
+        }
+        else {
+            const builtin = tryAnalyze(resolution.builtin.capability, resolution.builtin.stamp);
+            if (builtin) {
+                canonical = builtin;
+            }
+            else {
+                for (const entry of resolution.augment) {
+                    const analyzed = tryAnalyze(entry.capability, entry.stamp);
+                    if (analyzed) {
+                        canonical = analyzed;
+                        break;
+                    }
+                }
+                if (!canonical) {
+                    canonical = createConservativeFallbackAnalysis(filePath, diagnostics.length > 0 ? "provider_error" : "unsupported_language");
+                }
+            }
+        }
+        return runShadow(canonical);
+    }
+}
+/**
+ * Analyze using a pre-resolved extractor mode set (useful for tests).
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export async function analyzeWithResolution(resolution, filePath, content) {
+    const service = new SourceAnalysisService({
+        registry: {
+            resolveSymbolExtractors: async () => resolution,
+        },
+        resolveExtractors: async () => resolution,
+    });
+    return service.analyzeText(filePath, content);
+}
+// implements REQ-capability-plugin-activation-disclosure-v1
+export function createSourceAnalysisService(options) {
+    return new SourceAnalysisService(options);
+}

package/dist/prolog/janitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../src/prolog/janitor.ts"],"names":[],"mappings":"AAoBA,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAAC;CACtD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;CACnC;AAED,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,2EAA2E;AAE3E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,IAAI,CA+CzB;AAED,iEAAiE;AAEjE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,cAAc,GACtB,gBAAgB,EAAE,CAepB;AAED;;;GAGG;AAEH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,GACtB,aAAa,EAAE,CA8CjB;AAED,gFAAgF;AAEhF,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,CAKpE"}
+{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../src/prolog/janitor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,oBAAoB,EAK1B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAAC;CACtD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;CACnC;AAED,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,2EAA2E;AAE3E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,IAAI,CA+CzB;AAED,iEAAiE;AAEjE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,cAAc,GACtB,gBAAgB,EAAE,CAepB;AAED;;;GAGG;AAEH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,EAAE,CA8C5E;AAED,gFAAgF;AAEhF,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,CAKpE"}

package/dist/prolog/janitor.js

@@ -15,7 +15,7 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { breakStoreLock, classifyStoreLockHolder, isProcessAlive, readStoreLockOwner, } from "./store-lock.js";
 /** Scan one branch store's ownership journal and clean stale artifacts. */

package/dist/prolog/store-lock.d.ts

@@ -1,5 +1,5 @@
-import type { PrologStoreLockOwner } from "./error-terms.js";
 import type { QueryResult } from "../prolog.js";
+import type { PrologStoreLockOwner } from "./error-terms.js";
 /** Linux boot id; guards against PID reuse across reboots. Null elsewhere. */
 export declare function currentBootId(): string | null;
 export declare function isProcessAlive(pid: number): boolean;

package/dist/prolog/store-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-lock.d.ts","sourceRoot":"","sources":["../../src/prolog/store-lock.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAgBhD,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAEzE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,oBAAoB,CAYtB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4B7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAWzD;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,yBAAyB,CAoB3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACxD;AAED;;;;;;GAMG;AAEH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CA4BtB"}
+{"version":3,"file":"store-lock.d.ts","sourceRoot":"","sources":["../../src/prolog/store-lock.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAgBhF,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAEzE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,oBAAoB,CAYtB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4B7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAWzD;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,yBAAyB,CAoB3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACxD;AAED;;;;;;GAMG;AAEH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CA4BtB"}

package/dist/proof/inspect.js

@@ -148,7 +148,7 @@ function directoryExists(root, relative) {
         return false;
     }
 }
-// implements REQ-kibi-proof-evidence-protocol
+// implements REQ-kibi-verification-evidence-contract
 export function inspectProofEnvironment(root) {
     const languages = new Set();
     const buildSystems = new Set();

package/dist/proof/producers/playwright-case-id.js

@@ -5,7 +5,7 @@ import path from "node:path";
  * The path is always repository-relative before hashing so the same case has
  * the same identity in a checkout, packed consumer, and dogfood workspace.
  */
-// implements REQ-kibi-proof-evidence-protocol
+// implements REQ-kibi-verification-evidence-contract
 export function playwrightCaseId(sourceFile, qualifiedTitle) {
     const normalizedPath = sourceFile
         .replaceAll("\\", "/")
@@ -14,7 +14,7 @@ export function playwrightCaseId(sourceFile, qualifiedTitle) {
     const key = `${normalizedPath}\0${qualifiedTitle.trim()}`;
     return `SYM-PW-${createHash("sha256").update(key).digest("hex").slice(0, 16).toUpperCase()}`;
 }
-// implements REQ-kibi-proof-evidence-protocol
+// implements REQ-kibi-verification-evidence-contract
 export function normalizePlaywrightSourceFile(sourceFile, workspaceRoot) {
     const absolute = path.resolve(sourceFile);
     if (!workspaceRoot)

package/dist/proof/producers/playwright-reporter.js

@@ -2,7 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { PROOF_RUN_VERSION, } from "../../public/proof-protocol.js";
 import { normalizePlaywrightSourceFile, playwrightCaseId, } from "./playwright-case-id.js";
-// implements REQ-kibi-proof-evidence-protocol
+// implements REQ-kibi-verification-evidence-contract
 export { PROOF_RUN_VERSION };
 function outputPath(options) {
     const configured = options.outputPath ?? process.env.KIBI_PROOF_OUTPUT;
@@ -53,11 +53,11 @@ export class KibiPlaywrightProducer {
         this.options = options;
         this.startedAt = (options.now ?? (() => new Date()))().toISOString();
     }
-    // implements REQ-kibi-proof-evidence-protocol
+    // implements REQ-kibi-verification-evidence-contract
     onBegin() {
         this.startedAt = (this.options.now ?? (() => new Date()))().toISOString();
     }
-    // implements REQ-kibi-proof-evidence-protocol
+    // implements REQ-kibi-verification-evidence-contract
     onTestEnd(test, result) {
         const resultValue = result;
         const titles = titlePath(test);
@@ -101,7 +101,7 @@ export class KibiPlaywrightProducer {
             attempts: { status: "complete", entries: [attempt] },
         });
     }
-    // implements REQ-kibi-proof-evidence-protocol
+    // implements REQ-kibi-verification-evidence-contract
     async onEnd(result) {
         const now = this.options.now ?? (() => new Date());
         const status = result?.status;

package/dist/public/extractors/symbols-coordinator.d.ts

@@ -1,2 +1,2 @@
-export { analyzeSourceText, enrichSymbolCoordinates, type ManifestSymbolEntry, type AnalyzeSourceTextOptions, type SourceAnalysisProvider, type SourceAnalysisResult, type SourceModuleAnalysis, type SourceSymbolAnalysis, type SourceSymbolKind, } from "../../extractors/symbols-coordinator.js";
+export { analyzeSourceText, analyzeSourceTextWithRegistry, enrichSymbolCoordinates, type ManifestSymbolEntry, type AnalyzeSourceTextOptions, type SourceAnalysisProvider, type SourceAnalysisResult, type SourceModuleAnalysis, type SourceSymbolAnalysis, type SourceSymbolKind, } from "../../extractors/symbols-coordinator.js";
 //# sourceMappingURL=symbols-coordinator.d.ts.map

package/dist/public/extractors/symbols-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbols-coordinator.d.ts","sourceRoot":"","sources":["../../../src/public/extractors/symbols-coordinator.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,yCAAyC,CAAC"}
+{"version":3,"file":"symbols-coordinator.d.ts","sourceRoot":"","sources":["../../../src/public/extractors/symbols-coordinator.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,iBAAiB,EACjB,6BAA6B,EAC7B,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,yCAAyC,CAAC"}

package/dist/public/extractors/symbols-coordinator.js

@@ -15,4 +15,4 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-export { analyzeSourceText, enrichSymbolCoordinates, } from "../../extractors/symbols-coordinator.js";
+export { analyzeSourceText, analyzeSourceTextWithRegistry, enrichSymbolCoordinates, } from "../../extractors/symbols-coordinator.js";

package/dist/public/impact/analyzer.d.ts

@@ -1,3 +1,3 @@
 import type { ChangedFileImpactOptions, ChangedFileImpactResult } from "./types.js";
-export declare function analyzeChangedFileImpact(options: ChangedFileImpactOptions): ChangedFileImpactResult;
+export declare function analyzeChangedFileImpact(options: ChangedFileImpactOptions): Promise<ChangedFileImpactResult>;
 //# sourceMappingURL=analyzer.d.ts.map