kibi-cli 2.1.0 → 2.3.0

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

@@ -0,0 +1,54 @@
+import { analysisObligation, } from "../traceability/analysis-gate.js";
+/** Files analyzed at once; pooled providers bound their own worker count. */
+const SOURCE_ANALYSIS_CONCURRENCY = 4;
+/** Analyze both versions without changing the complete inventory or assigning proof. */
+// implements REQ-014
+export async function analyzeSourceChanges(inventory, service) {
+    const files = inventory.filter((file) => file.analysisDepth !== "metadata" && !file.skipReason);
+    const results = new Array(files.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < files.length) {
+            const index = next++;
+            const file = files[index];
+            const [before, after] = await Promise.all([
+                file.previousContent === undefined
+                    ? null
+                    : service.analyzeTextV2(file.oldPath ?? file.copyFromPath ?? file.path, file.previousContent),
+                file.content === undefined
+                    ? null
+                    : service.analyzeTextV2(file.path, file.content),
+            ]);
+            results[index] = { path: file.path, before, after };
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(SOURCE_ANALYSIS_CONCURRENCY, files.length) }, worker));
+    // Map order follows the inventory, independent of completion order.
+    return new Map(results.map((change) => [change.path, change]));
+}
+/** Adapt a host result to the shared analysis gate. */
+// implements REQ-source-analysis-v2
+export function gateAnalysis(result) {
+    return result
+        ? {
+            status: result.status,
+            diagnosticCodes: result.diagnostics.map((item) => item.code),
+            uncoveredRanges: result.uncoveredRanges,
+        }
+        : null;
+}
+/** Enforce the shared analysis gate when no impact policy accepts reviews. */
+// implements REQ-source-analysis-v2
+export function assertSourceAnalysisGate(inventory, analyses) {
+    for (const file of inventory) {
+        const analysis = analyses.get(file.path);
+        const after = analysis?.after ?? null;
+        const obligation = analysisObligation("after", gateAnalysis(after), file.hunkRanges);
+        if (obligation.kind !== "blocked" && obligation.kind !== "partial_review")
+            continue;
+        const detail = after?.diagnostics.map((d) => d.message).join("; ") ?? "";
+        throw new Error(obligation.kind === "blocked"
+            ? `Source analysis ${after?.status} for ${file.path}: ${detail}`
+            : `Source analysis partial for ${file.path} where the staged change touches uncovered lines (${obligation.ranges.map((range) => `${range.startLine}-${range.endLine}`).join(", ")}): ${detail}`);
+    }
+}

package/dist/plugins/source-classification.d.ts

@@ -0,0 +1,41 @@
+export type SourceClassification = Readonly<{
+    kind: "language";
+    language: string;
+    source: "extension" | "shebang" | "explicit";
+}> | Readonly<{
+    kind: "file-level";
+    language: string;
+    source: "extension" | "shebang" | "explicit";
+    reason: string;
+}> | Readonly<{
+    kind: "ambiguous";
+    language: string;
+    candidates: readonly string[];
+    reason: string;
+}> | Readonly<{
+    kind: "conflict";
+    language: "unknown";
+    extensionLanguage?: string;
+    shebangLanguage?: string;
+    explicitLanguage?: string;
+    reason: string;
+}> | Readonly<{
+    kind: "unknown";
+    language: "unknown";
+    reason: string;
+}>;
+/**
+ * Extension-only language label for a path, or "unknown". This is the single
+ * extension table; callers that need content-aware classification (shebangs,
+ * explicit hints, ambiguity) must use classifySource instead.
+ */
+export declare function extensionLanguage(filePath: string): string;
+/** True for TypeScript/JavaScript paths handled by the ts-morph analyzer. */
+export declare function isTsJsSourcePath(filePath: string): boolean;
+/** True for paths whose language has qualified declaration analysis. */
+export declare function isQualifiedSourcePath(filePath: string): boolean;
+/** Every classified extension, for parity checks against provider catalogs. */
+export declare function classifiedExtensions(): readonly string[];
+/** Classifies a path and bounded snapshot prefix without executing the source or its interpreter. */
+export declare function classifySource(filePath: string, content: string, explicitLanguageHint?: string): SourceClassification;
+//# sourceMappingURL=source-classification.d.ts.map

package/dist/plugins/source-classification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-classification.d.ts","sourceRoot":"","sources":["../../src/plugins/source-classification.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAC5B,QAAQ,CAAC;IACP,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;CAC9C,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,GACF,QAAQ,CAAC;IACP,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAsGP;;;;GAIG;AAEH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,6EAA6E;AAE7E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG1D;AAED,wEAAwE;AAExE,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAM/D;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,IAAI,SAAS,MAAM,EAAE,CAExD;AAuQD,qGAAqG;AACrG,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,oBAAoB,CAAC,EAAE,MAAM,GAC5B,oBAAoB,CA2JtB"}

package/dist/plugins/source-classification.js

@@ -0,0 +1,490 @@
+const MAX_SHEBANG_LENGTH = 512;
+const MAX_SHEBANG_TOKENS = 16;
+const MAX_TOKEN_LENGTH = 128;
+const EXTENSIONS = {
+    ".bash": { kind: "language", language: "bash" },
+    ".c": { kind: "language", language: "c" },
+    ".cc": { kind: "language", language: "cpp" },
+    ".cjs": { kind: "language", language: "javascript" },
+    ".cpp": { kind: "language", language: "cpp" },
+    ".cs": { kind: "language", language: "csharp" },
+    ".cts": { kind: "language", language: "typescript" },
+    ".cxx": { kind: "language", language: "cpp" },
+    ".go": { kind: "language", language: "go" },
+    ".h": { kind: "ambiguous", language: "c-or-cpp", candidates: ["c", "cpp"] },
+    ".hcl": { kind: "language", language: "hcl" },
+    ".hh": { kind: "language", language: "cpp" },
+    ".hpp": { kind: "language", language: "cpp" },
+    ".hxx": { kind: "language", language: "cpp" },
+    ".html": {
+        kind: "file-level",
+        language: "html",
+        reason: "HTML is classified as a file-level document.",
+    },
+    ".java": { kind: "language", language: "java" },
+    ".js": { kind: "language", language: "javascript" },
+    ".jsx": { kind: "language", language: "javascript" },
+    ".json": {
+        kind: "file-level",
+        language: "json",
+        reason: "JSON is classified as a file-level document.",
+    },
+    ".kt": { kind: "language", language: "kotlin" },
+    ".mjs": { kind: "language", language: "javascript" },
+    ".mts": { kind: "language", language: "typescript" },
+    ".php": { kind: "language", language: "php" },
+    ".pl": {
+        kind: "ambiguous",
+        language: "perl-or-prolog",
+        candidates: ["perl", "prolog"],
+    },
+    ".py": { kind: "language", language: "python" },
+    ".pyi": { kind: "language", language: "python" },
+    ".rb": { kind: "language", language: "ruby" },
+    ".rs": { kind: "language", language: "rust" },
+    ".sh": {
+        kind: "file-level",
+        language: "shell",
+        reason: "A .sh extension does not identify a shell dialect.",
+    },
+    ".sql": {
+        kind: "file-level",
+        language: "sql",
+        reason: "SQL is classified as a file-level document.",
+    },
+    ".swift": { kind: "language", language: "swift" },
+    ".ts": { kind: "language", language: "typescript" },
+    ".tsx": { kind: "language", language: "typescript" },
+    ".tf": { kind: "language", language: "terraform" },
+    ".yaml": {
+        kind: "file-level",
+        language: "yaml",
+        reason: "YAML is classified as a file-level document.",
+    },
+    ".yml": {
+        kind: "file-level",
+        language: "yaml",
+        reason: "YAML is classified as a file-level document.",
+    },
+    ".css": {
+        kind: "file-level",
+        language: "css",
+        reason: "CSS is classified as a file-level document.",
+    },
+};
+/** Languages whose declarations the host analyzes with a qualified parser. */
+const QUALIFIED_SOURCE_LANGUAGES = new Set([
+    "typescript",
+    "javascript",
+    "python",
+    "go",
+    "rust",
+]);
+/**
+ * Extension-only language label for a path, or "unknown". This is the single
+ * extension table; callers that need content-aware classification (shebangs,
+ * explicit hints, ambiguity) must use classifySource instead.
+ */
+// implements REQ-source-analysis-v2
+export function extensionLanguage(filePath) {
+    return EXTENSIONS[extensionOf(filePath)]?.language ?? "unknown";
+}
+/** True for TypeScript/JavaScript paths handled by the ts-morph analyzer. */
+// implements REQ-source-analysis-v2
+export function isTsJsSourcePath(filePath) {
+    const language = extensionLanguage(filePath);
+    return language === "typescript" || language === "javascript";
+}
+/** True for paths whose language has qualified declaration analysis. */
+// implements REQ-source-analysis-v2
+export function isQualifiedSourcePath(filePath) {
+    const signal = EXTENSIONS[extensionOf(filePath)];
+    return (signal?.kind === "language" &&
+        QUALIFIED_SOURCE_LANGUAGES.has(signal.language));
+}
+/** Every classified extension, for parity checks against provider catalogs. */
+// implements REQ-source-analysis-v2
+export function classifiedExtensions() {
+    return Object.keys(EXTENSIONS).sort();
+}
+const FILE_LEVEL_LANGUAGES = new Set([
+    "css",
+    "html",
+    "json",
+    "perl",
+    "prolog",
+    "shell",
+    "sql",
+    "yaml",
+]);
+const SHELL_INTERPRETERS = new Set([
+    "ash",
+    "busybox",
+    "csh",
+    "dash",
+    "fish",
+    "ksh",
+    "mksh",
+    "pwsh",
+    "sh",
+    "tcsh",
+    "yash",
+    "zsh",
+]);
+function basename(value) {
+    return value.split(/[\\/]/).at(-1) ?? value;
+}
+function extensionOf(filePath) {
+    const name = basename(filePath);
+    const dot = name.lastIndexOf(".");
+    return dot <= 0 ? "" : name.slice(dot).toLowerCase();
+}
+function canonicalLanguage(value) {
+    const language = value.trim().toLowerCase();
+    if (language === "")
+        return undefined;
+    if (["py", "python", "python2", "python3"].includes(language))
+        return "python";
+    if (["bash", "bash5"].includes(language))
+        return "bash";
+    if (["rb", "ruby"].includes(language) || /^ruby\d+(?:\.\d+)*$/.test(language))
+        return "ruby";
+    if (["js", "javascript", "node", "nodejs"].includes(language))
+        return "javascript";
+    if (["ts", "typescript"].includes(language))
+        return "typescript";
+    if (["c++", "cpp", "cxx"].includes(language))
+        return "cpp";
+    if (["c#", "c-sharp", "csharp", "cs"].includes(language))
+        return "csharp";
+    if (["perl", "pl"].includes(language))
+        return "perl";
+    if (["prolog", "swipl"].includes(language))
+        return "prolog";
+    if (language === "tf")
+        return "terraform";
+    return language;
+}
+function tokenizeWords(value) {
+    const words = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    let started = false;
+    for (const character of value) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            started = true;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaped = true;
+            started = true;
+            continue;
+        }
+        if (quote !== undefined) {
+            if (character === quote)
+                quote = undefined;
+            else
+                current += character;
+            started = true;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (started) {
+                words.push(current);
+                if (words.length > MAX_SHEBANG_TOKENS)
+                    return undefined;
+                current = "";
+                started = false;
+            }
+            continue;
+        }
+        current += character;
+        started = true;
+        if (current.length > MAX_TOKEN_LENGTH)
+            return undefined;
+    }
+    if (escaped || quote !== undefined)
+        return undefined;
+    if (started)
+        words.push(current);
+    return words.length > MAX_SHEBANG_TOKENS ? undefined : words;
+}
+function envCommand(arguments_) {
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === undefined)
+            return undefined;
+        if (argument === "--")
+            return arguments_[index + 1];
+        if (argument === "-S" || argument === "--split-string") {
+            const commandText = arguments_.slice(index + 1).join(" ");
+            return commandInSplitString(commandText);
+        }
+        if (argument.startsWith("--split-string=")) {
+            return commandInSplitString(argument.slice("--split-string=".length));
+        }
+        if (argument === "-u" ||
+            argument === "--unset" ||
+            argument === "-C" ||
+            argument === "--chdir" ||
+            argument === "-a" ||
+            argument === "--argv0") {
+            index += 1;
+            continue;
+        }
+        if (argument === "-i" ||
+            argument === "--ignore-environment" ||
+            argument.startsWith("--unset=") ||
+            argument.startsWith("--chdir=") ||
+            argument.startsWith("--argv0=") ||
+            /^[A-Za-z_][A-Za-z0-9_]*=/.test(argument)) {
+            continue;
+        }
+        if (argument.startsWith("-"))
+            return undefined;
+        return argument;
+    }
+    return undefined;
+}
+function commandInSplitString(value) {
+    const words = tokenizeWords(value);
+    if (!words)
+        return undefined;
+    let index = 0;
+    while (index < words.length) {
+        const argument = words[index];
+        if (argument === undefined)
+            return undefined;
+        if (argument === "--")
+            return words[index + 1];
+        if (argument === "-i" || argument === "--ignore-environment") {
+            index += 1;
+            continue;
+        }
+        if (argument === "-u" || argument === "--unset") {
+            const name = words[index + 1];
+            if (name === undefined || name === "")
+                return undefined;
+            index += 2;
+            continue;
+        }
+        if (argument.startsWith("--unset=")) {
+            if (argument.length === "--unset=".length)
+                return undefined;
+            index += 1;
+            continue;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(argument)) {
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("-"))
+            return undefined;
+        return argument;
+    }
+    return undefined;
+}
+function interpreterFor(command) {
+    const name = basename(command).toLowerCase();
+    const withoutExe = name.endsWith(".exe") ? name.slice(0, -4) : name;
+    if (/^(?:python|python\d+(?:\.\d+)*)$/.test(withoutExe)) {
+        return { name: withoutExe, language: "python" };
+    }
+    if (/^ruby(?:\d+(?:\.\d+)*)?$/.test(withoutExe)) {
+        return { name: withoutExe, language: "ruby" };
+    }
+    if (["node", "nodejs"].includes(withoutExe)) {
+        return { name: withoutExe, language: "javascript" };
+    }
+    if (withoutExe === "bash" || /^bash\d+$/.test(withoutExe)) {
+        return { name: withoutExe, language: "bash" };
+    }
+    if (SHELL_INTERPRETERS.has(withoutExe)) {
+        return { name: withoutExe, family: "shell" };
+    }
+    if (/^(?:perl|perl\d+(?:\.\d+)*)$/.test(withoutExe)) {
+        return { name: withoutExe, language: "perl" };
+    }
+    if (["prolog", "swipl", "gprolog"].includes(withoutExe)) {
+        return { name: withoutExe, language: "prolog" };
+    }
+    return { name: withoutExe || "unknown" };
+}
+function shebangFor(content) {
+    const bomOffset = content.charCodeAt(0) === 0xfeff ? 1 : 0;
+    const prefix = content.slice(bomOffset, bomOffset + MAX_SHEBANG_LENGTH + 2);
+    if (!prefix.startsWith("#!"))
+        return undefined;
+    const lineEnd = prefix.search(/[\r\n]/);
+    if (lineEnd < 0 && content.length > bomOffset + MAX_SHEBANG_LENGTH + 2) {
+        return { name: "overlong-shebang" };
+    }
+    const line = prefix.slice(2, lineEnd < 0 ? undefined : lineEnd).trim();
+    const words = tokenizeWords(line);
+    if (!words || words.length === 0 || words[0] === undefined) {
+        return { name: "malformed-shebang" };
+    }
+    const executable = basename(words[0]).toLowerCase();
+    if (executable === "env") {
+        const command = envCommand(words.slice(1));
+        return command === undefined
+            ? { name: "malformed-env-shebang" }
+            : interpreterFor(command);
+    }
+    return interpreterFor(words[0]);
+}
+function classificationForLanguage(language, source) {
+    if (FILE_LEVEL_LANGUAGES.has(language)) {
+        return {
+            kind: "file-level",
+            language,
+            source,
+            reason: `${language} is retained as a file-level classification; no syntax extractor is selected.`,
+        };
+    }
+    return { kind: "language", language, source };
+}
+function isExtensionCompatibleWith(extension, language) {
+    if (extension.kind === "ambiguous")
+        return extension.candidates.includes(language);
+    if (extension.kind === "file-level" && extension.language === "shell") {
+        return language === "bash" || language === "shell";
+    }
+    return extension.language === language;
+}
+function conflict(reason, details = {}) {
+    return { kind: "conflict", language: "unknown", reason, ...details };
+}
+/** Classifies a path and bounded snapshot prefix without executing the source or its interpreter. */
+export function classifySource(filePath, content, explicitLanguageHint) {
+    const extension = EXTENSIONS[extensionOf(filePath)];
+    const explicitRaw = explicitLanguageHint?.trim();
+    const explicit = explicitRaw ? canonicalLanguage(explicitRaw) : undefined;
+    const shebang = shebangFor(content);
+    const shebangLanguage = shebang?.language;
+    if (explicitRaw && explicit === undefined) {
+        return conflict(`The explicit language hint '${explicitRaw}' is not recognized.`);
+    }
+    if (explicit !== undefined) {
+        if (extension !== undefined &&
+            !isExtensionCompatibleWith(extension, explicit)) {
+            return conflict(`The explicit language '${explicit}' conflicts with the file extension classification.`, {
+                extensionLanguage: extension.language,
+                explicitLanguage: explicit,
+                ...(shebangLanguage === undefined ? {} : { shebangLanguage }),
+            });
+        }
+        if (shebang !== undefined) {
+            const shebangMatches = shebang.language === explicit ||
+                (shebang.family === "shell" && explicit === "shell");
+            if (!shebangMatches) {
+                return conflict(`The explicit language '${explicit}' conflicts with the snapshot shebang.`, {
+                    ...(extension === undefined
+                        ? {}
+                        : { extensionLanguage: extension.language }),
+                    ...(shebangLanguage === undefined ? {} : { shebangLanguage }),
+                    explicitLanguage: explicit,
+                });
+            }
+        }
+        return classificationForLanguage(explicit, "explicit");
+    }
+    if (extension?.kind === "ambiguous") {
+        if (shebang === undefined) {
+            return {
+                kind: "ambiguous",
+                language: extension.language,
+                candidates: extension.candidates,
+                reason: `The '${extension.language === "c-or-cpp" ? ".h" : ".pl"}' extension does not select one language.`,
+            };
+        }
+        const resolvedLanguage = shebang.language;
+        if (resolvedLanguage !== undefined &&
+            extension.candidates.includes(resolvedLanguage)) {
+            return classificationForLanguage(resolvedLanguage, "shebang");
+        }
+        return conflict("The file extension is ambiguous and the shebang does not resolve it to a supported candidate.", {
+            extensionLanguage: extension.language,
+            ...(shebangLanguage === undefined ? {} : { shebangLanguage }),
+        });
+    }
+    const hasExtension = extensionOf(filePath) !== "";
+    if (extension !== undefined) {
+        if (shebang !== undefined) {
+            if (shebang.family === "shell") {
+                if (extension.language === "shell") {
+                    return {
+                        kind: "file-level",
+                        language: "shell",
+                        source: "shebang",
+                        reason: `The ${shebang.name} shell dialect is retained as file-level source.`,
+                    };
+                }
+                return conflict(`The ${shebang.name} shell shebang conflicts with the file extension language.`, {
+                    extensionLanguage: extension.language,
+                    shebangLanguage: "shell",
+                });
+            }
+            if (shebang.language !== undefined) {
+                if (!isExtensionCompatibleWith(extension, shebang.language)) {
+                    return conflict(`The ${shebang.language} shebang conflicts with the file extension language.`, {
+                        extensionLanguage: extension.language,
+                        shebangLanguage: shebang.language,
+                    });
+                }
+                return classificationForLanguage(shebang.language, "shebang");
+            }
+            return conflict(`The shebang interpreter '${shebang.name}' is not qualified for the file extension language.`, {
+                extensionLanguage: extension.language,
+                shebangLanguage: shebang.name,
+            });
+        }
+        if (extension.kind === "file-level") {
+            return {
+                kind: "file-level",
+                language: extension.language,
+                source: "extension",
+                reason: extension.reason,
+            };
+        }
+        return classificationForLanguage(extension.language, "extension");
+    }
+    if (hasExtension) {
+        return {
+            kind: "unknown",
+            language: "unknown",
+            reason: "The file extension is not present in the source language catalog.",
+        };
+    }
+    if (shebang === undefined) {
+        return {
+            kind: "unknown",
+            language: "unknown",
+            reason: "No recognized source extension or shebang is present.",
+        };
+    }
+    if (shebang.language !== undefined) {
+        return classificationForLanguage(shebang.language, "shebang");
+    }
+    if (shebang.family === "shell") {
+        return {
+            kind: "file-level",
+            language: "shell",
+            source: "shebang",
+            reason: `The ${shebang.name} shell dialect is retained as file-level source.`,
+        };
+    }
+    return {
+        kind: "unknown",
+        language: "unknown",
+        reason: `The '${shebang.name}' interpreter is not in the executable source catalog.`,
+    };
+}

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;;;;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"}
+{"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,CAsD3E;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"}

package/dist/prolog/codec.js

@@ -191,6 +191,8 @@ export function parsePropertyList(propsStr) {
         }
         let parsed = parsePrologValue(value);
         if ((key === "rule_ir" ||
+            key === "argument_constants" ||
+            key === "argument_aliases" ||
             key === "semantic_inventory" ||
             key === "proof_receipts" ||
             key === "proof_contract" ||