kibi-cli 2.2.0 → 2.4.0

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/swipl-resolver.d.ts

@@ -0,0 +1,88 @@
+export type SwiplSource = "env" | "bundled" | "path";
+export type ResolvedSwipl = {
+    /** Absolute path to the executable. */
+    bin: string;
+    /** SWI_HOME_DIR for a bundled build. */
+    home?: string;
+    /** Upstream SWI-Prolog version, e.g. "10.0.2". */
+    version: string;
+    source: SwiplSource;
+};
+export declare const MINIMUM_SWIPL_MAJOR = 9;
+export type SwiplResolutionErrorCode = "swipl_not_found" | "swipl_env_invalid" | "swipl_bundle_corrupt";
+/** Structured failure; `message` is the complete operator-facing guidance. */
+export declare class SwiplResolutionError extends Error {
+    readonly code: SwiplResolutionErrorCode;
+    /** Detected host, e.g. "linux-x64 (glibc)". */
+    readonly platform: string;
+    /** Platform package that would have covered this host, when one exists. */
+    readonly packageName: string | undefined;
+    constructor(code: SwiplResolutionErrorCode, message: string, platform: string, packageName: string | undefined);
+}
+export type SwiplResolverDeps = {
+    platform: string;
+    arch: string;
+    /** True on glibc Linux, false on musl, undefined off Linux. */
+    glibc: boolean | undefined;
+    /** Directory of an installed platform package, or undefined. */
+    locatePackage: (packageName: string) => string | undefined;
+    /** Output of `<bin> --version`; throws when the executable cannot run. */
+    runVersion: (bin: string) => string;
+};
+/** Parse `SWI-Prolog version 10.0.2 for x86_64-linux` into its version. */
+export declare function parseSwiplVersion(output: string): {
+    version: string;
+    major: number;
+} | undefined;
+/** Uncached resolution with injectable host facts; the test seam. */
+export declare function resolveSwiplWith(env: NodeJS.ProcessEnv, deps: SwiplResolverDeps): ResolvedSwipl;
+/**
+ * Resolve the SWI-Prolog executable for this process. The result is cached for
+ * the lifetime of the process, keyed by the inputs that select it.
+ */
+export declare function resolveSwipl(env?: NodeJS.ProcessEnv): ResolvedSwipl;
+/** Test seam: forget every cached resolution. */
+export declare function resetSwiplResolverCache(): void;
+/** Stable identity of a resolved runtime, compared across engine processes. */
+export declare function swiplIdentity(resolved: ResolvedSwipl): string;
+/** Environment additions a child needs to run the resolved SWI-Prolog. */
+export declare function swiplChildEnv(resolved: Pick<ResolvedSwipl, "home">): Record<string, string>;
+export type BundleStatus = {
+    state: "unsupported";
+} | {
+    state: "missing" | "empty";
+    packageName: string;
+} | {
+    state: "corrupt";
+    packageName: string;
+    reason: string;
+} | {
+    state: "installed";
+    packageName: string;
+};
+/** Report the bundled package's state without resolving a runtime. */
+export declare function inspectSwiplBundle(deps?: SwiplResolverDeps): BundleStatus;
+/** Libraries Kibi loads at runtime; a SWI-Prolog lacking one cannot serve it. */
+export declare const REQUIRED_SWIPL_LIBRARIES: readonly ["semweb/rdf_db", "semweb/rdf_persistency", "semweb/sparql_client", "pcre", "crypto", "sha", "http/json", "http/json_convert", "chr", "clpfd", "thread", "persistency", "filesex", "readutil", "date", "aggregate", "solution_sequences"];
+export type SwiplGoalRunner = (bin: string, args: readonly string[], env: NodeJS.ProcessEnv) => {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+};
+export type LibraryProbe = {
+    kind: "ok";
+} | {
+    kind: "missing";
+    libraries: string[];
+} | {
+    kind: "failed";
+    detail: string;
+};
+/**
+ * Load every required library in one throwaway SWI-Prolog process and report
+ * the ones that fail. A probe that cannot run is reported as such, never as a
+ * pass.
+ */
+export declare function probeRequiredLibraries(resolved: ResolvedSwipl, run?: SwiplGoalRunner, env?: NodeJS.ProcessEnv): LibraryProbe;
+//# sourceMappingURL=swipl-resolver.d.ts.map

package/dist/prolog/swipl-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipl-resolver.d.ts","sourceRoot":"","sources":["../../src/prolog/swipl-resolver.ts"],"names":[],"mappings":"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"}