kibi-mcp 0.22.0 → 2.0.0

package/dist/tools/autopilot-generate.js

@@ -1,47 +0,0 @@
-import { executeAutopilotGenerate, } from "kibi-cli/operations";
-import { nodeFilesystem, nodeGit } from "kibi-cli/operations";
-import { PrologProcess } from "kibi-cli/prolog";
-import { resolveWorkspaceRoot } from "../workspace.js";
-import { executeTestDependencies, resetTestDependencies, setTestDependencies, } from "./autopilot-test-compat.js";
-export function _setAutopilotGenerateDepsForTests(dependencies) {
-    setTestDependencies(dependencies);
-}
-export function _resetAutopilotGenerateDepsForTests() {
-    resetTestDependencies();
-}
-function isOperationContext(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        "workspaceRoot" in value &&
-        "signal" in value);
-}
-function adaptProlog(prolog) {
-    return {
-        query: (goal) => prolog.query(goal),
-        nextSolution: async () => null,
-        save: () => prolog.query("kb_save"),
-    };
-}
-// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
-export async function handleKbAutopilotGenerate(first, second) {
-    if (isOperationContext(second) && !(first instanceof PrologProcess))
-        return executeAutopilotGenerate(first, {
-            ...second,
-            fs: second.fs ?? nodeFilesystem,
-            git: second.git ?? nodeGit,
-        });
-    if (!(first instanceof PrologProcess) || isOperationContext(second))
-        throw new TypeError("Invalid autopilot adapter invocation");
-    const testResult = await executeTestDependencies(first, second);
-    if (testResult)
-        return testResult;
-    const context = {
-        workspaceRoot: resolveWorkspaceRoot(),
-        signal: new AbortController().signal,
-        clock: () => new Date(),
-        fs: nodeFilesystem,
-        git: nodeGit,
-        prolog: adaptProlog(first),
-    };
-    return executeAutopilotGenerate(second, context);
-}

package/dist/tools/autopilot-test-compat.js

@@ -1,88 +0,0 @@
-import { presentAutopilot, selectAutopilotCandidates, } from "kibi-cli/operations";
-import { resolveWorkspaceRoot } from "../workspace.js";
-import { activation, candidate, record, signal, } from "./autopilot-test-parsers.js";
-let testDependencies;
-export function setTestDependencies(dependencies) {
-    testDependencies = dependencies;
-}
-export function resetTestDependencies() {
-    testDependencies = undefined;
-}
-async function invoke(dependencies, name, values) {
-    const callable = dependencies[name];
-    return typeof callable === "function"
-        ? Reflect.apply(callable, undefined, [...values])
-        : undefined;
-}
-export async function executeTestDependencies(prolog, input) {
-    const dependencies = testDependencies;
-    if (!dependencies)
-        return null;
-    const root = resolveWorkspaceRoot();
-    const policy = activation(await invoke(dependencies, "resolveActivationPolicy", [root, prolog]));
-    if (!policy)
-        return null;
-    const discovered = record(await invoke(dependencies, "discoverProviderEvidence", [root, policy]));
-    const rawSummary = record(discovered?.summary);
-    const summary = {
-        activationState: policy.activationState,
-        activationMode: policy.activationMode,
-        applyBlocked: policy.applyBlocked,
-        reason: policy.reason,
-        providersRun: [],
-        providerCounts: {},
-        detectedLanguages: [],
-        detectedTestFrameworks: [],
-        excludedRoots: [],
-        truncated: false,
-        scanWarnings: [],
-        ...(rawSummary ? Object.fromEntries(Object.entries(rawSummary)) : {}),
-    };
-    const rawEntities = await invoke(dependencies, "loadEntities", [prolog, {}]);
-    const existingIds = new Set(Array.isArray(rawEntities)
-        ? rawEntities
-            .map((entry) => record(entry)?.id)
-            .filter((id) => typeof id === "string")
-        : []);
-    const discoveryInput = {
-        evidence: Array.isArray(discovered?.evidence) ? discovered.evidence : [],
-    };
-    const context = { ids: existingIds, workspaceRoot: root };
-    const minConfidence = Math.max(0.6, Math.min(0.95, input.minConfidence ?? 0.8));
-    const all = [];
-    for (const name of [
-        "buildTypedMarkdownCandidates",
-        "buildSymbolManifestCandidates",
-        "buildGenericMarkdownCandidates",
-        "buildNormativeRequirementCandidates",
-        "buildProviderEvidenceCandidates",
-    ]) {
-        const result = await invoke(dependencies, name, [
-            discoveryInput,
-            context,
-            minConfidence,
-        ]);
-        if (Array.isArray(result))
-            all.push(...result.flatMap((entry) => candidate(entry) ?? []));
-    }
-    const rawSignals = await invoke(dependencies, "collectSourceOnlyAuthoringSignals", [discoveryInput, context, minConfidence]);
-    const signals = Array.isArray(rawSignals)
-        ? rawSignals.flatMap((entry) => signal(entry) ?? [])
-        : [];
-    const selected = selectAutopilotCandidates(all.filter((entry) => entry.confidence >= minConfidence), existingIds, input.entityTypes, Math.max(1, Math.min(200, Math.trunc(input.maxCandidates ?? 50))));
-    const warning = await invoke(dependencies, "getWorkspaceMigrationWarning", [
-        root,
-    ]);
-    return presentAutopilot({
-        root,
-        activation: policy,
-        discoverySummary: summary,
-        migrationWarning: typeof warning === "string" ? warning : null,
-        ...(input.bootstrapContext
-            ? { bootstrapContext: input.bootstrapContext }
-            : {}),
-        candidates: selected.candidates,
-        sourceOnlySignals: signals,
-        suppressedCandidates: selected.suppressed,
-    });
-}

package/dist/tools/autopilot-test-parsers.js

@@ -1,120 +0,0 @@
-export function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? Object.fromEntries(Object.entries(value))
-        : null;
-}
-export function candidate(value) {
-    const item = record(value);
-    if (!item ||
-        typeof item.candidateId !== "string" ||
-        typeof item.entityType !== "string" ||
-        typeof item.title !== "string" ||
-        typeof item.sourceKind !== "string" ||
-        typeof item.sourcePath !== "string" ||
-        typeof item.confidence !== "number" ||
-        !Array.isArray(item.applyPlan))
-        return null;
-    const relationships = Array.isArray(item.relationships)
-        ? item.relationships.flatMap((entry) => {
-            const relation = record(entry);
-            return relation &&
-                typeof relation.type === "string" &&
-                typeof relation.from === "string" &&
-                typeof relation.to === "string"
-                ? [{ type: relation.type, from: relation.from, to: relation.to }]
-                : [];
-        })
-        : [];
-    const applyPlan = item.applyPlan
-        .map(record)
-        .filter((entry) => entry !== null);
-    return {
-        candidateId: item.candidateId,
-        entityType: item.entityType,
-        title: item.title,
-        sourceKind: item.sourceKind,
-        sourcePath: item.sourcePath,
-        confidence: item.confidence,
-        confidenceBand: typeof item.confidenceBand === "string" ? item.confidenceBand : "medium",
-        evidence: Array.isArray(item.evidence)
-            ? item.evidence.filter((entry) => typeof entry === "string")
-            : [],
-        relationships,
-        applyPlan,
-    };
-}
-export function signal(value) {
-    const item = record(value);
-    if (!item ||
-        !["req", "scenario", "test"].includes(String(item.kind)) ||
-        typeof item.title !== "string" ||
-        typeof item.sourcePath !== "string" ||
-        typeof item.confidence !== "number")
-        return null;
-    const kind = item.kind === "req"
-        ? "req"
-        : item.kind === "scenario"
-            ? "scenario"
-            : "test";
-    return {
-        kind,
-        title: item.title,
-        sourcePath: item.sourcePath,
-        confidence: item.confidence,
-        evidence: Array.isArray(item.evidence)
-            ? item.evidence.filter((entry) => typeof entry === "string")
-            : [],
-    };
-}
-export function activation(value) {
-    const item = record(value);
-    if (!item ||
-        typeof item.activationState !== "string" ||
-        typeof item.activationMode !== "string" ||
-        typeof item.applyBlocked !== "boolean" ||
-        typeof item.allowCandidateGeneration !== "boolean" ||
-        typeof item.reason !== "string")
-        return null;
-    const states = new Set([
-        "root_uninitialized",
-        "root_partial",
-        "vendored_only",
-        "root_active_thin",
-        "root_active_seeded",
-    ]);
-    const modes = new Set([
-        "cold_start_bootstrap",
-        "repair_bootstrap",
-        "attached_thin_handoff",
-        "attached_seeded_handoff",
-        "vendored_blocked",
-    ]);
-    if (!states.has(item.activationState) || !modes.has(item.activationMode))
-        return null;
-    return {
-        activationState: item.activationState === "root_partial"
-            ? "root_partial"
-            : item.activationState === "vendored_only"
-                ? "vendored_only"
-                : item.activationState === "root_active_thin"
-                    ? "root_active_thin"
-                    : item.activationState === "root_active_seeded"
-                        ? "root_active_seeded"
-                        : "root_uninitialized",
-        activationMode: item.activationMode === "repair_bootstrap"
-            ? "repair_bootstrap"
-            : item.activationMode === "attached_thin_handoff"
-                ? "attached_thin_handoff"
-                : item.activationMode === "attached_seeded_handoff"
-                    ? "attached_seeded_handoff"
-                    : item.activationMode === "vendored_blocked"
-                        ? "vendored_blocked"
-                        : "cold_start_bootstrap",
-        applyBlocked: item.applyBlocked,
-        allowCandidateGeneration: item.allowCandidateGeneration,
-        reason: item.reason,
-        ...(typeof item.handoffMessage === "string"
-            ? { handoffMessage: item.handoffMessage }
-            : {}),
-    };
-}

package/dist/tools/check-config.js

@@ -1,67 +0,0 @@
-/*
- Kibi — repo-local, per-branch, queryable long-term memory for software projects
- Copyright (C) 2026 Piotr Franczyk
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Affero General Public License for more details.
-
- 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 { readFile } from "node:fs/promises";
-import * as path from "node:path";
-import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
-// implements REQ-002
-export async function loadChecksConfig(workspaceRoot) {
-    const configPath = path.join(workspaceRoot, ".kb", "config.json");
-    try {
-        const content = await readFile(configPath, "utf8");
-        const parsed = JSON.parse(content);
-        const parsedRules = parsed.checks?.rules;
-        const normalizedRules = {
-            ...DEFAULT_CHECKS_CONFIG.rules,
-        };
-        if (parsedRules && typeof parsedRules === "object") {
-            for (const [key, value] of Object.entries(parsedRules)) {
-                if (typeof value === "boolean") {
-                    normalizedRules[key] = value;
-                }
-            }
-        }
-        const parsedSt = parsed.checks?.symbolTraceability;
-        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
-        if (parsedSt &&
-            typeof parsedSt === "object" &&
-            typeof parsedSt.requireAdr === "boolean") {
-            normalizedSt.requireAdr = parsedSt.requireAdr;
-        }
-        return {
-            rules: normalizedRules,
-            symbolTraceability: normalizedSt,
-        };
-    }
-    catch {
-        return DEFAULT_CHECKS_CONFIG;
-    }
-}
-// implements REQ-002
-export function getEffectiveRules(configRules, requestedRules) {
-    if (requestedRules && requestedRules.length > 0) {
-        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
-    }
-    const effective = new Set();
-    for (const rule of RULE_NAMES) {
-        const enabled = configRules[rule] ?? true;
-        if (enabled) {
-            effective.add(rule);
-        }
-    }
-    return effective;
-}