kibi-mcp 0.7.1 → 0.9.0

package/dist/tools/autopilot-generate.js

@@ -0,0 +1,271 @@
+import path from "node:path";
+import { buildTypedMarkdownCandidates, buildSymbolManifestCandidates, } from "./autopilot-candidates.js";
+import { classifyActivationState, discoverSources as discoverActivationSources, } from "./autopilot-discovery.js";
+import { loadEntities } from "./entity-query.js";
+import { resolveWorkspaceRoot } from "../workspace.js";
+function extractTextRefFromApplyPlan(applyPlan) {
+    if (!Array.isArray(applyPlan) || applyPlan.length === 0)
+        return "";
+    const first = applyPlan[0];
+    if (!first || typeof first !== "object")
+        return "";
+    const firstRecord = first;
+    const properties = firstRecord.properties;
+    if (!properties || typeof properties !== "object")
+        return "";
+    const propsRecord = properties;
+    const textRef = propsRecord.text_ref;
+    return typeof textRef === "string" ? textRef : "";
+}
+function toSuppressedCandidate(reason, candidate) {
+    return {
+        candidateId: String(candidate.candidateId ?? ""),
+        reason,
+        sourcePath: String(candidate.sourcePath ?? ""),
+        entityType: String(candidate.entityType ?? ""),
+    };
+}
+function activationReasonFor(state) {
+    switch (state) {
+        case "vendored_only":
+            return "Workspace appears to contain vendored Kibi sources only; no local candidates generated.";
+        case "root_partial":
+            return "Workspace root is partially configured; discovery completed using available sources.";
+        case "root_active_seeded":
+            return "KB attached and discovery completed for a seeded workspace.";
+        case "root_active_thin":
+            return "KB attached and discovery completed for a thin workspace.";
+        default:
+            return "Workspace root is not fully initialized; discovery completed using the resolved workspace root.";
+    }
+}
+function splitDiscoveredSources(workspaceRoot, candidates) {
+    const markdownFiles = [];
+    const manifestFiles = [];
+    for (const relativePath of candidates) {
+        const absolutePath = path.resolve(workspaceRoot, relativePath);
+        if (/symbols\.ya?ml$/i.test(relativePath)) {
+            manifestFiles.push(absolutePath);
+            continue;
+        }
+        if (/\.md$/i.test(relativePath)) {
+            markdownFiles.push(absolutePath);
+        }
+    }
+    return { markdownFiles, manifestFiles };
+}
+export async function handleKbAutopilotGenerate(// implements REQ-mcp-init-kibi-autopilot-v1
+_prolog, args) {
+    const { includeGenericMarkdown = true, minConfidence = 0.8, maxCandidates = 50, entityTypes, } = args;
+    // Minimal discovery + candidate assembly implementation
+    const prolog = _prolog;
+    // Gather existing entity ids to suppress duplicates
+    let existingIds = new Set();
+    try {
+        const entities = await loadEntities(prolog, {});
+        for (const e of entities) {
+            const id = String(e.id ?? "");
+            if (id)
+                existingIds.add(id);
+        }
+    }
+    catch (error) {
+        // If we can't list entities, proceed with empty set
+        existingIds = new Set();
+    }
+    const workspaceRoot = resolveWorkspaceRoot();
+    const activationState = await classifyActivationState(workspaceRoot, prolog);
+    const activationDiscovery = discoverActivationSources(workspaceRoot, activationState);
+    const discovery = splitDiscoveredSources(workspaceRoot, activationDiscovery.candidates);
+    const allowGeneration = activationState === "root_uninitialized" || activationState === "root_partial";
+    if (!allowGeneration) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Autopilot generated 0 candidate(s).",
+                },
+            ],
+            structuredContent: {
+                activationState,
+                activationReason: activationReasonFor(activationState),
+                applyBlocked: true,
+                discoverySummary: {
+                    markdownFiles: discovery.markdownFiles.length,
+                    manifestFiles: discovery.manifestFiles.length,
+                    vendored: activationDiscovery.summary.vendored ?? [],
+                },
+                candidates: [],
+                suppressedCandidates: [],
+                payoffSummary: {
+                    current: {},
+                    projectedIfAllApplied: {},
+                    delta: {},
+                },
+            },
+        };
+    }
+    const typedMarkdownCandidates = buildTypedMarkdownCandidates(discovery, {
+        ids: existingIds,
+        workspaceRoot,
+    });
+    const manifestCandidates = buildSymbolManifestCandidates(discovery, {
+        ids: existingIds,
+        workspaceRoot,
+    });
+    // Lazy import to avoid circulars if any
+    // buildGenericMarkdownCandidates is added in autopilot-candidates
+    let genericCandidates = [];
+    if (includeGenericMarkdown) {
+        try {
+            // Import from same module file
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const ac = await import("./autopilot-candidates.js");
+            if (typeof ac.buildGenericMarkdownCandidates === "function") {
+                genericCandidates = ac.buildGenericMarkdownCandidates(discovery, {
+                    ids: existingIds,
+                    workspaceRoot,
+                }, minConfidence);
+            }
+        }
+        catch (err) {
+            // ignore import failures and proceed with typed candidates only
+            genericCandidates = [];
+        }
+    }
+    // Merge and filter candidates by requested entityTypes and minConfidence
+    let allCandidates = [...typedMarkdownCandidates, ...manifestCandidates, ...genericCandidates];
+    if (entityTypes && entityTypes.length > 0) {
+        const allowed = new Set(entityTypes);
+        allCandidates = allCandidates.filter((c) => allowed.has(c.entityType));
+    }
+    allCandidates = allCandidates.filter((c) => c.confidence >= minConfidence);
+    // Limit and deterministic sort (confidence desc, sourcePath asc)
+    allCandidates.sort((a, b) => {
+        if (b.confidence !== a.confidence)
+            return b.confidence - a.confidence;
+        if (a.sourcePath < b.sourcePath)
+            return -1;
+        if (a.sourcePath > b.sourcePath)
+            return 1;
+        return 0;
+    });
+    allCandidates = allCandidates.slice(0, maxCandidates);
+    // Dedupe logic
+    const seenByKey = new Map();
+    const suppressed = [];
+    // Helpers
+    function normalizeTitle(entityType, title) {
+        return `${entityType}::${String(title).trim().toLowerCase().replace(/\s+/g, " ")}`;
+    }
+    const typedTitleKeys = new Set(typedMarkdownCandidates.map((candidate) => normalizeTitle(String(candidate.entityType || ""), String(candidate.title || ""))));
+    for (const c of allCandidates) {
+        const record = { ...c };
+        const entityType = String(c.entityType || "");
+        const title = String(c.title || "");
+        const sourceKind = String(c.sourceKind || "");
+        const sourcePath = String(c.sourcePath || "");
+        const textRef = extractTextRefFromApplyPlan(c.applyPlan);
+        const titleKey = normalizeTitle(entityType, title);
+        // entity_exists: exact entity ID present in KB
+        const upsert = Array.isArray(c.applyPlan) ? c.applyPlan[0] : null;
+        let upsertId = "";
+        if (upsert && typeof upsert === "object") {
+            const upsertRecord = upsert;
+            const directId = upsertRecord.id;
+            if (typeof directId === "string" && directId.length > 0) {
+                upsertId = directId;
+            }
+            else {
+                const properties = upsertRecord.properties;
+                if (properties && typeof properties === "object") {
+                    const nestedId = properties.id;
+                    if (typeof nestedId === "string" && nestedId.length > 0) {
+                        upsertId = nestedId;
+                    }
+                }
+            }
+        }
+        if (existingIds.has(upsertId)) {
+            suppressed.push(toSuppressedCandidate("entity_exists", record));
+            continue;
+        }
+        if (sourceKind === "generic_markdown" && typedTitleKeys.has(titleKey)) {
+            suppressed.push(toSuppressedCandidate("shadowed_by_typed_source", record));
+            continue;
+        }
+        // duplicate_title: same entityType + normalized title
+        const existing = seenByKey.get(titleKey);
+        if (existing) {
+            // keep the higher confidence one
+            const existingConf = Number(existing.confidence ?? 0);
+            const thisConf = Number(c.confidence ?? 0);
+            if (thisConf > existingConf) {
+                // move existing to suppressed
+                suppressed.push(toSuppressedCandidate("duplicate_title", existing));
+                seenByKey.set(titleKey, record);
+            }
+            else if (thisConf < existingConf) {
+                suppressed.push(toSuppressedCandidate("duplicate_title", record));
+            }
+            else {
+                // tie-break by lexicographically smallest sourcePath:textRef
+                const existingRef = `${String(existing.sourcePath ?? "")}::${extractTextRefFromApplyPlan(existing.applyPlan)}`;
+                const thisRef = `${sourcePath}::${textRef}`;
+                if (thisRef < existingRef) {
+                    suppressed.push(toSuppressedCandidate("duplicate_title", existing));
+                    seenByKey.set(titleKey, record);
+                }
+                else {
+                    suppressed.push(toSuppressedCandidate("duplicate_title", record));
+                }
+            }
+            continue;
+        }
+        seenByKey.set(titleKey, record);
+    }
+    const candidateRecords = Array.from(seenByKey.values());
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Autopilot generated ${allCandidates.length} candidate(s).`,
+            },
+        ],
+        structuredContent: {
+            activationState,
+            activationReason: activationReasonFor(activationState),
+            applyBlocked: activationState === "root_partial",
+            discoverySummary: {
+                markdownFiles: discovery.markdownFiles.length,
+                manifestFiles: discovery.manifestFiles.length,
+                vendored: activationDiscovery.summary.vendored ?? [],
+            },
+            candidates: candidateRecords,
+            suppressedCandidates: suppressed,
+            payoffSummary: (() => {
+                // current counts by type
+                const current = {};
+                try {
+                    // compute from existingIds via loadEntities would be expensive; fall back to empty
+                }
+                catch (e) {
+                    // noop
+                }
+                // projected if all applied
+                const projected = { ...current };
+                for (const r of candidateRecords) {
+                    const t = String(r.entityType || "unknown");
+                    projected[t] = (projected[t] || 0) + 1;
+                }
+                const delta = {};
+                for (const k of Object.keys(projected)) {
+                    const projectedValue = projected[k] ?? 0;
+                    const currentValue = current[k] ?? 0;
+                    delta[k] = projectedValue - currentValue;
+                }
+                return { current, projectedIfAllApplied: projected, delta };
+            })(),
+        },
+    };
+}