kibi-cli 2.2.0 → 2.3.0

package/dist/plugins/registry.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 { KIBI_PLUGIN_API_VERSION, ONTOLOGY_PACK_CAPABILITY_ID, SEMANTIC_CLASSIFIER_CAPABILITY_ID, SYMBOL_EXTRACTOR_CAPABILITY_ID, VOCABULARY_ALIGNMENT_CAPABILITY_ID, defineKibiPlugin, validateKibiPlugin, } from "kibi-plugin-sdk";
+import { KIBI_PLUGIN_API_VERSION, ONTOLOGY_PACK_CAPABILITY_ID, SEMANTIC_CLASSIFIER_CAPABILITY_ID, SYMBOL_EXTRACTOR_CAPABILITY_ID, SYMBOL_EXTRACTOR_V2_CAPABILITY_ID, VOCABULARY_ALIGNMENT_CAPABILITY_ID, defineKibiPlugin, validateKibiPlugin, } from "kibi-plugin-sdk";
 import { loadPluginPackage } from "./load-plugin.js";
 import { readProjectKibiConfig } from "./project-config.js";
 import { PluginResolutionError } from "./resolve-package.js";
@@ -23,6 +23,7 @@ const CAPABILITY_SLOT = {
     [SEMANTIC_CLASSIFIER_CAPABILITY_ID]: "semanticClassifier",
     [ONTOLOGY_PACK_CAPABILITY_ID]: "ontologyPack",
     [SYMBOL_EXTRACTOR_CAPABILITY_ID]: "symbolExtractor",
+    [SYMBOL_EXTRACTOR_V2_CAPABILITY_ID]: "symbolExtractorV2",
     [VOCABULARY_ALIGNMENT_CAPABILITY_ID]: "vocabularyAlignment",
 };
 /**
@@ -197,6 +198,10 @@ export class CapabilityRegistry {
     async resolveSymbolExtractors() {
         return this.resolveCapability(SYMBOL_EXTRACTOR_CAPABILITY_ID);
     }
+    // implements REQ-capability-plugin-activation-disclosure-v1
+    async resolveSymbolExtractorsV2() {
+        return this.resolveCapability(SYMBOL_EXTRACTOR_V2_CAPABILITY_ID);
+    }
     async resolveVocabularyAlignment() {
         return this.resolveCapability(VOCABULARY_ALIGNMENT_CAPABILITY_ID);
     }

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

@@ -1,4 +1,4 @@
-import { type PluginProviderStamp, type SourceAnalysisResult, type SymbolExtractorV1 } from "kibi-plugin-sdk";
+import { type PluginProviderStamp, type SourceAnalysisResult, type SourceAnalysisResultV2, type SymbolExtractorV1, type SymbolExtractorV2 } from "kibi-plugin-sdk";
 import type { CapabilityModeResolution, CapabilityRegistry } from "./registry.js";
 export type HostSourceAnalysisShadowComparison = Readonly<{
     pluginId: string;
@@ -18,9 +18,21 @@ export type HostSourceAnalysisResult = SourceAnalysisResult & Readonly<{
 }>;
 export type SourceAnalysisServiceOptions = Readonly<{
     registry: CapabilityRegistry;
+    /** Explicit v2 resolution; maintenance callers supply only approved providers. */
+    resolveExtractorsV2?: () => Promise<CapabilityModeResolution<SymbolExtractorV2>>;
+    /** Wall-clock deadline for async providers; CPU-bound plugins need their own terminable worker. */
+    analysisTimeoutMs?: number;
+    /** Host-verified package/asset fingerprint, never accepted from result data. */
+    providerFingerprints?: Readonly<Record<string, string>>;
     /** Injectable resolution for tests. */
     resolveExtractors?: () => Promise<CapabilityModeResolution<SymbolExtractorV1>>;
 }>;
+/**
+ * The host owns the analysis deadline. Providers get a slightly smaller budget
+ * so a cooperative provider reports its own timeout diagnostic before the host
+ * abandons the call.
+ */
+export declare function providerBudgetMs(hostTimeoutMs: number): number;
 export declare function createConservativeFallbackAnalysis(filePath: string, fallbackReason: string): HostSourceAnalysisResult;
 /**
  * Host-validated symbol analysis over registry providers with conservative
@@ -32,8 +44,23 @@ export declare function createConservativeFallbackAnalysis(filePath: string, fal
  */
 export declare class SourceAnalysisService {
     private readonly registry;
+    private readonly options;
     private readonly resolveExtractors;
     constructor(options: SourceAnalysisServiceOptions);
+    /**
+     * Analyze supplied snapshot bytes with explicit completeness and host provenance.
+     * An explicit language hint selects an ambiguous extension only when it agrees
+     * with any shebang; conflicting signals return unsupported without dispatch.
+     *
+     * Classify, bound the input, resolve providers, take the first claiming
+     * provider's result as canonical, then record shadow comparisons.
+     */
+    analyzeTextV2(filePath: string, content: string, explicitLanguageHint?: string): Promise<HostSourceAnalysisResultV2>;
+    /**
+     * Run one provider under the host-owned deadline. Returns null when the
+     * provider does not claim the input; a claimed failure is a failed result.
+     */
+    private runV2Extractor;
     analyzeText(filePath: string, content: string): Promise<HostSourceAnalysisResult>;
 }
 /**
@@ -41,4 +68,12 @@ export declare class SourceAnalysisService {
  */
 export declare function analyzeWithResolution(resolution: CapabilityModeResolution<SymbolExtractorV1>, filePath: string, content: string): Promise<HostSourceAnalysisResult>;
 export declare function createSourceAnalysisService(options: SourceAnalysisServiceOptions): SourceAnalysisService;
+/** V2 results preserve failure/completeness; provenance is always assigned by the host. */
+export type HostSourceAnalysisResultV2 = SourceAnalysisResultV2 & Readonly<{
+    providerId: string | null;
+    stamp: PluginProviderStamp | null;
+    inputFingerprint: string;
+    providerFingerprint: string | null;
+    shadowComparisons: readonly HostSourceAnalysisShadowComparison[];
+}>;
 //# sourceMappingURL=source-analysis-service.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"source-analysis-service.d.ts","sourceRoot":"","sources":["../../src/plugins/source-analysis-service.ts"],"names":[],"mappings":"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"}

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

@@ -15,35 +15,73 @@
  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 { createHash } from "node:crypto";
 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",
-};
+import { SOURCE_ANALYSIS_V2_MAX_INPUT_CODE_UNITS, SYMBOL_EXTRACTOR_V2_CAPABILITY_ID, toSourceAnalysisProvider, validateSourceAnalysisResultForPath, validateSourceAnalysisResultV2, } from "kibi-plugin-sdk";
+import { classifySource, extensionLanguage } from "./source-classification.js";
 function detectSourceLanguage(filePath) {
-    return (SOURCE_LANGUAGE_EXTENSIONS[path.extname(filePath).toLowerCase()] ??
-        "unknown");
+    return extensionLanguage(filePath);
+}
+/** Classify once and bind every result for this input to one fingerprint. */
+function createV2Request(filePath, content, explicitLanguageHint) {
+    const classification = classifySource(filePath, content, explicitLanguageHint);
+    const language = classification.language;
+    const inputFingerprint = createHash("sha256")
+        .update(filePath)
+        .update("\0")
+        .update(content)
+        .update("\0")
+        .update(classification.kind)
+        .update("\0")
+        .update(classification.language)
+        .update("\0")
+        .update(explicitLanguageHint?.trim().toLowerCase() ?? "")
+        .digest("hex");
+    return {
+        classification,
+        input: {
+            path: filePath,
+            content,
+            ...(classification.kind === "language"
+                ? { language: classification.language }
+                : {}),
+        },
+        inputFingerprint,
+        fallback: (status, code, message) => ({
+            contractVersion: SYMBOL_EXTRACTOR_V2_CAPABILITY_ID,
+            status,
+            sourceFile: filePath,
+            language,
+            module: {
+                title: inferModuleTitle(filePath),
+                language,
+                analysisMode: "fallback",
+                fallbackReason: code,
+            },
+            symbols: [],
+            diagnostics: [{ code, message }],
+            uncoveredRanges: [],
+            providerId: null,
+            stamp: null,
+            inputFingerprint,
+            providerFingerprint: null,
+            shadowComparisons: [],
+        }),
+    };
+}
+function hostDeadlineMs(requested) {
+    const value = requested ?? 10000;
+    return Number.isFinite(value) && value > 0 ? Math.min(value, 60000) : 10000;
+}
+/**
+ * The host owns the analysis deadline. Providers get a slightly smaller budget
+ * so a cooperative provider reports its own timeout diagnostic before the host
+ * abandons the call.
+ */
+// implements REQ-source-analysis-v2
+export function providerBudgetMs(hostTimeoutMs) {
+    const grace = Math.min(1000, Math.floor(hostTimeoutMs / 10));
+    return Math.max(1, hostTimeoutMs - grace);
 }
 function inferModuleTitle(filePath) {
     const extension = path.extname(filePath);
@@ -100,13 +138,132 @@ function dedupeSymbols(symbols) {
 // implements REQ-capability-plugin-activation-disclosure-v1
 export class SourceAnalysisService {
     registry;
+    options;
     resolveExtractors;
     constructor(options) {
         this.registry = options.registry;
+        this.options = options;
         this.resolveExtractors =
             options.resolveExtractors ??
                 (() => this.registry.resolveSymbolExtractors());
     }
+    /**
+     * Analyze supplied snapshot bytes with explicit completeness and host provenance.
+     * An explicit language hint selects an ambiguous extension only when it agrees
+     * with any shebang; conflicting signals return unsupported without dispatch.
+     *
+     * Classify, bound the input, resolve providers, take the first claiming
+     * provider's result as canonical, then record shadow comparisons.
+     */
+    // implements REQ-capability-plugin-activation-disclosure-v1
+    async analyzeTextV2(filePath, content, explicitLanguageHint) {
+        const request = createV2Request(filePath, content, explicitLanguageHint);
+        const { classification } = request;
+        if (content.length > SOURCE_ANALYSIS_V2_MAX_INPUT_CODE_UNITS ||
+            Buffer.byteLength(content, "utf8") > 8 * 1024 * 1024)
+            return request.fallback("failed", "input_limit", `Source input exceeds the ${SOURCE_ANALYSIS_V2_MAX_INPUT_CODE_UNITS} UTF-16 code unit or 8 MiB UTF-8 analysis limit`);
+        let resolution;
+        try {
+            resolution = await (this.options.resolveExtractorsV2?.() ??
+                this.registry.resolveSymbolExtractorsV2());
+        }
+        catch (error) {
+            return request.fallback("failed", "provider_resolution_failed", String(error));
+        }
+        if (classification.kind !== "language" &&
+            classification.kind !== "unknown") {
+            const code = classification.kind === "ambiguous"
+                ? "source_language_ambiguous"
+                : classification.kind === "conflict"
+                    ? "source_classification_conflict"
+                    : classification.kind === "file-level"
+                        ? "source_file_level_only"
+                        : "unsupported_language";
+            return request.fallback("unsupported", code, classification.reason);
+        }
+        const entries = resolution.replace
+            ? [resolution.replace, resolution.builtin, ...resolution.augment]
+            : [resolution.builtin, ...resolution.augment];
+        let canonical = null;
+        for (const entry of entries) {
+            const result = await this.runV2Extractor(entry, request);
+            if (result === null)
+                continue;
+            // A claimed file's incomplete/failed result is authoritative uncertainty.
+            // Never turn a required provider failure into empty symbols or success.
+            canonical = result;
+            break;
+        }
+        canonical ??= request.fallback("unsupported", "unsupported_language", "No configured source analyzer claims this file; file-level review remains required.");
+        const shadowComparisons = [];
+        for (const entry of resolution.shadow) {
+            const result = await this.runV2Extractor(entry, request);
+            if (!result)
+                continue;
+            shadowComparisons.push({
+                pluginId: entry.pluginId,
+                stamp: entry.stamp,
+                symbolCount: result.symbols.length,
+                language: result.language,
+                ok: result.status === "ok",
+                ...(result.status !== "ok"
+                    ? { error: result.diagnostics.map((d) => d.message).join("; ") }
+                    : {}),
+            });
+        }
+        return { ...canonical, shadowComparisons };
+    }
+    /**
+     * Run one provider under the host-owned deadline. Returns null when the
+     * provider does not claim the input; a claimed failure is a failed result.
+     */
+    async runV2Extractor(entry, request) {
+        const { classification, input } = request;
+        try {
+            const supportsInput = classification.kind === "language"
+                ? { path: input.path, language: classification.language }
+                : { path: input.path };
+            if (!entry.capability.supports(supportsInput))
+                return null;
+            const timeout = hostDeadlineMs(this.options.analysisTimeoutMs);
+            let timer;
+            let raw;
+            try {
+                raw = await Promise.race([
+                    entry.capability.analyze({
+                        ...input,
+                        timeoutMs: providerBudgetMs(timeout),
+                    }),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error("Source analysis deadline exceeded")), timeout);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+            }
+            const validated = validateSourceAnalysisResultV2(raw, input);
+            return {
+                ...validated,
+                providerId: entry.capability.id,
+                stamp: entry.stamp,
+                inputFingerprint: request.inputFingerprint,
+                providerFingerprint: this.options.providerFingerprints?.[entry.pluginId] ??
+                    createHash("sha256")
+                        .update(`${entry.pluginId}\0${entry.pluginVersion}\0${entry.stamp.capability}`)
+                        .digest("hex"),
+                shadowComparisons: [],
+            };
+        }
+        catch (error) {
+            return {
+                ...request.fallback("failed", "provider_failed", `Extractor '${entry.capability.id}' failed: ${String(error)}`),
+                providerId: entry.capability.id,
+                stamp: entry.stamp,
+            };
+        }
+    }
     async analyzeText(filePath, content) {
         const resolution = await this.resolveExtractors();
         const diagnostics = [];

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

@@ -0,0 +1,15 @@
+import { type GateAnalysis } from "../traceability/analysis-gate.js";
+import type { StagedPath } from "../traceability/git-staged.js";
+import type { HostSourceAnalysisResultV2, SourceAnalysisService } from "./source-analysis-service.js";
+export interface SourceChangeAnalysis {
+    path: string;
+    before: HostSourceAnalysisResultV2 | null;
+    after: HostSourceAnalysisResultV2 | null;
+}
+/** Analyze both versions without changing the complete inventory or assigning proof. */
+export declare function analyzeSourceChanges(inventory: readonly StagedPath[], service: SourceAnalysisService): Promise<Map<string, SourceChangeAnalysis>>;
+/** Adapt a host result to the shared analysis gate. */
+export declare function gateAnalysis(result: HostSourceAnalysisResultV2 | null): GateAnalysis<HostSourceAnalysisResultV2["uncoveredRanges"][number]> | null;
+/** Enforce the shared analysis gate when no impact policy accepts reviews. */
+export declare function assertSourceAnalysisGate(inventory: readonly StagedPath[], analyses: ReadonlyMap<string, SourceChangeAnalysis>): void;
+//# sourceMappingURL=source-change-analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"source-change-analysis.d.ts","sourceRoot":"","sources":["../../src/plugins/source-change-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAElB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAC1C,KAAK,EAAE,0BAA0B,GAAG,IAAI,CAAC;CAC1C;AAKD,wFAAwF;AAExF,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,SAAS,UAAU,EAAE,EAChC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAgC5C;AAED,uDAAuD;AAEvD,wBAAgB,YAAY,CAC1B,MAAM,EAAE,0BAA0B,GAAG,IAAI,GACxC,YAAY,CAAC,0BAA0B,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAQ5E;AAED,8EAA8E;AAE9E,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,UAAU,EAAE,EAChC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAClD,IAAI,CAkBN"}

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"}