0xray 4.0.12 → 4.0.13

package/dist/inference/semantic-patterns.js

@@ -1,310 +0,0 @@
-import { execSync } from "child_process";
-export function analyzeStructuralPatterns(fromRef, toRef) {
-    const changes = getFileChanges(fromRef, toRef);
-    if (changes.length === 0)
-        return [];
-    const patterns = [];
-    const extractMethod = detectExtractMethod(changes, fromRef, toRef);
-    if (extractMethod)
-        patterns.push(extractMethod);
-    const registry = detectRegistryPattern(fromRef, toRef);
-    if (registry)
-        patterns.push(registry);
-    const facade = detectFacadePattern(changes, fromRef, toRef);
-    if (facade)
-        patterns.push(facade);
-    const convention = detectConventionOverConfig(changes, fromRef, toRef);
-    if (convention)
-        patterns.push(convention);
-    const deadCode = detectDeadCodeRemoval(changes);
-    if (deadCode)
-        patterns.push(deadCode);
-    const testExpansion = detectTestExpansion(changes);
-    if (testExpansion)
-        patterns.push(testExpansion);
-    const di = detectDependencyInjection(fromRef, toRef);
-    if (di)
-        patterns.push(di);
-    const stabilitySprint = detectStabilitySprint(changes);
-    if (stabilitySprint)
-        patterns.push(stabilitySprint);
-    return patterns.sort((a, b) => b.confidence - a.confidence);
-}
-function getFileChanges(fromRef, toRef) {
-    try {
-        const output = execSync(`git diff --numstat ${fromRef}..${toRef} --no-renames`, { encoding: "utf-8", stdio: "pipe", timeout: 5000 });
-        return output
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => {
-            const [ins, dels, filePath] = line.split("\t");
-            if (!filePath)
-                return null;
-            const status = getChangeStatus(filePath, fromRef, toRef);
-            const parts = filePath.split("/");
-            return {
-                path: filePath,
-                status,
-                insertions: parseInt(ins || "0", 10) || 0,
-                deletions: parseInt(dels || "0", 10) || 0,
-                dir: parts.length > 1 ? parts.slice(0, -1).join("/") : ".",
-                basename: parts[parts.length - 1],
-            };
-        })
-            .filter((c) => c !== null);
-    }
-    catch {
-        return [];
-    }
-}
-function getChangeStatus(filePath, fromRef, toRef) {
-    try {
-        const status = execSync(`git diff --name-status ${fromRef}..${toRef} -- ${filePath}`, { encoding: "utf-8", stdio: "pipe", timeout: 3000 }).trim();
-        const statusChar = status.charAt(0);
-        if (statusChar === "A" || statusChar === "M" || statusChar === "D" || statusChar === "R" || statusChar === "C") {
-            return statusChar;
-        }
-        return "M";
-    }
-    catch {
-        return "M";
-    }
-}
-function detectExtractMethod(changes, _fromRef, _toRef) {
-    const added = changes.filter((c) => c.status === "A" && c.path.endsWith(".ts"));
-    const modified = changes.filter((c) => c.status === "M");
-    if (added.length < 2)
-        return null;
-    const addedDirs = new Set(added.map((c) => c.dir));
-    const modifiedDirs = new Set(modified.map((c) => c.dir));
-    const sharedDirs = [...addedDirs].filter((d) => modifiedDirs.has(d));
-    if (sharedDirs.length === 0)
-        return null;
-    const evidence = [];
-    for (const dir of sharedDirs) {
-        const addedInDir = added.filter((c) => c.dir === dir);
-        const modInDir = modified.filter((c) => c.dir === dir);
-        evidence.push(`${addedInDir.length} new files + ${modInDir.length} modified in ${dir}/`);
-        for (const f of addedInDir.slice(0, 3)) {
-            evidence.push(`  + ${f.basename}`);
-        }
-        for (const f of modInDir.slice(0, 3)) {
-            evidence.push(`  ~ ${f.basename} (-${f.deletions} lines)`);
-        }
-    }
-    const confidence = Math.min(0.95, 0.6 + added.length * 0.05 + sharedDirs.length * 0.1);
-    return {
-        name: "Extract Method",
-        confidence,
-        evidence,
-        description: "Methods extracted from monolithic modules into dedicated files in the same directory. Classic decomposition pattern: one large file sheds responsibilities into focused modules.",
-    };
-}
-function detectRegistryPattern(fromRef, toRef) {
-    try {
-        const diff = execSync(`git diff ${fromRef}..${toRef} --no-renames`, {
-            encoding: "utf-8",
-            stdio: "pipe",
-            timeout: 8000,
-        });
-        const evidence = [];
-        let switchRemovals = 0;
-        let mapAdditions = 0;
-        const switchLines = diff.split("\n");
-        for (const line of switchLines) {
-            if (line.startsWith("-") &&
-                (line.includes("switch") || line.includes("case "))) {
-                switchRemovals++;
-            }
-            if (line.startsWith("+") && line.includes("new Map")) {
-                mapAdditions++;
-            }
-            if (line.startsWith("+") && line.includes(".set(")) {
-                mapAdditions++;
-            }
-        }
-        if (switchRemovals > 0 && mapAdditions > 0) {
-            evidence.push(`Removed ${switchRemovals} switch/case lines, added ${mapAdditions} Map operations`);
-        }
-        else if (mapAdditions >= 2) {
-            evidence.push(`${mapAdditions} Map operations added`);
-        }
-        else {
-            return null;
-        }
-        const factoryPattern = diff.includes("registerProcessor") || diff.includes("register(");
-        if (factoryPattern) {
-            evidence.push("Factory/registry registration pattern detected");
-        }
-        return {
-            name: "Registry Pattern",
-            confidence: switchRemovals > 0 ? 0.9 : 0.7,
-            evidence,
-            description: "Switch statement replaced with Map-based registry lookup. O(1) dispatch replaces O(n) case matching. New entries require only registration, not code changes to the dispatcher.",
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function detectFacadePattern(changes, fromRef, toRef) {
-    const modified = changes.filter((c) => c.status === "M" &&
-        c.deletions > c.insertions * 2 &&
-        c.deletions > 50);
-    if (modified.length === 0)
-        return null;
-    const added = changes.filter((c) => c.status === "A" && c.path.endsWith(".ts"));
-    if (added.length === 0)
-        return null;
-    try {
-        const diff = execSync(`git diff ${fromRef}..${toRef} -- ${modified.map((c) => c.path).join(" ")} --no-renames`, { encoding: "utf-8", stdio: "pipe", timeout: 5000 });
-        const removedFunctionLines = diff
-            .split("\n")
-            .filter((l) => l.startsWith("-") &&
-            (l.includes("async ") || l.includes("function ") || l.includes("private "))).length;
-        if (removedFunctionLines < 3)
-            return null;
-        const evidence = [];
-        for (const f of modified) {
-            evidence.push(`${f.path}: -${f.deletions}/+${f.insertions} lines, ${removedFunctionLines} function signatures removed`);
-        }
-        evidence.push(`${added.length} new files created to absorb extracted logic`);
-        return {
-            name: "Facade Pattern",
-            confidence: 0.85,
-            evidence,
-            description: "Monolithic file stripped down to a thin facade while logic moves to dedicated modules. The original becomes a coordinator, not an implementer.",
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function detectConventionOverConfig(changes, fromRef, toRef) {
-    const hasImplementations = changes.some((c) => c.status === "A" && c.path.includes("implementations/"));
-    if (!hasImplementations)
-        return null;
-    try {
-        const diff = execSync(`git diff ${fromRef}..${toRef} --no-renames`, {
-            encoding: "utf-8",
-            stdio: "pipe",
-            timeout: 8000,
-        });
-        const hasDiscovery = diff.includes("discover") || diff.includes("auto-register") || diff.includes("scan");
-        const hasReflection = diff.includes("reflect") || diff.includes("metadata");
-        const hasDynamicImport = diff.includes("import(") || diff.includes("require(");
-        if (!hasDiscovery && !hasDynamicImport)
-            return null;
-        const addedImpl = changes.filter((c) => c.status === "A" && c.path.includes("implementations/"));
-        const evidence = [
-            `${addedImpl.length} new implementations auto-discovered`,
-        ];
-        if (hasDiscovery)
-            evidence.push("Discovery/scan logic present");
-        if (hasDynamicImport)
-            evidence.push("Dynamic imports for runtime loading");
-        if (hasReflection)
-            evidence.push("Reflection/metadata introspection");
-        return {
-            name: "Convention over Configuration",
-            confidence: 0.88,
-            evidence,
-            description: "New modules are auto-discovered at runtime instead of manually registered. Drop a file in the right directory and the system finds it. Eliminates registration boilerplate and prevents orphaned modules.",
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function detectDeadCodeRemoval(changes) {
-    const deleted = changes.filter((c) => c.status === "D");
-    if (deleted.length < 2)
-        return null;
-    const evidence = [];
-    for (const f of deleted.slice(0, 5)) {
-        evidence.push(`- ${f.path}`);
-    }
-    if (deleted.length > 5) {
-        evidence.push(`... and ${deleted.length - 5} more`);
-    }
-    return {
-        name: "Dead Code Removal",
-        confidence: 0.9,
-        evidence,
-        description: `${deleted.length} files deleted — unused code eliminated. Reduces maintenance burden, removes misleading signals for new readers.`,
-    };
-}
-function detectTestExpansion(changes) {
-    const addedTests = changes.filter((c) => c.status === "A" && c.path.includes("__tests__"));
-    if (addedTests.length < 2)
-        return null;
-    const evidence = [];
-    for (const f of addedTests.slice(0, 5)) {
-        evidence.push(`+ ${f.path}`);
-    }
-    return {
-        name: "Test Coverage Expansion",
-        confidence: 0.95,
-        evidence,
-        description: `${addedTests.length} new test files added. Test-first or test-alongside development — covering new code as it ships.`,
-    };
-}
-function detectDependencyInjection(fromRef, toRef) {
-    try {
-        const diff = execSync(`git diff ${fromRef}..${toRef} --no-renames`, {
-            encoding: "utf-8",
-            stdio: "pipe",
-            timeout: 8000,
-        });
-        const evidence = [];
-        const hasStaticDeps = diff.includes("+  static readonly dependencies") ||
-            diff.includes("+  static dependencies");
-        const hasInject = diff.includes("inject") || diff.includes("resolve(");
-        const hasConstructorDI = diff.includes("constructor(") &&
-            (diff.includes("private ") || diff.includes("readonly "));
-        if (!hasStaticDeps && !hasInject)
-            return null;
-        if (hasStaticDeps)
-            evidence.push("Static dependency declarations added");
-        if (hasInject)
-            evidence.push("DI container / injection logic");
-        if (hasConstructorDI)
-            evidence.push("Constructor-based DI signatures");
-        return {
-            name: "Dependency Injection",
-            confidence: 0.82,
-            evidence,
-            description: "Explicit dependency declarations replacing hardcoded imports. Enables testing with mocks, runtime configuration, and auto-wiring.",
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function detectStabilitySprint(changes) {
-    const fixChanges = changes.filter((c) => c.path.toLowerCase().includes("fix") ||
-        c.path.toLowerCase().includes("patch"));
-    const totalModified = changes.filter((c) => c.status === "M" || c.status === "A").length;
-    const deleted = changes.filter((c) => c.status === "D");
-    if (deleted.length < 3 && fixChanges.length < 3)
-        return null;
-    const netDeletions = changes.reduce((s, c) => s + c.deletions - c.insertions, 0);
-    if (netDeletions < 100 && deleted.length < 3)
-        return null;
-    const evidence = [];
-    if (deleted.length >= 3) {
-        evidence.push(`${deleted.length} files deleted`);
-    }
-    if (netDeletions > 0) {
-        evidence.push(`Net ${netDeletions} lines removed`);
-    }
-    if (fixChanges.length >= 3) {
-        evidence.push(`${fixChanges.length} fix-related changes`);
-    }
-    return {
-        name: "Stability Sprint",
-        confidence: 0.75,
-        evidence,
-        description: "Focus on removal and fixing over feature addition. Technical debt being paid down — a sign of mature development practice.",
-    };
-}

package/dist/inference/session-capture.d.ts

@@ -1,32 +0,0 @@
-import { StructuralPattern } from "./semantic-patterns.js";
-export interface SessionInference {
-    sessionId: string;
-    timestamp: string;
-    span: {
-        from: string;
-        to: string;
-    };
-    problems: string[];
-    approaches: string[];
-    wrongTurns: string[];
-    solutions: string[];
-    reasoningChain: ReasoningLink[];
-    patterns: StructuralPattern[];
-    metrics: SessionMetrics;
-}
-export interface ReasoningLink {
-    from: string;
-    to: string;
-    reasoning: string;
-}
-export interface SessionMetrics {
-    commits: number;
-    filesChanged: number;
-    insertions: number;
-    deletions: number;
-    filesAdded: number;
-    filesDeleted: number;
-    uniqueDirs: number;
-}
-export declare function captureSessionInference(fromRef: string, toRef: string): SessionInference | null;
-export declare function saveSessionInference(inference: SessionInference, outputDir?: string): string;

package/dist/inference/session-capture.js

@@ -1,308 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { execSync } from "child_process";
-import { analyzeStructuralPatterns } from "./semantic-patterns.js";
-export function captureSessionInference(fromRef, toRef) {
-    const commits = getCommitData(fromRef, toRef);
-    if (commits.length === 0)
-        return null;
-    const metrics = computeMetrics(fromRef, toRef);
-    const patterns = analyzeStructuralPatterns(fromRef, toRef);
-    const problems = extractProblems(commits, patterns);
-    const approaches = extractApproaches(commits, patterns);
-    const wrongTurns = extractWrongTurns(commits, fromRef, toRef);
-    const solutions = extractSolutions(commits, patterns);
-    const reasoningChain = buildReasoningChain(problems, approaches, wrongTurns, solutions);
-    return {
-        sessionId: `session-${new Date().toISOString().slice(0, 10)}`,
-        timestamp: new Date().toISOString(),
-        span: { from: fromRef, to: toRef },
-        problems,
-        approaches,
-        wrongTurns,
-        solutions,
-        reasoningChain,
-        patterns,
-        metrics,
-    };
-}
-export function saveSessionInference(inference, outputDir) {
-    const dir = outputDir || path.join(process.cwd(), "docs", "inference");
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    const filename = `session-${inference.sessionId.replace(/^session-/, "")}-${Date.now()}.json`;
-    const filePath = path.join(dir, filename);
-    fs.writeFileSync(filePath, JSON.stringify(inference, null, 2));
-    const latestPath = path.join(dir, "latest-session.json");
-    fs.writeFileSync(latestPath, JSON.stringify(inference, null, 2));
-    return filePath;
-}
-function getCommitData(fromRef, toRef) {
-    try {
-        const log = execSync(`git log ${fromRef}..${toRef} --format="%H||%s" --shortstat --no-merges`, { encoding: "utf-8", stdio: "pipe", timeout: 5000 });
-        if (!log.trim())
-            return [];
-        return log
-            .split(/\n{2,}/)
-            .filter((b) => b.trim().length > 0 && b.includes("||"))
-            .map((block) => {
-            const lines = block.trim().split("\n");
-            const headerLine = lines.find((l) => l.includes("||")) || "";
-            const [hash, message] = headerLine.split("||");
-            const statsLine = lines.find((l) => l.includes("file") &&
-                (l.includes("insertion") || l.includes("deletion"))) || "";
-            return {
-                hash: (hash || "").trim().slice(0, 7),
-                message: (message || "").trim(),
-                insertions: parseInt(statsLine.match(/(\d+) insertion/)?.[1] || "0", 10),
-                deletions: parseInt(statsLine.match(/(\d+) deletion/)?.[1] || "0", 10),
-                filesChanged: parseInt(statsLine.match(/(\d+) files? changed/)?.[1] || "0", 10),
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-function computeMetrics(fromRef, toRef) {
-    try {
-        const stat = execSync(`git diff --stat ${fromRef}..${toRef} --no-renames`, {
-            encoding: "utf-8",
-            stdio: "pipe",
-            timeout: 30000,
-            maxBuffer: 50 * 1024 * 1024,
-        });
-        const finalLine = stat.trim().split("\n").pop() || "";
-        const filesChanged = parseInt(finalLine.match(/(\d+) files? changed/)?.[1] || "0", 10);
-        const insertions = parseInt(finalLine.match(/(\d+) insertion/)?.[1] || "0", 10);
-        const deletions = parseInt(finalLine.match(/(\d+) deletion/)?.[1] || "0", 10);
-        const nameStatus = execSync(`git diff --name-status ${fromRef}..${toRef} --no-renames`, { encoding: "utf-8", stdio: "pipe", timeout: 30000, maxBuffer: 50 * 1024 * 1024 });
-        const lines = nameStatus.split("\n").filter(Boolean);
-        const filesAdded = lines.filter((l) => l.startsWith("A")).length;
-        const filesDeleted = lines.filter((l) => l.startsWith("D")).length;
-        const uniqueDirs = new Set(lines.map((l) => {
-            const parts = l.split("\t")[1].split("/");
-            return parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
-        })).size;
-        const commitCount = getCommitData(fromRef, toRef).length;
-        return {
-            commits: commitCount,
-            filesChanged,
-            insertions,
-            deletions,
-            filesAdded,
-            filesDeleted,
-            uniqueDirs,
-        };
-    }
-    catch {
-        return {
-            commits: 0,
-            filesChanged: 0,
-            insertions: 0,
-            deletions: 0,
-            filesAdded: 0,
-            filesDeleted: 0,
-            uniqueDirs: 0,
-        };
-    }
-}
-function extractProblems(commits, patterns) {
-    const problems = [];
-    for (const c of commits) {
-        const msg = c.message;
-        const msgLower = msg.toLowerCase();
-        const isFixCommit = /^[a-f0-9]+:? ?fix[\s:(/]/i.test(msg) || msgLower.startsWith("fix") || msgLower.includes("bug fix") || msgLower.includes("bugfix");
-        if (isFixCommit) {
-            problems.push(`Bug: ${msg} (${c.hash})`);
-        }
-        if (msgLower.includes("remove") && (msgLower.includes("circular") || msgLower.includes("dead code"))) {
-            problems.push(`Code health: ${msg} (${c.hash})`);
-        }
-        if (msgLower.includes("stub") || msgLower.includes("placeholder")) {
-            problems.push(`Incomplete implementation: ${msg} (${c.hash})`);
-        }
-    }
-    for (const p of patterns) {
-        if (p.name === "Dead Code Removal") {
-            problems.push(`Accumulated dead code: ${p.evidence[0]}`);
-        }
-        if (p.name === "Stability Sprint") {
-            problems.push(`Technical debt requiring stability focus`);
-        }
-    }
-    if (problems.length === 0 && commits.length > 3) {
-        problems.push(`General development session: ${commits.length} commits`);
-    }
-    return [...new Set(problems)];
-}
-function extractApproaches(commits, patterns) {
-    const approaches = [];
-    for (const p of patterns) {
-        switch (p.name) {
-            case "Extract Method":
-                approaches.push(`Extract methods into dedicated files to reduce monolith size`);
-                break;
-            case "Registry Pattern":
-                approaches.push(`Replace switch statements with Map-based registry for O(1) dispatch`);
-                break;
-            case "Facade Pattern":
-                approaches.push(`Thin facade + extracted modules: coordinator delegates, doesn't implement`);
-                break;
-            case "Convention over Configuration":
-                approaches.push(`Auto-discover implementations at runtime to eliminate manual registration`);
-                break;
-            case "Dependency Injection":
-                approaches.push(`Declare dependencies explicitly for testability and auto-wiring`);
-                break;
-            case "Dead Code Removal":
-                approaches.push(`Delete unused code to reduce maintenance burden`);
-                break;
-            case "Test Coverage Expansion":
-                approaches.push(`Add tests alongside new implementations`);
-                break;
-        }
-    }
-    for (const c of commits) {
-        const msg = c.message.toLowerCase();
-        if (msg.includes("sync") && msg.includes("version")) {
-            approaches.push(`Automate version synchronization across config files`);
-        }
-        if (msg.includes("append") && (msg.includes("doc") || msg.includes("agent"))) {
-            approaches.push(`Append-only doc updates to prevent data loss`);
-        }
-        if (msg.includes("guard")) {
-            approaches.push(`Structural guard to enforce invariants`);
-        }
-    }
-    return [...new Set(approaches)];
-}
-function extractWrongTurns(commits, fromRef, toRef) {
-    const wrongTurns = [];
-    try {
-        const log = execSync(`git log ${fromRef}..${toRef} --format="%s" --no-merges`, { encoding: "utf-8", stdio: "pipe", timeout: 5000 });
-        const messages = log.split("\n").filter(Boolean).map((m) => m.toLowerCase());
-        if (messages.some((m) => m.includes("revert"))) {
-            wrongTurns.push("Approach was reverted — initial direction was wrong");
-        }
-        const fixAfterFeature = findFixAfterFeature(messages);
-        if (fixAfterFeature) {
-            wrongTurns.push(fixAfterFeature);
-        }
-    }
-    catch {
-        // ignore
-    }
-    for (const c of commits) {
-        const msg = c.message.toLowerCase();
-        if (msg.includes("wrong") || msg.includes("incorrect") || msg.includes("oops")) {
-            wrongTurns.push(`Self-corrected: ${c.message} (${c.hash})`);
-        }
-    }
-    const allMessages = commits.map((c) => c.message.toLowerCase());
-    const hasPathFix = allMessages.filter((m) => m.includes("path") && (m.includes("fix") || m.includes("bogus"))).length;
-    if (hasPathFix > 0) {
-        wrongTurns.push("Path handling bug: absolute vs relative path confusion");
-    }
-    const hasFlakyFix = allMessages.filter((m) => m.includes("timeout") || m.includes("flaky")).length;
-    if (hasFlakyFix > 0) {
-        wrongTurns.push(`Timing issue: test assumptions violated in parallel execution`);
-    }
-    return [...new Set(wrongTurns)];
-}
-function findFixAfterFeature(messages) {
-    let lastFeatureIdx = -1;
-    let firstFixAfter = -1;
-    for (let i = 0; i < messages.length; i++) {
-        if (messages[i].includes("feat") ||
-            messages[i].includes("add") ||
-            messages[i].includes("implement")) {
-            lastFeatureIdx = i;
-        }
-        if (lastFeatureIdx >= 0 &&
-            messages[i].includes("fix") &&
-            firstFixAfter < 0) {
-            firstFixAfter = i;
-        }
-    }
-    if (lastFeatureIdx >= 0 && firstFixAfter > lastFeatureIdx) {
-        return `Feature commit followed by fix — incomplete initial implementation`;
-    }
-    return null;
-}
-function extractSolutions(commits, patterns) {
-    const solutions = [];
-    for (const p of patterns) {
-        solutions.push(`Applied ${p.name} pattern (confidence: ${Math.round(p.confidence * 100)}%)`);
-    }
-    for (const c of commits) {
-        const msg = c.message.toLowerCase();
-        if (msg.includes("create") || msg.includes("add script")) {
-            solutions.push(`New tooling: ${c.message} (${c.hash})`);
-        }
-        if (msg.includes("wire") || msg.includes("integrate")) {
-            solutions.push(`Integration: ${c.message} (${c.hash})`);
-        }
-        if (msg.includes("consolidat")) {
-            solutions.push(`Consolidation: ${c.message} (${c.hash})`);
-        }
-    }
-    if (solutions.length === 0 && commits.length > 0) {
-        solutions.push(`${commits.length} commits shipped successfully`);
-    }
-    return [...new Set(solutions)];
-}
-function buildReasoningChain(problems, approaches, wrongTurns, solutions) {
-    const chain = [];
-    for (const approach of approaches) {
-        const matchingSolution = solutions.find((s) => approaches.indexOf(approach) === solutions.indexOf(s) ||
-            s.toLowerCase().includes(approachKeyword(approach)));
-        if (matchingSolution) {
-            chain.push({
-                from: "approach",
-                to: "solution",
-                reasoning: `${approach} → ${matchingSolution}`,
-            });
-        }
-        else {
-            chain.push({
-                from: "problem",
-                to: "approach",
-                reasoning: approach,
-            });
-        }
-    }
-    for (const wt of wrongTurns) {
-        chain.push({
-            from: "approach",
-            to: "wrong_turn",
-            reasoning: wt,
-        });
-    }
-    return chain;
-}
-function approachKeyword(approach) {
-    const lower = approach.toLowerCase();
-    if (lower.includes("extract"))
-        return "extract";
-    if (lower.includes("registry") || lower.includes("map"))
-        return "registry";
-    if (lower.includes("facade") || lower.includes("thin"))
-        return "facade";
-    if (lower.includes("convention") || lower.includes("discover"))
-        return "convention";
-    if (lower.includes("dependen") || lower.includes("inject"))
-        return "dependenc";
-    if (lower.includes("dead code") || lower.includes("delete"))
-        return "dead code";
-    if (lower.includes("test"))
-        return "test";
-    if (lower.includes("version") || lower.includes("sync"))
-        return "version";
-    if (lower.includes("append"))
-        return "append";
-    if (lower.includes("guard"))
-        return "guard";
-    return "";
-}