mcp-cognition-engine 1.0.0-alpha.1

package/dist/cognition-engine/ast-constraint-solver.js

@@ -0,0 +1,294 @@
+/**
+ * Copyright 2026 熊高锐
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { parseToAST } from "../legacy-engine/parsers.js";
+// ── DSL Parser ────────────────────────────────────────────
+/**
+ * Parse templateDsl JSON string into AstConstraint array.
+ */
+export function parseConstraintDsl(dsl) {
+    try {
+        const parsed = JSON.parse(dsl);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object" && parsed.nodeType) {
+            return [parsed];
+        }
+        return [];
+    }
+    catch {
+        // If plain text, try line-based DSL format:
+        //   NODE:FunctionDeclaration
+        //   FIELD:name MATCH:{{placeholder}}
+        //   FIELD:returnType EXISTS:true
+        return parseLineBasedDsl(dsl);
+    }
+}
+function parseLineBasedDsl(dsl) {
+    const constraints = [];
+    let current = null;
+    for (const line of dsl.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("NODE:")) {
+            if (current)
+                constraints.push(current);
+            current = { nodeType: trimmed.slice(5).trim(), fields: {} };
+        }
+        else if (trimmed.startsWith("FIELD:") && current) {
+            const rest = trimmed.slice(6);
+            const matchMatcher = rest.match(/^(\S+)\s+MATCH:(.+)$/);
+            const existsMatcher = rest.match(/^(\S+)\s+EXISTS:(true|false)$/);
+            const childTypeMatcher = rest.match(/^(\S+)\s+CHILD_TYPE:(.+)$/);
+            if (matchMatcher) {
+                current.fields[matchMatcher[1]] = { match: matchMatcher[2] };
+            }
+            else if (existsMatcher) {
+                current.fields[existsMatcher[1]] = { exists: existsMatcher[2] === "true" };
+            }
+            else if (childTypeMatcher) {
+                current.fields[childTypeMatcher[1]] = { childType: childTypeMatcher[2] };
+            }
+        }
+    }
+    if (current)
+        constraints.push(current);
+    return constraints;
+}
+/**
+ * Bind {{placeholder}} values in a constraint to actual AST node text.
+ * Walks the AST to find nodes matching each constraint's nodeType,
+ * then extracts text values for placeholders.
+ */
+export function bindConstraints(constraints, ast) {
+    const bindings = {};
+    const bound = constraints.map((c) => ({
+        ...c,
+        fields: Object.fromEntries(Object.entries(c.fields).map(([key, fc]) => {
+            const boundFc = { ...fc };
+            if (fc.match && fc.match.includes("{{")) {
+                const placeholder = fc.match.match(/\{\{(.+?)\}\}/)?.[1];
+                if (placeholder) {
+                    const actualValue = extractFieldValue(ast, c.nodeType, key);
+                    if (actualValue) {
+                        bindings[placeholder] = actualValue;
+                        boundFc.match = fc.match.replace(/\{\{(.+?)\}\}/, actualValue);
+                    }
+                }
+            }
+            return [key, boundFc];
+        })),
+    }));
+    return { bound, bindings };
+}
+/**
+ * Extract a field value from an AST node.
+ * Simplified: checks node type match, then children for field values.
+ */
+function extractFieldValue(ast, nodeType, field) {
+    const matchingNodes = findNodesByType(ast, nodeType);
+    if (matchingNodes.length === 0)
+        return null;
+    const node = matchingNodes[0];
+    // Check if any child's type matches the field name
+    for (const child of node.children) {
+        if (child.type === field) {
+            return child.text;
+        }
+    }
+    // Fallback: return node text itself
+    return field === "name" ? node.text : null;
+}
+function findNodesByType(node, type) {
+    const results = [];
+    if (node.type === type)
+        results.push(node);
+    for (const child of node.children) {
+        results.push(...findNodesByType(child, type));
+    }
+    return results;
+}
+// ── Constraint Validation ─────────────────────────────────
+/**
+ * Validate an AST against a set of bound constraints.
+ *
+ * @param constraints  Parsed + bound AstConstraint array
+ * @param nodeId       Source cognition node ID (for traceability)
+ * @param templateDsl  Original template DSL string
+ * @param ast          Target AST to validate
+ * @returns Structured validation result
+ */
+export function validateConstraints(constraints, nodeId, templateDsl, ast) {
+    const failures = [];
+    for (const constraint of constraints) {
+        const matchingNodes = findNodesByType(ast, constraint.nodeType);
+        if (matchingNodes.length === 0) {
+            failures.push({
+                nodeId,
+                templateDsl,
+                constraintPath: '$.type',
+                expected: constraint.nodeType,
+                actual: `(no matching node)`,
+            });
+            continue;
+        }
+        for (const matchingNode of matchingNodes) {
+            for (const [fieldName, fieldConstraint] of Object.entries(constraint.fields)) {
+                const result = checkFieldConstraint(fieldName, fieldConstraint, matchingNode);
+                if (result) {
+                    failures.push({ nodeId, templateDsl, ...result });
+                }
+            }
+        }
+    }
+    return {
+        isValid: failures.length === 0,
+        failures,
+    };
+}
+function checkFieldConstraint(fieldName, fc, node) {
+    // Check existence
+    if (fc.exists !== undefined) {
+        const exists = node.children.some((c) => c.type === fieldName);
+        if (fc.exists && !exists) {
+            return {
+                constraintPath: '$.children.',
+                expected: 'exists: true',
+                actual: `(child "${fieldName}" not found)`,
+            };
+        }
+    }
+    // Check match (literal or bound placeholder)
+    if (fc.match) {
+        const actual = node.text;
+        if (actual !== fc.match) {
+            return {
+                constraintPath: '$.text',
+                expected: fc.match,
+                actual,
+            };
+        }
+    }
+    // Check child type
+    if (fc.childType) {
+        const hasChild = node.children.some((c) => c.type === fc.childType);
+        if (!hasChild) {
+            return {
+                constraintPath: '$.children.' + fieldName,
+                expected: fc.childType,
+                actual: `(child "${fc.childType}" not found)`,
+            };
+        }
+    }
+    // Check child count
+    if (fc.childCount) {
+        const count = node.children.length;
+        if (fc.childCount.min !== undefined && count < fc.childCount.min) {
+            return {
+                constraintPath: '$.children.length',
+                expected: '>= ' + fc.childCount.min,
+                actual: String(count),
+            };
+        }
+        if (fc.childCount.max !== undefined && count > fc.childCount.max) {
+            return {
+                constraintPath: '$.children.length',
+                expected: '<= ' + fc.childCount.max,
+                actual: String(count),
+            };
+        }
+    }
+    return null;
+}
+// ── Transform Patch Generation ────────────────────────────
+/**
+ * Generate a transform patch from validation failures.
+ * Creates operations that would fix the validation failures.
+ */
+export function generatePatchFromFailures(failures, ast) {
+    const patches = new Map();
+    for (const failure of failures) {
+        const nodeId = failure.nodeId;
+        if (!patches.has(nodeId)) {
+            patches.set(nodeId, { nodeId, operations: [], description: "" });
+        }
+        const patch = patches.get(nodeId);
+        const ops = [];
+        if (failure.actual.includes("(no matching node)")) {
+            ops.push({
+                type: "INSERT",
+                path: "$",
+                value: failure.expected,
+                originalText: undefined,
+            });
+        }
+        else if (failure.constraintPath === "$.text") {
+            ops.push({
+                type: "REPLACE",
+                path: "$.text",
+                value: failure.expected,
+                originalText: failure.actual,
+            });
+        }
+        patch.operations.push(...ops);
+        const briefDesc = `${failure.constraintPath}: "${failure.actual}" → "${failure.expected}"`;
+        patch.description = patch.description
+            ? `${patch.description}; `
+            : briefDesc;
+    }
+    return [...patches.values()];
+}
+// ── High-level API ────────────────────────────────────────
+/**
+ * Run the full constraint-solving pipeline:
+ *   1. Parse templateDSL from cognition nodes
+ *   2. Parse file content to AST
+ *   3. Bind {{placeholder}} values
+ *   4. Validate constraints
+ *   5. Generate transform patches
+ *
+ * @param cognitionNodes  Nodes with astTemplate to check
+ * @param fileContent     Source code to validate against
+ * @param language        Language for AST parsing
+ * @returns Validation + patch results
+ */
+export async function solveConstraints(cognitionNodes, fileContent, language) {
+    const allValidations = [];
+    const allPatches = [];
+    const allBindings = {};
+    const { ast } = await parseToAST(fileContent, language);
+    for (const node of cognitionNodes) {
+        if (!node.astTemplate)
+            continue;
+        const constraints = parseConstraintDsl(node.astTemplate.templateDsl);
+        if (constraints.length === 0)
+            continue;
+        const { bound, bindings } = bindConstraints(constraints, ast);
+        Object.assign(allBindings, bindings);
+        const validation = validateConstraints(bound, node.id, node.astTemplate.templateDsl, ast);
+        allValidations.push(validation);
+        if (!validation.isValid) {
+            const patches = generatePatchFromFailures(validation.failures, ast);
+            allPatches.push(...patches);
+        }
+    }
+    return {
+        validations: allValidations,
+        patches: allPatches,
+        boundValues: allBindings,
+    };
+}
+//# sourceMappingURL=ast-constraint-solver.js.map

package/dist/cognition-engine/ast-constraint-solver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-constraint-solver.js","sourceRoot":"","sources":["../../src/cognition-engine/ast-constraint-solver.ts"],"names":[],"mappings":"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"}

package/dist/cognition-engine/constraint-validator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2026 熊高锐
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type ValidationMode = "REJECT" | "WARN";
+export type RuleLevel = "GLOBAL" | "PROJECT";
+export interface ConstraintViolation {
+    ruleId: string;
+    ruleLevel: RuleLevel;
+    mode: ValidationMode;
+    constraintPath: string;
+    expected: string;
+    actual: string;
+    message: string;
+}
+export interface ValidationReport {
+    passed: boolean;
+    violations: ConstraintViolation[];
+    hardBlocks: number;
+    softWarnings: number;
+}
+/** Validate code content against constraints. */
+export declare function validateCode(codeContent: string, language: string, projectId?: string): Promise<ValidationReport>;
+//# sourceMappingURL=constraint-validator.d.ts.map

package/dist/cognition-engine/constraint-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-validator.d.ts","sourceRoot":"","sources":["../../src/cognition-engine/constraint-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAC/C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,iDAAiD;AACjD,wBAAsB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAqBvH"}

package/dist/cognition-engine/constraint-validator.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright 2026 熊高锐
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file Constraint Validator — Trust & Governance Layer
+ * Reuses Phase 3 AstTemplate DSL parser for dual-mode validation.
+ */
+import { parseConstraintDsl, validateConstraints } from "../cognition-engine/ast-constraint-solver.js";
+import { CognitionRepository } from "../storage/cognition-repository.js";
+/** Validate code content against constraints. */
+export async function validateCode(codeContent, language, projectId) {
+    const repo = new CognitionRepository();
+    const violations = [];
+    const hash = simpleHash("NEGATIVE_CONSTRAINT:" + language);
+    const negativeNodes = await repo.findNodesBySemanticHash(hash);
+    let hardBlocks = 0;
+    let softWarnings = 0;
+    for (const node of negativeNodes) {
+        if (!node.astTemplate)
+            continue;
+        const constraints = parseConstraintDsl(node.astTemplate.templateDsl);
+        if (constraints.length === 0)
+            continue;
+        const { ast } = await import("../legacy-engine/parsers.js").then(m => m.parseToAST(codeContent, language));
+        const result = validateConstraints(constraints, node.id, node.astTemplate.templateDsl, ast);
+        if (!result.isValid) {
+            for (const f of result.failures) {
+                violations.push({ ruleId: node.id, ruleLevel: "GLOBAL", mode: "REJECT", constraintPath: f.constraintPath, expected: f.expected, actual: f.actual, message: "Hard block: " + f.constraintPath });
+                hardBlocks++;
+            }
+        }
+    }
+    return { passed: hardBlocks === 0, violations, hardBlocks, softWarnings };
+}
+function simpleHash(s) {
+    let hash = 0;
+    for (let i = 0; i < s.length; i++) {
+        hash = ((hash << 5) - hash) + s.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(16);
+}
+//# sourceMappingURL=constraint-validator.js.map

package/dist/cognition-engine/constraint-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-validator.js","sourceRoot":"","sources":["../../src/cognition-engine/constraint-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACvG,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAsBzE,iDAAiD;AACjD,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,WAAmB,EAAE,QAAgB,EAAE,SAAkB;IAC1F,MAAM,IAAI,GAAG,IAAI,mBAAmB,EAAE,CAAC;IACvC,MAAM,UAAU,GAA0B,EAAE,CAAC;IAC7C,MAAM,IAAI,GAAG,UAAU,CAAC,sBAAsB,GAAG,QAAQ,CAAC,CAAC;IAC3D,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;IAC/D,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,SAAS;QAChC,MAAM,WAAW,GAAG,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACrE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACvC,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC3G,MAAM,MAAM,GAAG,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;QAC5F,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAChC,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC,cAAc,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC;gBAChM,UAAU,EAAE,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,UAAU,KAAK,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AAC5E,CAAC;AAED,SAAS,UAAU,CAAC,CAAS;IAC3B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAAC,IAAI,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAAC,IAAI,IAAI,CAAC,CAAC;IAAC,CAAC;IAChG,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AACrC,CAAC"}

package/dist/cognition-engine/graph-traverser.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2026 熊高锐
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file Graph Traverser
+ * Replaces the legacy rule-matcher by performing weighted BFS/DFS traversal
+ * over the cognition graph, starting from nodes matching the current code context.
+ *
+ * Reuses: ast-node.ts (computeSemanticHash-like logic via cognition-repository)
+ */
+import { CognitionRepository } from "../storage/cognition-repository.js";
+import type { TraversalOptions, TraversalResult } from "./types.js";
+export declare class GraphTraverser {
+    private repo;
+    constructor(repo?: CognitionRepository);
+    /**
+     * Traverse the cognition graph starting from nodes relevant to the given code context.
+     *
+     * @param language   Programming language (e.g., "typescript", "python")
+     * @param filePath   File path for context extraction
+     * @param content    Code snippet or AST signature for semantic matching
+     * @param options    Traversal options
+     * @returns Scored cognition nodes sorted by relevance
+     */
+    traverse(language: string, filePath: string, content: string, options?: TraversalOptions, contextHash?: string): Promise<TraversalResult>;
+    /** Check if moving from sourceLevel to targetLevel is compatible. */
+    private isLevelCompatible;
+    /** Compute a relevance score [0, 1] for a frontier entry. */
+    private computeNodeScore;
+}
+//# sourceMappingURL=graph-traverser.d.ts.map

package/dist/cognition-engine/graph-traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-traverser.d.ts","sourceRoot":"","sources":["../../src/cognition-engine/graph-traverser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAuB,MAAM,oCAAoC,CAAC;AAI9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAuB,MAAM,YAAY,CAAC;AAoCzF,qBAAa,cAAc;IACzB,OAAO,CAAC,IAAI,CAAsB;gBAEtB,IAAI,CAAC,EAAE,mBAAmB;IAItC;;;;;;;;OAQG;IACG,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,EAC9B,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,eAAe,CAAC;IA2H3B,qEAAqE;IACrE,OAAO,CAAC,iBAAiB;IAyBzB,6DAA6D;IAC7D,OAAO,CAAC,gBAAgB;CAezB"}

package/dist/cognition-engine/graph-traverser.js

@@ -0,0 +1,205 @@
+/**
+ * Copyright 2026 熊高锐
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file Graph Traverser
+ * Replaces the legacy rule-matcher by performing weighted BFS/DFS traversal
+ * over the cognition graph, starting from nodes matching the current code context.
+ *
+ * Reuses: ast-node.ts (computeSemanticHash-like logic via cognition-repository)
+ */
+import { CognitionRepository, computeSemanticHash } from "../storage/cognition-repository.js";
+// ── Constants ─────────────────────────────────────────────
+/** Edge relation multipliers for weighted traversal. */
+const RELATION_MULTIPLIERS = {
+    CAUSES: 1.5,
+    PRECEDES: 1.3,
+    REFINES: 1.2,
+    GENERALIZES: 0.5,
+    MUTEX: 0.3,
+};
+/** Intent bias: adjusts abstraction level preference based on intent. */
+const INTENT_BIAS = {
+    REFACTOR: [2, 3, 1, 0], // prefer architecture/module level
+    BUGFIX: [0, 1, 2, 3], // prefer concrete/function level
+    BOILERPLATE: [1, 2, 0, 3], // prefer module/function level
+};
+const DEFAULT_MAX_DEPTH = 5;
+const DEFAULT_MIN_RELEVANCE = 0.1;
+const DEFAULT_MAX_DURATION_MS = 500;
+// ── Graph Traverser ───────────────────────────────────────
+export class GraphTraverser {
+    repo;
+    constructor(repo) {
+        this.repo = repo ?? new CognitionRepository();
+    }
+    /**
+     * Traverse the cognition graph starting from nodes relevant to the given code context.
+     *
+     * @param language   Programming language (e.g., "typescript", "python")
+     * @param filePath   File path for context extraction
+     * @param content    Code snippet or AST signature for semantic matching
+     * @param options    Traversal options
+     * @returns Scored cognition nodes sorted by relevance
+     */
+    async traverse(language, filePath, content, options = {}, contextHash) {
+        const startTime = performance.now();
+        const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+        const minRelevance = options.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+        const maxDuration = options.maxDurationMs ?? DEFAULT_MAX_DURATION_MS;
+        const intentHint = options.intentHint;
+        // 1. Compute semantic hash from code content
+        const semanticHash = contextHash ?? computeSemanticHash(language + ":" + filePath.split(".").pop(), { contentHash: simpleHash(content) });
+        // 2. Find matching nodes in the graph
+        const matchedNodes = await this.repo.findNodesBySemanticHash(semanticHash);
+        // If no exact match, try a broader search using file extension
+        let startNodes = matchedNodes;
+        if (startNodes.length === 0) {
+            const extHash = computeSemanticHash(language, { ext: filePath.split(".").pop() });
+            startNodes = await this.repo.findNodesBySemanticHash(extHash);
+        }
+        // 3. If still no matches, return empty result
+        if (startNodes.length === 0) {
+            return {
+                nodes: [],
+                edges: [],
+                durationMs: performance.now() - startTime,
+                truncated: false,
+            };
+        }
+        // 4. Weighted BFS traversal from matched nodes
+        const visitedNodeIds = new Set();
+        const visitedEdgeIds = new Set();
+        const scoredNodes = new Map();
+        const allEdges = new Map();
+        const frontier = [];
+        // Initialize frontier with start nodes
+        for (const node of startNodes) {
+            visitedNodeIds.add(node.id);
+            frontier.push({
+                nodeId: node.id,
+                node,
+                depth: 0,
+                pathWeight: 1.0,
+                trace: [],
+            });
+        }
+        let elapsed = performance.now() - startTime;
+        let truncated = false;
+        while (frontier.length > 0 && elapsed < maxDuration) {
+            // Sort frontier: highest pathWeight first, then lowest depth
+            frontier.sort((a, b) => b.pathWeight - a.pathWeight || a.depth - b.depth);
+            const current = frontier.shift();
+            // Score and store
+            const score = this.computeNodeScore(current, intentHint);
+            if (score >= minRelevance) {
+                scoredNodes.set(current.node.id, {
+                    node: current.node,
+                    relevanceScore: score,
+                    trace: current.trace,
+                });
+            }
+            // Stop at max depth
+            if (current.depth >= maxDepth)
+                continue;
+            // Fetch outgoing edges for this node
+            const subgraph = await this.repo.getSubgraph(current.nodeId, 1);
+            const outgoingEdges = subgraph.edges.filter(e => e.sourceId === current.nodeId && !visitedEdgeIds.has(e.id));
+            for (const edge of outgoingEdges) {
+                visitedEdgeIds.add(edge.id);
+                allEdges.set(edge.id, edge);
+                // Apply abstraction level filter
+                const targetNode = subgraph.nodes.find(n => n.id === edge.targetId);
+                if (!targetNode)
+                    continue;
+                if (!this.isLevelCompatible(current.node.abstractionLevel, targetNode.abstractionLevel, edge.relation, intentHint)) {
+                    continue;
+                }
+                // Apply GENERALIZES pruning
+                const multiplier = RELATION_MULTIPLIERS[edge.relation] ?? 0.5;
+                if (edge.relation === "GENERALIZES" && current.depth > 1)
+                    continue;
+                if (!visitedNodeIds.has(edge.targetId)) {
+                    visitedNodeIds.add(edge.targetId);
+                    frontier.push({
+                        nodeId: edge.targetId,
+                        node: targetNode,
+                        depth: current.depth + 1,
+                        pathWeight: current.pathWeight * multiplier * Math.max(0.5, edge.weight / 1.0),
+                        trace: [...current.trace, edge.relation + ' → ' + targetNode.type + ':' + targetNode.abstractionLevel],
+                    });
+                }
+            }
+            elapsed = performance.now() - startTime;
+        }
+        if (frontier.length > 0)
+            truncated = true;
+        // 5. Sort by score descending
+        const sorted = [...scoredNodes.values()]
+            .sort((a, b) => b.relevanceScore - a.relevanceScore);
+        return {
+            nodes: sorted,
+            edges: [...allEdges.values()],
+            durationMs: performance.now() - startTime,
+            truncated,
+        };
+    }
+    // ── Private Helpers ────────────────────────────────────
+    /** Check if moving from sourceLevel to targetLevel is compatible. */
+    isLevelCompatible(sourceLevel, targetLevel, relation, intentHint) {
+        const absDiff = Math.abs(sourceLevel - targetLevel);
+        // Always allow same or adjacent levels
+        if (absDiff <= 1)
+            return true;
+        // Jumping from 0→2 or 1→3 (or reverse) needs REFINES connection
+        if (absDiff === 2 && relation === "REFINES")
+            return true;
+        // Intent-based filtering
+        if (intentHint) {
+            const bias = INTENT_BIAS[intentHint] ?? [0, 1, 2, 3];
+            // If target level is prioritized by intent, allow
+            if (bias.indexOf(targetLevel) <= bias.indexOf(sourceLevel) + 1)
+                return true;
+        }
+        // Skip large level jumps unless explicitly connected
+        return absDiff <= 2 && (relation === "CAUSES" || relation === "REFINES");
+    }
+    /** Compute a relevance score [0, 1] for a frontier entry. */
+    computeNodeScore(entry, intentHint) {
+        const depthPenalty = 1 - 0.15 * entry.depth;
+        const weightScore = Math.min(1, entry.pathWeight / 1.5);
+        const levelScore = intentHint
+            ? 1 - Math.abs(INTENT_BIAS[intentHint].indexOf(entry.node.abstractionLevel) - INTENT_BIAS[intentHint].indexOf(0)) * 0.2
+            : 1 - Math.abs(entry.node.abstractionLevel - 1) * 0.15;
+        // Base score
+        let score = Math.max(0, weightScore * depthPenalty * levelScore);
+        // Bonus for nodes with AST templates (more actionable)
+        if (entry.node.astTemplate)
+            score = Math.min(1, score * 1.2);
+        return Math.round(score * 100) / 100;
+    }
+}
+// ── Utility ───────────────────────────────────────────────
+function simpleHash(s) {
+    if (!s)
+        return "0";
+    let hash = 0;
+    for (let i = 0; i < s.length; i++) {
+        hash = ((hash << 5) - hash) + s.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(16);
+}
+//# sourceMappingURL=graph-traverser.js.map