kibi-cli 1.0.1 → 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/codec.d.ts

@@ -4,7 +4,8 @@
  */
 /**
  * Escape a string for use as a Prolog atom.
- * Doubles single-quote characters per ISO Prolog standard.
+ * Escapes backslashes/control characters and doubles single quotes per ISO
+ * Prolog syntax.
  */
 export declare function escapeAtom(value: string): string;
 /**
@@ -23,13 +24,24 @@ export declare function toPrologString(value: string): string;
  * Alias for escapeAtom for semantic clarity.
  */
 export declare function escapeAtomContent(value: string): string;
+/**
+ * Parse a Prolog list of list rows without decoding or normalizing columns.
+ * Malformed outer collections fail closed rather than returning a partial
+ * projection.
+ */
 export declare function parseListOfLists(listStr: string): string[][];
+export declare function firstTwoDefinedParts(parts: readonly (string | undefined)[]): [string, string] | undefined;
+export declare function fallbackWhenPairMissing<T>(pair: [string, string] | undefined, fallback: T): T | null;
+export declare function typedLiteralFromParts(parts: readonly (string | undefined)[], original: string): unknown;
+export declare function fileUriLeaf(value: string): string;
+export declare function entityFromBindingParts(parts: readonly (string | undefined)[]): Record<string, unknown>;
 export declare function parseEntityFromBinding(bindingStr: string): Record<string, unknown>;
 export declare function parseEntityFromList(data: string[]): Record<string, unknown>;
 export declare function parsePropertyList(propsStr: string): Record<string, unknown>;
 export declare function parsePrologValue(valueInput: string): unknown;
 export declare function splitTopLevelGeneral(str: string, delimiter: string): string[];
 export declare function splitTopLevel(str: string, delimiter: string): string[];
+export declare function normalizeEntityId(value: string): string;
 export declare function parseAtomList(raw: string): string[];
 export declare function parsePairList(raw: string): Array<[string, string]>;
 export declare function parseTriples(raw: string): Array<[string, string, string]>;

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

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/prolog/codec.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CA8C5D;AAED,wBAAgB,sBAAsB,CAEpC,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBzB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB3E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmD3E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAkG5D;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAoD7E;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtE;AAqBD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAenD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBlE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBzE;AAuDD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,EAAE,CA6DjE"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/prolog/codec.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYhD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAU5D;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACrC,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAO9B;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAClC,QAAQ,EAAE,CAAC,GACV,CAAC,GAAG,IAAI,CAEV;AAID,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EACtC,QAAQ,EAAE,MAAM,GACf,OAAO,CAoCT;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiBzB;AAED,wBAAgB,sBAAsB,CAEpC,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGzB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB3E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoD3E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CA6D5D;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAG7E;AAuFD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtE;AAYD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUvD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAenD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBlE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBzE;AAyCD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,EAAE,CA6DjE"}