kibi-cli 0.14.0 → 0.17.0

package/dist/operations/autopilot/activation.d.ts

@@ -0,0 +1,4 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { ActivationPolicy } from "./types.js";
+export declare function classifyActivation(context: OperationContext, files: readonly string[]): Promise<ActivationPolicy>;
+//# sourceMappingURL=activation.d.ts.map

package/dist/operations/autopilot/activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/activation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAC;AA+FpE,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAuE3B"}

package/dist/operations/autopilot/activation.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+function activationFor(state) {
+    switch (state) {
+        case "root_uninitialized":
+            return {
+                activationState: state,
+                activationMode: "cold_start_bootstrap",
+                applyBlocked: false,
+                allowCandidateGeneration: true,
+                reason: "Workspace has no attached root KB yet; run a cold-start bootstrap scan across repository evidence.",
+            };
+        case "root_partial":
+            return {
+                activationState: state,
+                activationMode: "repair_bootstrap",
+                applyBlocked: true,
+                allowCandidateGeneration: true,
+                reason: "Workspace root is only partially configured; run a repair bootstrap scan and keep apply blocked until the root is repaired.",
+            };
+        case "vendored_only":
+            return {
+                activationState: state,
+                activationMode: "vendored_blocked",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace appears to contain vendored Kibi sources only; bootstrap generation is blocked in this posture.",
+                handoffMessage: "Vendored Kibi posture detected. Move to the real project root before attempting bootstrap.",
+            };
+        case "root_active_thin":
+            return {
+                activationState: state,
+                activationMode: "attached_thin_handoff",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace already has an attached but thin KB; bootstrap synthesis is replaced by an explicit thin handoff.",
+                handoffMessage: "Attached thin KB detected. Review sparse KB coverage and continue with a handoff.",
+            };
+        case "root_active_seeded":
+            return {
+                activationState: state,
+                activationMode: "attached_seeded_handoff",
+                applyBlocked: true,
+                allowCandidateGeneration: false,
+                reason: "Workspace already has an attached seeded KB; bootstrap synthesis is replaced by an explicit seeded handoff.",
+                handoffMessage: "Attached seeded KB detected. Use existing KB context instead of generating bootstrap candidates.",
+            };
+    }
+}
+async function exists(context, target) {
+    try {
+        await context.fs?.stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function coverageState(rows) {
+    const counts = Object.fromEntries(rows.map((row) => [row.type, Number(row.count)]));
+    const nonSymbols = [
+        "req",
+        "scenario",
+        "test",
+        "adr",
+        "flag",
+        "event",
+        "fact",
+    ].reduce((sum, type) => sum + Number(counts[type] ?? 0), 0);
+    const supporting = Number(counts.scenario ?? 0) +
+        Number(counts.test ?? 0) +
+        Number(counts.adr ?? 0) +
+        Number(counts.fact ?? 0);
+    return Number(counts.req ?? 0) >= 1 && nonSymbols >= 5 && supporting >= 1
+        ? "root_active_seeded"
+        : "root_active_thin";
+}
+export async function classifyActivation(context, files) {
+    const configPath = path.join(context.workspaceRoot, ".kb", "config.json");
+    if (!(await exists(context, configPath))) {
+        const vendored = files.some((file) => file.startsWith("kibi/"));
+        const projectSignal = files.some((file) => !file.startsWith("kibi/") &&
+            /^(README\.md|package\.json|src\/|app\/|packages\/|tests\/)/.test(file));
+        return activationFor(vendored && !projectSignal ? "vendored_only" : "root_uninitialized");
+    }
+    let config = {};
+    try {
+        config = JSON.parse((await context.fs?.readFile(configPath)) ?? "{}") ?? {};
+    }
+    catch {
+        return activationFor("root_partial");
+    }
+    const defaults = [
+        "documentation/requirements",
+        "documentation/scenarios",
+        "documentation/tests",
+        "documentation/adr",
+        "documentation/flags",
+        "documentation/events",
+        "documentation/facts",
+        "documentation/symbols.yaml",
+    ];
+    const configured = Object.values(config.paths ?? {});
+    const targets = configured.length >= 8 ? configured : defaults;
+    const resolved = await Promise.all(targets.map((target) => exists(context, path.resolve(context.workspaceRoot, target.replace(/[*?\[].*$/, "").replace(/\/$/, "")))));
+    if (resolved.some((value) => !value))
+        return activationFor("root_partial");
+    if (!context.prolog)
+        return activationFor("root_active_thin");
+    try {
+        const result = await context.prolog.query("discovery:coverage_report_json(type, [], true, false, 100, 0, JsonString)");
+        const parsed = JSON.parse(result.bindings.JsonString ?? '{"rows":[]}');
+        const rows = parsed !== null &&
+            typeof parsed === "object" &&
+            "rows" in parsed &&
+            Array.isArray(parsed.rows)
+            ? parsed.rows.flatMap((row) => row !== null &&
+                typeof row === "object" &&
+                "type" in row &&
+                "count" in row &&
+                typeof row.type === "string" &&
+                typeof row.count === "number"
+                ? [{ type: row.type, count: row.count }]
+                : [])
+            : [];
+        return activationFor(coverageState(rows));
+    }
+    catch {
+        return activationFor("root_active_thin");
+    }
+}

package/dist/operations/autopilot/candidate-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { StrictWriteSet } from "../../utils/strict-modeling.js";
+export declare function confidenceBand(value: number): string;
+export declare function slug(value: string, limit?: number): string;
+export declare function upsert<T extends {
+    readonly type?: unknown;
+    readonly id?: unknown;
+}>(entity: T, relationships?: readonly {
+    readonly type: string;
+    readonly from: string;
+    readonly to: string;
+}[]): Readonly<Record<string, unknown>>;
+export declare function strictPlan(writeSet: StrictWriteSet): readonly Readonly<Record<string, unknown>>[];
+//# sourceMappingURL=candidate-helpers.d.ts.map

package/dist/operations/autopilot/candidate-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-helpers.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/candidate-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,MAAM,CAMtD;AAED,wBAAgB,MAAM,CACpB,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAA;CAAE,EAE5D,MAAM,EAAE,CAAC,EACT,aAAa,GAAE,SAAS;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,EAAO,GACP,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQnC;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,cAAc,GACvB,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAmC9C"}

package/dist/operations/autopilot/candidate-helpers.js

@@ -0,0 +1,55 @@
+export function confidenceBand(value) {
+    return value >= 0.9 ? "high" : value >= 0.8 ? "medium" : "low";
+}
+export function slug(value, limit = 80) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "")
+        .slice(0, limit);
+}
+export function upsert(entity, relationships = []) {
+    const { type, id, ...properties } = entity;
+    return {
+        type: String(type ?? ""),
+        id: String(id ?? ""),
+        properties,
+        relationships,
+    };
+}
+export function strictPlan(writeSet) {
+    if (!writeSet.isStrict) {
+        return [
+            {
+                type: "fact",
+                id: writeSet.observationFact.id,
+                properties: writeSet.observationFact.properties,
+                relationships: [],
+            },
+        ];
+    }
+    return [
+        {
+            type: "fact",
+            id: writeSet.subjectFact.id,
+            properties: writeSet.subjectFact.properties,
+            relationships: [],
+        },
+        {
+            type: "fact",
+            id: writeSet.propertyFact.id,
+            properties: writeSet.propertyFact.properties,
+            relationships: [],
+        },
+        {
+            type: "req",
+            id: writeSet.req.id,
+            properties: writeSet.req.properties,
+            relationships: writeSet.relationships.map(({ type, from, to }) => ({
+                type,
+                from,
+                to,
+            })),
+        },
+    ];
+}

package/dist/operations/autopilot/candidates.d.ts

@@ -0,0 +1,4 @@
+import { type CandidateBuildResult } from "./markdown-candidates.js";
+import type { AutopilotEvidence } from "./types.js";
+export declare function buildAutopilotCandidates(evidence: readonly AutopilotEvidence[], existingIds: ReadonlySet<string>, minConfidence: number, includeGenericMarkdown: boolean): CandidateBuildResult;
+//# sourceMappingURL=candidates.d.ts.map

package/dist/operations/autopilot/candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/candidates.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAmHpB,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,EACtC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,sBAAsB,EAAE,OAAO,GAC9B,oBAAoB,CAqBtB"}

package/dist/operations/autopilot/candidates.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { extractFromManifestString } from "../../extractors/manifest.js";
+import { extractFromMarkdownString } from "../../extractors/markdown.js";
+import { confidenceBand, slug, upsert } from "./candidate-helpers.js";
+import { markdownCandidates, } from "./markdown-candidates.js";
+function typedCandidates(item, existingIds) {
+    try {
+        const results = item.kind === "symbol_manifest"
+            ? extractFromManifestString(item.content ?? "", item.relativePath ?? item.label)
+            : [
+                extractFromMarkdownString(item.content ?? "", item.relativePath ?? item.label),
+            ];
+        return results.flatMap(({ entity, relationships }) => {
+            if (existingIds.has(entity.id))
+                return [];
+            const sourceKind = item.kind === "symbol_manifest" ? "symbol_manifest" : "typed_markdown";
+            return [
+                {
+                    candidateId: `${sourceKind === "symbol_manifest" ? "mf" : "md"}:${item.relativePath}:${entity.id}`,
+                    entityType: entity.type,
+                    title: entity.title,
+                    sourceKind,
+                    sourcePath: item.absolutePath ?? item.label,
+                    confidence: sourceKind === "symbol_manifest" ? 0.98 : 1,
+                    confidenceBand: "high",
+                    evidence: [
+                        `extracted_from_${sourceKind}:${item.relativePath}`,
+                        `entity_id:${entity.id}`,
+                    ],
+                    relationships: relationships.map(({ type, from, to }) => ({
+                        type,
+                        from,
+                        to,
+                    })),
+                    applyPlan: [upsert(entity, relationships)],
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function providerCandidate(item, existingIds, minConfidence) {
+    if (!new Set([
+        "repo_metadata",
+        "repo_layout",
+        "test_topology",
+        "source_symbols",
+    ]).has(item.kind))
+        return [];
+    const relativePath = item.relativePath ?? item.label;
+    const confidence = typeof item.data.confidence === "number" ? item.data.confidence : 0.8;
+    const id = `FACT-GEN-${slug(`${item.kind}-${relativePath}`, 64) || "evidence"}`.toUpperCase();
+    if (confidence < minConfidence || existingIds.has(id))
+        return [];
+    const symbolTitle = item.kind === "source_symbols" && /\.(?:[cm]?[jt]sx?)$/i.test(relativePath)
+        ? `Source symbols: ${path.basename(relativePath, path.extname(relativePath))}`
+        : undefined;
+    const title = symbolTitle ??
+        (typeof item.data.title === "string"
+            ? item.data.title
+            : `Autopilot evidence from ${relativePath}`);
+    const entity = {
+        type: "fact",
+        id,
+        title,
+        status: "active",
+        fact_kind: typeof item.data.factKind === "string"
+            ? item.data.factKind
+            : item.kind === "repo_metadata"
+                ? "meta"
+                : "observation",
+        source: `autopilot:${item.provider}:${relativePath}`,
+        text_ref: relativePath,
+    };
+    const evidence = Array.isArray(item.data.evidence)
+        ? item.data.evidence.filter((value) => typeof value === "string")
+        : [`provider:${item.provider}`];
+    return [
+        {
+            candidateId: `prov:${item.kind}:${slug(relativePath, 96) || "evidence"}`,
+            entityType: "fact",
+            title,
+            sourceKind: item.kind,
+            sourcePath: item.absolutePath ?? relativePath,
+            confidence,
+            confidenceBand: confidenceBand(confidence),
+            evidence,
+            relationships: [],
+            applyPlan: [upsert(entity)],
+        },
+    ];
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export function buildAutopilotCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
+    const candidates = [];
+    const sourceOnlySignals = [];
+    for (const item of evidence) {
+        if (item.kind === "typed_markdown" || item.kind === "symbol_manifest")
+            candidates.push(...typedCandidates(item, existingIds));
+        if (item.kind === "generic_markdown" && includeGenericMarkdown) {
+            const built = markdownCandidates(item, existingIds, minConfidence);
+            candidates.push(...built.candidates);
+            sourceOnlySignals.push(...built.sourceOnlySignals);
+        }
+        candidates.push(...providerCandidate(item, existingIds, minConfidence));
+    }
+    return {
+        candidates,
+        sourceOnlySignals: sourceOnlySignals.sort((left, right) => right.confidence - left.confidence ||
+            left.sourcePath.localeCompare(right.sourcePath)),
+    };
+}

package/dist/operations/autopilot/discovery-evidence.d.ts

@@ -0,0 +1,10 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { AutopilotEvidence } from "./types.js";
+export type EvidenceScan = {
+    readonly files: readonly string[];
+    readonly ignoredSources: readonly string[];
+    readonly evidence: readonly AutopilotEvidence[];
+    readonly warnings: readonly string[];
+};
+export declare function scanEvidence(context: OperationContext): Promise<EvidenceScan>;
+//# sourceMappingURL=discovery-evidence.d.ts.map

package/dist/operations/autopilot/discovery-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-evidence.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery-evidence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AA0BpB,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AA8HF,wBAAsB,YAAY,CAChC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CAqDvB"}

package/dist/operations/autopilot/discovery-evidence.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { OperationError } from "../../cli-errors.js";
+const SCAN_PATTERNS = [
+    "**/*.md",
+    "**/symbols.{yml,yaml}",
+    "**/package.json",
+    "**/tsconfig*.json",
+    "**/pyproject.toml",
+    "**/Cargo.toml",
+    "**/go.mod",
+    "**/opencode.json",
+    "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+];
+const CODE_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rb|go|rs|java|kt|swift|php|c|cc|cpp|h|hpp)$/i;
+const LAYOUT_ROOTS = new Set([
+    "src",
+    "app",
+    "apps",
+    "packages",
+    "tests",
+    "test",
+    "docs",
+    "scripts",
+]);
+function isScanFilesystem(value) {
+    return Boolean(value && "glob" in value && typeof value.glob === "function");
+}
+function isScanGit(value) {
+    return Boolean(value &&
+        "ignoredPaths" in value &&
+        typeof value.ignoredPaths === "function");
+}
+function classifyFile(relativePath, content) {
+    if (/symbols\.ya?ml$/i.test(relativePath))
+        return ["typed_kibi_docs", "symbol_manifest"];
+    if (/\.md$/i.test(relativePath)) {
+        return /^---\s*[\r\n]/.test(content) &&
+            /(^|\/)documentation\/(requirements|scenarios|tests|adr|flags|events|facts)\//.test(relativePath)
+            ? ["typed_kibi_docs", "typed_markdown"]
+            : ["generic_repo_docs", "generic_markdown"];
+    }
+    if (/(^|\/)(package\.json|tsconfig[^/]*\.json|pyproject\.toml|Cargo\.toml|go\.mod)$/.test(relativePath))
+        return ["repo_metadata", "repo_metadata"];
+    if (/\.(test|spec)\.[^.]+$/i.test(relativePath) ||
+        /(^|\/)__tests__\//.test(relativePath))
+        return ["test_topology", "test_topology"];
+    if (CODE_EXTENSION.test(relativePath))
+        return ["source_symbols", "source_symbols"];
+    return null;
+}
+function evidenceData(provider, relativePath, content) {
+    if (provider === "repo_metadata")
+        return {
+            title: `Repository metadata: ${path.basename(relativePath)}`,
+            factKind: "meta",
+            confidence: relativePath.includes("tsconfig") ? 0.9 : 0.86,
+            evidence: [`repo_metadata:${relativePath}`],
+        };
+    if (provider === "test_topology") {
+        const frameworks = [
+            content.includes("bun:test") ? "bun:test" : "",
+            content.includes("vitest") ? "vitest" : "",
+            content.includes("node:test") ? "node:test" : "",
+        ].filter(Boolean);
+        return {
+            title: `Test topology: ${frameworks.join(", ") || relativePath}`,
+            factKind: "observation",
+            confidence: frameworks.length > 0 ? 0.92 : 0.85,
+            evidence: [
+                `test_topology:${relativePath}`,
+                ...frameworks.map((item) => `framework:${item}`),
+            ],
+            frameworks,
+        };
+    }
+    if (provider === "source_symbols")
+        return {
+            title: `Source module: ${path.basename(relativePath, path.extname(relativePath))}`,
+            factKind: "observation",
+            confidence: 0.82,
+            evidence: [`source_symbols:${relativePath}`],
+        };
+    return {};
+}
+function layoutEvidence(workspaceRoot, files, ignored) {
+    const roots = [
+        ...new Set(files
+            .filter((file) => !ignored.has(file))
+            .map((file) => file.split("/", 1)[0] ?? "")
+            .filter((root) => LAYOUT_ROOTS.has(root))),
+    ];
+    return roots.map((root) => ({
+        provider: "repo_layout",
+        kind: "repo_layout",
+        label: root,
+        relativePath: root,
+        absolutePath: path.join(workspaceRoot, root),
+        data: {
+            title: `Repository layout: ${root} directory`,
+            factKind: "observation",
+            confidence: 0.84,
+            evidence: [`repo_layout:${root}`],
+        },
+    }));
+}
+export async function scanEvidence(context) {
+    const fs = context.fs;
+    const git = context.git;
+    if (!isScanFilesystem(fs) || !isScanGit(git))
+        throw new OperationError("OPERATION_FAILED", "Autopilot requires filesystem glob and git ignore ports.");
+    const files = [
+        ...(await fs.glob(SCAN_PATTERNS, {
+            cwd: context.workspaceRoot,
+            includeIgnored: true,
+        })),
+    ].sort();
+    const ignoredSources = [
+        ...(await git.ignoredPaths(context.workspaceRoot, files)),
+    ].sort();
+    const ignored = new Set(ignoredSources);
+    const evidence = [];
+    const warnings = [];
+    for (const relativePath of files) {
+        if (ignored.has(relativePath))
+            continue;
+        const absolutePath = path.resolve(context.workspaceRoot, relativePath);
+        try {
+            const content = await fs.readFile(absolutePath);
+            const classification = classifyFile(relativePath, content);
+            if (!classification)
+                continue;
+            const [provider, kind] = classification;
+            if (provider === "repo_metadata" &&
+                path.basename(relativePath) === "package.json") {
+                try {
+                    JSON.parse(content);
+                }
+                catch {
+                    warnings.push(`repo_metadata:failed_to_parse:${relativePath}`);
+                }
+            }
+            evidence.push({
+                provider,
+                kind,
+                label: relativePath,
+                relativePath,
+                absolutePath,
+                content,
+                data: evidenceData(provider, relativePath, content),
+            });
+        }
+        catch {
+            warnings.push(`failed_to_read:${relativePath}`);
+        }
+    }
+    evidence.push(...layoutEvidence(context.workspaceRoot, files, ignored));
+    return { files, ignoredSources, evidence, warnings };
+}

package/dist/operations/autopilot/discovery.d.ts

@@ -0,0 +1,4 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type DiscoveryResult } from "./types.js";
+export declare function discoverAutopilot(context: OperationContext): Promise<DiscoveryResult>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/operations/autopilot/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,YAAY,CAAC;AAwEpB,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+C1B"}

package/dist/operations/autopilot/discovery.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { getSchemaVersionStatus } from "../../public/schema-version.js";
+import { classifyActivation } from "./activation.js";
+import { scanEvidence } from "./discovery-evidence.js";
+import { AUTOPILOT_PROVIDER_ORDER, } from "./types.js";
+const EXCLUDED_ROOTS = [
+    ".git",
+    ".kb",
+    ".venv",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+    "third-party",
+    "third_party",
+    "vendor",
+    "vendors",
+    "venv",
+];
+const LANGUAGE_NAMES = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+};
+async function migrationWarning(context) {
+    try {
+        const raw = await context.fs?.readFile(path.join(context.workspaceRoot, ".kb", "config.json"));
+        return getSchemaVersionStatus(JSON.parse(raw ?? "{}") ?? undefined).warning;
+    }
+    catch {
+        return null;
+    }
+}
+function languages(evidence) {
+    return [
+        ...new Set(evidence
+            .filter((item) => item.kind === "source_symbols")
+            .map((item) => {
+            const extension = path.extname(item.label).slice(1);
+            return LANGUAGE_NAMES[extension] ?? extension;
+        })),
+    ].sort();
+}
+function frameworks(evidence) {
+    return [
+        ...new Set(evidence.flatMap((item) => Array.isArray(item.data.frameworks)
+            ? item.data.frameworks.filter((value) => typeof value === "string")
+            : [])),
+    ].sort();
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export async function discoverAutopilot(context) {
+    const scan = await scanEvidence(context);
+    const ignored = new Set(scan.ignoredSources);
+    const activation = await classifyActivation(context, scan.files.filter((file) => !ignored.has(file)));
+    const evidence = activation.allowCandidateGeneration
+        ? [...scan.evidence]
+        : [];
+    evidence.sort((left, right) => AUTOPILOT_PROVIDER_ORDER.indexOf(left.provider) -
+        AUTOPILOT_PROVIDER_ORDER.indexOf(right.provider) ||
+        left.label.localeCompare(right.label));
+    const providersRun = activation.allowCandidateGeneration
+        ? [...AUTOPILOT_PROVIDER_ORDER]
+        : [];
+    const providerCounts = Object.fromEntries(AUTOPILOT_PROVIDER_ORDER.map((provider) => [
+        provider,
+        evidence.filter((item) => item.provider === provider).length,
+    ]));
+    return {
+        activation,
+        evidence,
+        ignoredSources: scan.ignoredSources,
+        migrationWarning: await migrationWarning(context),
+        summary: {
+            activationState: activation.activationState,
+            activationMode: activation.activationMode,
+            applyBlocked: activation.applyBlocked,
+            reason: activation.reason,
+            ...(activation.handoffMessage
+                ? { handoffMessage: activation.handoffMessage }
+                : {}),
+            providersRun,
+            providerCounts,
+            detectedLanguages: languages(evidence),
+            detectedTestFrameworks: frameworks(evidence),
+            excludedRoots: [...EXCLUDED_ROOTS].sort(),
+            truncated: false,
+            scanWarnings: [...new Set(scan.warnings)].sort(),
+        },
+    };
+}

package/dist/operations/autopilot/generate.d.ts

@@ -0,0 +1,8 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { AutopilotGenerateArgs, AutopilotGenerateResult, Candidate } from "./types.js";
+export declare function selectAutopilotCandidates(input: readonly Candidate[], existingIds: ReadonlySet<string>, entityTypes: readonly string[] | undefined, maximum: number): {
+    readonly candidates: readonly Candidate[];
+    readonly suppressed: readonly Readonly<Record<string, unknown>>[];
+};
+export declare function executeAutopilotGenerate(args: AutopilotGenerateArgs, context: OperationContext): Promise<AutopilotGenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/operations/autopilot/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/generate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,SAAS,EACV,MAAM,YAAY,CAAC;AAsBpB,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd;IACD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACnE,CAiDA;AAiBD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,uBAAuB,CAAC,CAgDlC"}