kibi-mcp 0.3.0 → 0.3.2

package/dist/tools/derive.js

@@ -1,292 +0,0 @@
-import { escapeAtom } from "kibi-cli/prolog/codec";
-import { parseAtomList, parsePairList } from "./prolog-list.js";
-const RULES = [
-    "transitively_implements",
-    "transitively_depends",
-    "impacted_by_change",
-    "affected_symbols",
-    "coverage_gap",
-    "untested_symbols",
-    "stale",
-    "orphaned",
-    "conflicting",
-    "deprecated_still_used",
-    "current_adr",
-    "adr_chain",
-    "superseded_by",
-    "domain_contradictions",
-];
-export async function handleKbDerive(prolog, args) {
-    const params = args.params ?? {};
-    const { rule } = args;
-    if (!RULES.includes(rule)) {
-        throw new Error(`Unsupported rule '${rule}'`);
-    }
-    let rows = [];
-    switch (rule) {
-        case "transitively_implements":
-            rows = await deriveTransitivelyImplements(prolog, params);
-            break;
-        case "transitively_depends":
-            rows = await deriveTransitivelyDepends(prolog, params);
-            break;
-        case "impacted_by_change":
-            rows = await deriveImpactedByChange(prolog, params);
-            break;
-        case "affected_symbols":
-            rows = await deriveAffectedSymbols(prolog, params);
-            break;
-        case "coverage_gap":
-            rows = await deriveCoverageGap(prolog, params);
-            break;
-        case "untested_symbols":
-            rows = await deriveUntestedSymbols(prolog);
-            break;
-        case "stale":
-            rows = await deriveStale(prolog, params);
-            break;
-        case "orphaned":
-            rows = await deriveOrphaned(prolog, params);
-            break;
-        case "conflicting":
-            rows = await deriveConflicting(prolog, params);
-            break;
-        case "deprecated_still_used":
-            rows = await deriveDeprecatedStillUsed(prolog, params);
-            break;
-        case "current_adr":
-            rows = await deriveCurrentAdr(prolog);
-            break;
-        case "adr_chain":
-            rows = await deriveAdrChain(prolog, params);
-            break;
-        case "superseded_by":
-            rows = await deriveSupersededBy(prolog, params);
-            break;
-        case "domain_contradictions":
-            rows = await deriveDomainContradictions(prolog);
-            break;
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Derived ${rows.length} row(s) for rule '${rule}'.`,
-            },
-        ],
-        structuredContent: {
-            rule,
-            params,
-            count: rows.length,
-            rows,
-            provenance: {
-                predicate: rule,
-                deterministic: true,
-            },
-        },
-    };
-}
-async function deriveTransitivelyImplements(prolog, params) {
-    const symbolFilter = asOptionalString(params.symbol);
-    const reqFilter = asOptionalString(params.req);
-    const cond = makeConjunction([
-        symbolFilter ? `Symbol='${escapeAtom(symbolFilter)}'` : "",
-        reqFilter ? `Req='${escapeAtom(reqFilter)}'` : "",
-    ]);
-    const goal = `setof([Symbol,Req], (transitively_implements(Symbol, Req)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([symbol, req]) => ({ symbol, req }));
-}
-async function deriveTransitivelyDepends(prolog, params) {
-    const req1Filter = asOptionalString(params.req1);
-    const req2Filter = asOptionalString(params.req2);
-    const cond = makeConjunction([
-        req1Filter ? `Req1='${escapeAtom(req1Filter)}'` : "",
-        req2Filter ? `Req2='${escapeAtom(req2Filter)}'` : "",
-    ]);
-    const goal = `setof([Req1,Req2], (transitively_depends(Req1, Req2)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([req1, req2]) => ({ req1, req2 }));
-}
-async function deriveImpactedByChange(prolog, params) {
-    const changed = asRequiredString(params.changed, "params.changed is required");
-    const goal = `setof(Entity, impacted_by_change(Entity, '${escapeAtom(changed)}'), Rows)`;
-    const entities = await queryAtomRows(prolog, goal, "Rows");
-    return entities.map((entity) => ({ changed, entity }));
-}
-async function deriveAffectedSymbols(prolog, params) {
-    const req = asRequiredString(params.req, "params.req is required");
-    const goal = `affected_symbols('${escapeAtom(req)}', Symbols)`;
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings.Symbols) {
-        return [];
-    }
-    const symbols = parseAtomList(result.bindings.Symbols);
-    return symbols.map((symbol) => ({ req, symbol }));
-}
-async function deriveCoverageGap(prolog, params) {
-    const reqFilter = asOptionalString(params.req);
-    const cond = reqFilter ? `Req='${escapeAtom(reqFilter)}'` : "";
-    const goal = `setof([Req,Reason], (coverage_gap(Req, Reason)${makeConjunction([cond])}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([req, reason]) => ({ req, reason }));
-}
-async function deriveUntestedSymbols(prolog) {
-    const result = await prolog.query("untested_symbols(Symbols)");
-    if (!result.success || !result.bindings.Symbols) {
-        return [];
-    }
-    const symbols = parseAtomList(result.bindings.Symbols);
-    return symbols.map((symbol) => ({ symbol }));
-}
-async function deriveStale(prolog, params) {
-    const maxAgeDays = Number(params.max_age_days ?? params.maxAgeDays);
-    if (!Number.isFinite(maxAgeDays)) {
-        throw new Error("params.max_age_days is required and must be numeric");
-    }
-    const entityFilter = asOptionalString(params.entity);
-    const cond = entityFilter ? `Entity='${escapeAtom(entityFilter)}'` : "";
-    const goal = `setof(Entity, (stale(Entity, ${maxAgeDays})${makeConjunction([cond])}), Rows)`;
-    const entities = await queryAtomRows(prolog, goal, "Rows");
-    return entities.map((entity) => ({ entity, max_age_days: maxAgeDays }));
-}
-async function deriveOrphaned(prolog, params) {
-    const symbolFilter = asOptionalString(params.symbol);
-    const cond = symbolFilter ? `Symbol='${escapeAtom(symbolFilter)}'` : "";
-    const goal = `setof(Symbol, (orphaned(Symbol)${makeConjunction([cond])}), Rows)`;
-    const symbols = await queryAtomRows(prolog, goal, "Rows");
-    return symbols.map((symbol) => ({ symbol }));
-}
-async function deriveConflicting(prolog, params) {
-    const adr1Filter = asOptionalString(params.adr1);
-    const adr2Filter = asOptionalString(params.adr2);
-    const cond = makeConjunction([
-        adr1Filter ? `Adr1='${escapeAtom(adr1Filter)}'` : "",
-        adr2Filter ? `Adr2='${escapeAtom(adr2Filter)}'` : "",
-    ]);
-    const goal = `setof([Adr1,Adr2], (conflicting(Adr1, Adr2)${cond}), Rows)`;
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([adr1, adr2]) => ({ adr1, adr2 }));
-}
-async function deriveDeprecatedStillUsed(prolog, params) {
-    const adrFilter = asOptionalString(params.adr);
-    const goal = adrFilter
-        ? `deprecated_still_used('${escapeAtom(adrFilter)}', Symbols)`
-        : "setof([Adr,Symbols], deprecated_still_used(Adr, Symbols), Rows)";
-    if (adrFilter) {
-        const result = await prolog.query(goal);
-        if (!result.success || !result.bindings.Symbols) {
-            return [];
-        }
-        return [
-            { adr: adrFilter, symbols: parseAtomList(result.bindings.Symbols) },
-        ];
-    }
-    const pairs = await queryPairRows(prolog, goal, "Rows");
-    return pairs.map(([adr, symbolsRaw]) => ({
-        adr,
-        symbols: parseAtomList(symbolsRaw),
-    }));
-}
-async function queryAtomRows(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parseAtomList(result.bindings[bindingName]);
-}
-async function queryPairRows(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parsePairList(result.bindings[bindingName]);
-}
-function asOptionalString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function asRequiredString(value, message) {
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(message);
-    }
-    return value;
-}
-function makeConjunction(parts) {
-    const filtered = parts.filter((part) => part.length > 0);
-    if (filtered.length === 0) {
-        return "";
-    }
-    return `, ${filtered.join(", ")}`;
-}
-async function deriveCurrentAdr(prolog) {
-    // Query for all current ADRs and their titles
-    const result = await prolog.query("setof([Id,TitleAtom], (kb_entity(Id, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom), current_adr(Id)), Rows)");
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    const pairs = parsePairList(result.bindings.Rows);
-    return pairs.map(([id, title]) => ({ id, title }));
-}
-async function deriveAdrChain(prolog, params) {
-    const adr = asRequiredString(params.adr, "params.adr is required");
-    // Query for the full chain including status
-    const result = await prolog.query(`findall([Id,TitleAtom,StatusAtom], (kb_entity(Id, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom), memberchk(status=Status, Props), normalize_term_atom(Status, StatusAtom), adr_chain('${escapeAtom(adr)}', Chain), member(Id, Chain)), Rows)`);
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    // Parse triplets and include status
-    const triplets = parseTripleList(result.bindings.Rows);
-    return triplets.map(([id, title, status]) => ({ id, title, status }));
-}
-async function deriveSupersededBy(prolog, params) {
-    const adr = asRequiredString(params.adr, "params.adr is required");
-    // Query for direct supersession
-    const result = await prolog.query(`superseded_by('${escapeAtom(adr)}', NewAdr), kb_entity(NewAdr, adr, Props), memberchk(title=Title, Props), normalize_term_atom(Title, TitleAtom)`);
-    if (!result.success ||
-        !result.bindings.NewAdr ||
-        !result.bindings.TitleAtom) {
-        return [];
-    }
-    const newAdr = String(result.bindings.NewAdr).replace(/^'|'$/g, "");
-    const newAdrTitle = String(result.bindings.TitleAtom).replace(/^'|'$/g, "");
-    return [
-        {
-            adr,
-            successor_id: newAdr,
-            successor_title: newAdrTitle,
-        },
-    ];
-}
-function parseTripleList(raw) {
-    const match = raw.match(/\[(.*)\]/);
-    if (!match) {
-        return [];
-    }
-    const content = match[1].trim();
-    if (!content) {
-        return [];
-    }
-    // Parse triplets: [[a,b,c],[x,y,z],...]
-    const triplets = [];
-    const tripletRegex = /\[([^,]+),([^,]+),([^\]]+)\]/g;
-    let tripletMatch;
-    do {
-        tripletMatch = tripletRegex.exec(content);
-        if (tripletMatch !== null) {
-            triplets.push([
-                tripletMatch[1].trim().replace(/^'|'$/g, ""),
-                tripletMatch[2].trim().replace(/^'|'$/g, ""),
-                tripletMatch[3].trim().replace(/^'|'$/g, ""),
-            ]);
-        }
-    } while (tripletMatch !== null);
-    return triplets;
-}
-async function deriveDomainContradictions(prolog) {
-    const result = await prolog.query("setof([ReqA,ReqB,Reason], contradicting_reqs(ReqA, ReqB, Reason), Rows)");
-    if (!result.success || !result.bindings.Rows) {
-        return [];
-    }
-    const rows = parseTripleList(result.bindings.Rows);
-    return rows.map(([reqA, reqB, reason]) => ({ reqA, reqB, reason }));
-}

package/dist/tools/impact.js

@@ -1,51 +0,0 @@
-import { escapeAtom } from "kibi-cli/prolog/codec";
-import { parseAtomList } from "./prolog-list.js";
-export async function handleKbImpact(prolog, args) {
-    if (!args.entity || typeof args.entity !== "string") {
-        throw new Error("'entity' is required");
-    }
-    const goal = `setof(Id, (impacted_by_change(Id, '${escapeAtom(args.entity)}'), Id \\= '${escapeAtom(args.entity)}'), Impacted)`;
-    const impactedIds = await queryAtoms(prolog, goal, "Impacted");
-    const impacted = [];
-    for (const id of impactedIds) {
-        const type = await getEntityType(prolog, id);
-        impacted.push({ id, type: type ?? "unknown" });
-    }
-    impacted.sort((a, b) => {
-        if (a.type === b.type) {
-            return a.id.localeCompare(b.id);
-        }
-        return a.type.localeCompare(b.type);
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Impact analysis for '${args.entity}': ${impacted.length} impacted entity(s).`,
-            },
-        ],
-        structuredContent: {
-            entity: args.entity,
-            impacted,
-            count: impacted.length,
-            provenance: {
-                predicate: "impacted_by_change",
-                deterministic: true,
-            },
-        },
-    };
-}
-async function queryAtoms(prolog, goal, bindingName) {
-    const result = await prolog.query(goal);
-    if (!result.success || !result.bindings[bindingName]) {
-        return [];
-    }
-    return parseAtomList(result.bindings[bindingName]);
-}
-async function getEntityType(prolog, id) {
-    const result = await prolog.query(`kb_entity('${escapeAtom(id)}', Type, _)`);
-    if (!result.success || !result.bindings.Type) {
-        return null;
-    }
-    return result.bindings.Type;
-}

package/dist/tools/list-types.js

@@ -1,58 +0,0 @@
-/**
- * Handle kb_list_entity_types tool calls
- * Returns the static list of supported KB entity type names (req, scenario, test, adr, flag, event, symbol, fact).
- */
-export async function handleKbListEntityTypes() {
-    return {
-        content: [
-            {
-                type: "text",
-                text: "Available entity types: req, scenario, test, adr, flag, event, symbol, fact",
-            },
-        ],
-        structuredContent: {
-            types: [
-                "req",
-                "scenario",
-                "test",
-                "adr",
-                "flag",
-                "event",
-                "symbol",
-                "fact",
-            ],
-        },
-    };
-}
-/**
- * Handle kb_list_relationship_types tool calls
- * Returns the static list of supported KB relationship type names (depends_on, specified_by, verified_by, etc.).
- */
-export async function handleKbListRelationshipTypes() {
-    return {
-        content: [
-            {
-                type: "text",
-                text: "Available relationship types: depends_on, specified_by, verified_by, validates, implements, covered_by, constrained_by, constrains, requires_property, guards, publishes, consumes, supersedes, relates_to",
-            },
-        ],
-        structuredContent: {
-            types: [
-                "depends_on",
-                "specified_by",
-                "verified_by",
-                "validates",
-                "implements",
-                "covered_by",
-                "constrained_by",
-                "constrains",
-                "requires_property",
-                "guards",
-                "publishes",
-                "consumes",
-                "supersedes",
-                "relates_to",
-            ],
-        },
-    };
-}

package/dist/tools/query-relationships.js

@@ -1,159 +0,0 @@
-const VALID_REL_TYPES = [
-    "depends_on",
-    "specified_by",
-    "verified_by",
-    "validates",
-    "implements",
-    "covered_by",
-    "constrained_by",
-    "constrains",
-    "requires_property",
-    "guards",
-    "publishes",
-    "consumes",
-    "supersedes",
-    "relates_to",
-];
-/**
- * Handle kb_query_relationships tool calls.
- * Queries the kb_relationship/3 predicate which has arity (Type, From, To).
- *
- * Note: kb_relationship/3 requires RelType to be bound (atom_concat/3 in Prolog
- * does not work with an unbound first argument). When no type filter is given,
- * we iterate over all known type values.
- */
-export async function handleKbQueryRelationships(prolog, args) {
-    const { from, to, type } = args;
-    if (type && !VALID_REL_TYPES.includes(type)) {
-        throw new Error(`Invalid relationship type '${type}'. Valid types: ${VALID_REL_TYPES.join(", ")}`);
-    }
-    // When type is specified we run one query; otherwise iterate all known types
-    // (kb_relationship/3 requires the type to be bound due to atom_concat/3 in Prolog).
-    const typesToQuery = type ? [type] : VALID_REL_TYPES;
-    const allRelationships = [];
-    for (const relType of typesToQuery) {
-        // We collect what we actually need based on which args are bound.
-        // When both from and to are specified, we just need to check existence.
-        // Otherwise collect the unbound sides.
-        let goal;
-        if (from && to) {
-            // Check if the specific triple exists
-            goal = `(kb_relationship('${relType}', '${from}', '${to}') -> Results = [['${from}','${to}']] ; Results = [])`;
-        }
-        else if (from) {
-            goal = `findall(To, kb_relationship('${relType}', '${from}', To), Results)`;
-        }
-        else if (to) {
-            goal = `findall(From, kb_relationship('${relType}', From, '${to}'), Results)`;
-        }
-        else {
-            goal = `findall([From,To], kb_relationship('${relType}', From, To), Results)`;
-        }
-        const queryResult = await prolog.query(goal);
-        if (!queryResult.success) {
-            throw new Error(queryResult.error || "Relationship query failed");
-        }
-        if (queryResult.bindings.Results) {
-            const raw = queryResult.bindings.Results;
-            if (from && to) {
-                // Results is either [[from,to]] or []
-                const pairs = parsePairResults(raw);
-                for (const [pairFrom, pairTo] of pairs) {
-                    allRelationships.push({ relType, from: pairFrom, to: pairTo });
-                }
-            }
-            else if (from) {
-                // Results is [To, To, ...]
-                const ids = parseIdList(raw);
-                for (const toId of ids) {
-                    allRelationships.push({ relType, from, to: toId });
-                }
-            }
-            else if (to) {
-                // Results is [From, From, ...]
-                const ids = parseIdList(raw);
-                for (const fromId of ids) {
-                    allRelationships.push({ relType, from: fromId, to });
-                }
-            }
-            else {
-                // Results is [[From,To], ...]
-                const pairs = parsePairResults(raw);
-                for (const [pairFrom, pairTo] of pairs) {
-                    allRelationships.push({ relType, from: pairFrom, to: pairTo });
-                }
-            }
-        }
-    }
-    const text = allRelationships.length === 0
-        ? "No relationships found."
-        : `Found ${allRelationships.length} relationship(s): ${allRelationships
-            .map((r) => `${r.from} -[${r.relType}]-> ${r.to}`)
-            .join(", ")}`;
-    return {
-        content: [{ type: "text", text }],
-        structuredContent: {
-            relationships: allRelationships,
-            count: allRelationships.length,
-        },
-    };
-}
-/**
- * Parse a flat Prolog list of atoms "[A,B,C]" into a string array.
- */
-function parseIdList(raw) {
-    const cleaned = raw.trim();
-    if (cleaned === "[]" || cleaned === "")
-        return [];
-    const inner = cleaned.replace(/^\[/, "").replace(/\]$/, "");
-    return inner
-        .split(",")
-        .map((s) => s.trim().replace(/^'|'$/g, "").replace(/^"|"$/g, ""))
-        .filter(Boolean);
-}
-/**
- * Parse Prolog findall result "[[From,To],...]" into [from, to] pairs.
- */
-function parsePairResults(raw) {
-    const cleaned = raw.trim();
-    if (cleaned === "[]" || cleaned === "")
-        return [];
-    const inner = cleaned.replace(/^\[/, "").replace(/\]$/, "");
-    const pairs = [];
-    let depth = 0;
-    let current = "";
-    for (let i = 0; i < inner.length; i++) {
-        const ch = inner[i];
-        if (ch === "[") {
-            depth++;
-            current += ch;
-        }
-        else if (ch === "]") {
-            depth--;
-            current += ch;
-            if (depth === 0) {
-                const pair = parsePair(current.trim());
-                if (pair)
-                    pairs.push(pair);
-                current = "";
-            }
-        }
-        else if (ch === "," && depth === 0) {
-            // top-level separator between pairs — skip
-        }
-        else {
-            current += ch;
-        }
-    }
-    return pairs;
-}
-function parsePair(pairStr) {
-    // expect "[From,To]"
-    const inner = pairStr.replace(/^\[/, "").replace(/\]$/, "").trim();
-    const parts = inner
-        .split(",")
-        .map((s) => s.trim().replace(/^'|'$/g, "").replace(/^"|"$/g, ""));
-    if (parts.length < 2)
-        return null;
-    return [parts[0], parts[1]];
-}

package/dist/tools/suggest-shared-facts.js

@@ -1,121 +0,0 @@
-import { parseAtomList } from "./prolog-list.js";
-/**
- * Handle analyze_shared_facts tool calls
- * Analyzes requirements to suggest shared domain facts for extraction
- */
-export async function handleSuggestSharedFacts(prolog, args) {
-    const minFreq = args.min_frequency ?? 2;
-    try {
-        // Query all requirements with their text properties
-        const reqsResult = await prolog.query("findall([Id,Title], (kb_entity(Id, req, Props), memberchk(title=Title, Props)), Reqs)");
-        if (!reqsResult.success || !reqsResult.bindings.Reqs) {
-            return {
-                content: [{ type: "text", text: "No requirements found in KB" }],
-                structuredContent: { suggestions: [], count: 0 },
-            };
-        }
-        const reqsList = parseAtomList(reqsResult.bindings.Reqs);
-        const requirements = [];
-        // Parse the list-of-lists format from Prolog
-        const reqMatch = reqsList.join("").matchAll(/\[([^,]+),([^\]]+)\]/g);
-        if (reqMatch) {
-            for (const match of reqMatch) {
-                const id = match[1].trim().replace(/^'|'$/g, "");
-                const title = match[2].trim().replace(/^'|'$/g, "");
-                requirements.push({ id, title, description: title });
-            }
-        }
-        // Query all existing facts for context
-        const factsResult = await prolog.query("findall([Id,Title], (kb_entity(Id, fact, Props), memberchk(title=Title, Props)), Facts)");
-        if (!factsResult.success || !factsResult.bindings.Facts) {
-            return {
-                content: [{ type: "text", text: "No facts found in KB" }],
-                structuredContent: { suggestions: [], count: 0 },
-            };
-        }
-        const factsList = parseAtomList(factsResult.bindings.Facts);
-        const existingFacts = new Set();
-        const factMatch = factsList.join("").matchAll(/\[([^,]+),([^\]]+)\]/g);
-        if (factMatch) {
-            for (const match of factMatch) {
-                const title = match[2].trim().replace(/^'|'$/g, "");
-                existingFacts.add(title.toLowerCase());
-            }
-        }
-        // Extract and analyze domain concepts from requirements
-        const suggestions = analyzeSharedConcepts(requirements, existingFacts, minFreq);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Found ${suggestions.length} potential shared fact(s) to consider creating.`,
-                },
-            ],
-            structuredContent: {
-                suggestions,
-                count: suggestions.length,
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Shared facts analysis failed: ${message}`);
-    }
-}
-/**
- * Lightweight heuristic to identify shared domain concepts
- * Focuses on:
- * - Capitalized terms (possible domain concepts)
- * - Repeated phrases across multiple requirements
- * - Excludes existing facts
- */
-function analyzeSharedConcepts(requirements, existingFacts, minFreq) {
-    const conceptCounts = new Map();
-    for (const req of requirements) {
-        const originalText = `${req.title} ${req.description || ""}`;
-        const text = originalText.toLowerCase();
-        // Extract capitalized terms (potential domain concepts)
-        // Pattern: words starting with capital letters that aren't at sentence start
-        const capitalizedTerms = originalText.matchAll(/\b([A-Z][a-z]+)\b/g);
-        // Extract repeated phrases (2+ words)
-        // Extract repeated phrases (2+ words)
-        const words = text.split(/\s+/).filter((w) => w.length > 3);
-        for (let i = 0; i < words.length - 1; i++) {
-            const phrase = `${words[i]} ${words[i + 1]}`;
-            if (!conceptCounts.has(phrase)) {
-                conceptCounts.set(phrase, new Set());
-            }
-            conceptCounts.get(phrase).add(req.id);
-        }
-        // Also track individual capitalized terms
-        for (const match of capitalizedTerms) {
-            const lowerTerm = match[1].toLowerCase(); // Get the captured group
-            if (!conceptCounts.has(lowerTerm)) {
-                conceptCounts.set(lowerTerm, new Set());
-            }
-            conceptCounts.get(lowerTerm).add(req.id);
-        }
-    }
-    // Generate suggestions
-    const suggestions = [];
-    for (const [concept, reqIds] of conceptCounts) {
-        if (reqIds.size >= minFreq) {
-            // Skip if this concept already exists as a fact
-            if (!existingFacts.has(concept)) {
-                suggestions.push({
-                    concept: capitalizeConcept(concept),
-                    mentions: reqIds.size,
-                    requirements: Array.from(reqIds),
-                });
-            }
-        }
-    }
-    // Sort by frequency (most mentioned first)
-    return suggestions.sort((a, b) => b.mentions - a.mentions);
-}
-function capitalizeConcept(concept) {
-    return concept
-        .split(/\s+/)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(" ");
-}