0xray 2.0.0

package/dist/inference/semantic-patterns.js

@@ -0,0 +1,310 @@
+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.js

@@ -0,0 +1,308 @@
+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 "";
+}