sequant 1.15.2 → 1.15.4

package/dist/src/lib/test-tautology-detector.js

@@ -0,0 +1,488 @@
+/**
+ * Test Tautology Detector
+ *
+ * Detects tautological tests — tests that pass but don't call any production code.
+ * These tests provide zero regression protection as they only assert on local values.
+ *
+ * @example
+ * ```typescript
+ * import { detectTautologicalTests, formatTautologyResults } from './test-tautology-detector';
+ *
+ * const results = detectTautologicalTests([
+ *   { path: 'src/lib/foo.test.ts', content: fileContent },
+ * ]);
+ * console.log(formatTautologyResults(results));
+ * ```
+ */
+/**
+ * Test library imports to exclude from production function detection
+ */
+const TEST_LIBRARY_PATTERNS = [
+    /^vitest$/,
+    /^@vitest\//,
+    /^jest$/,
+    /^@jest\//,
+    /^@testing-library\//,
+    /^react-test-renderer/,
+    /^enzyme/,
+    /^sinon/,
+    /^chai/,
+    /^mocha/,
+    /^node:test/,
+    /^assert$/,
+];
+/**
+ * Mock/fixture path patterns to exclude
+ */
+const MOCK_FIXTURE_PATTERNS = [
+    /mock/i,
+    /fixture/i,
+    /stub/i,
+    /fake/i,
+    /__mocks__/,
+    /__fixtures__/,
+    /test-utils?/i,
+    /test-helper/i,
+];
+/**
+ * Check if an import path is from a source module (not a test library or mock)
+ */
+export function isSourceModule(modulePath) {
+    // Check if it's a test library
+    for (const pattern of TEST_LIBRARY_PATTERNS) {
+        if (pattern.test(modulePath)) {
+            return false;
+        }
+    }
+    // Check if it's a mock/fixture
+    for (const pattern of MOCK_FIXTURE_PATTERNS) {
+        if (pattern.test(modulePath)) {
+            return false;
+        }
+    }
+    // Check if it's a Node.js built-in
+    if (modulePath.startsWith("node:")) {
+        return false;
+    }
+    // Source modules typically start with ./ or ../ or are absolute imports
+    // For this detector, we consider relative imports as production code
+    if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
+        return true;
+    }
+    // Absolute imports from the project (non-node_modules) are also production code
+    // We can't reliably detect this without filesystem access, so we're conservative
+    // and only count relative imports as production code
+    return false;
+}
+/**
+ * Extract imports from a test file
+ *
+ * Handles:
+ * - Named imports: `import { foo, bar } from './module'`
+ * - Default imports: `import foo from './module'`
+ * - Namespace imports: `import * as foo from './module'` (extracts the namespace name)
+ */
+export function extractImports(content) {
+    const imports = [];
+    // Named imports: import { foo, bar, baz as qux } from './module'
+    const namedImportPattern = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = namedImportPattern.exec(content)) !== null) {
+        const names = match[1];
+        const modulePath = match[2];
+        if (!isSourceModule(modulePath)) {
+            continue;
+        }
+        // Parse individual imports, handling aliases (foo as bar)
+        const importedNames = names.split(",").map((n) => n.trim());
+        for (const name of importedNames) {
+            if (!name)
+                continue;
+            // Handle aliased imports: "originalName as aliasName"
+            const aliasMatch = name.match(/(\w+)\s+as\s+(\w+)/);
+            if (aliasMatch) {
+                // Use the alias (the name actually used in code)
+                imports.push({ name: aliasMatch[2], modulePath });
+            }
+            else {
+                // No alias, use the name directly
+                const cleanName = name.replace(/\s+/g, "");
+                if (cleanName) {
+                    imports.push({ name: cleanName, modulePath });
+                }
+            }
+        }
+    }
+    // Default imports: import foo from './module'
+    const defaultImportPattern = /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
+    while ((match = defaultImportPattern.exec(content)) !== null) {
+        const name = match[1];
+        const modulePath = match[2];
+        if (isSourceModule(modulePath)) {
+            imports.push({ name, modulePath });
+        }
+    }
+    // Namespace imports: import * as foo from './module'
+    const namespaceImportPattern = /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g;
+    while ((match = namespaceImportPattern.exec(content)) !== null) {
+        const name = match[1];
+        const modulePath = match[2];
+        if (isSourceModule(modulePath)) {
+            imports.push({ name, modulePath });
+        }
+    }
+    return imports;
+}
+/**
+ * Extract test blocks (it() and test()) from content
+ *
+ * Returns the description, line number, body content, and style of each test block.
+ */
+export function extractTestBlocks(content) {
+    const blocks = [];
+    // Find test block starts with their line numbers
+    // Pattern matches: it("...", ...) or test("...", ...)
+    // Including variations like it.skip, it.only, test.skip, test.only
+    const testBlockStartPattern = /\b(it|test)(?:\.skip|\.only)?\s*\(\s*(['"`])(.+?)\2/g;
+    let match;
+    while ((match = testBlockStartPattern.exec(content)) !== null) {
+        const style = match[1];
+        const description = match[3];
+        const startIndex = match.index;
+        // Skip matches inside string literals (e.g., test code embedded in template literals)
+        if (isInsideString(content, startIndex)) {
+            continue;
+        }
+        // Calculate line number
+        const contentBeforeMatch = content.substring(0, startIndex);
+        const lineNumber = contentBeforeMatch.split("\n").length;
+        // Find the matching closing brace for the test block
+        // This is a simplified approach that works for most cases
+        const afterMatch = content.substring(startIndex);
+        const body = extractBlockBody(afterMatch);
+        blocks.push({
+            description,
+            lineNumber,
+            body,
+            style,
+        });
+    }
+    return blocks;
+}
+/**
+ * Check if a position in the content is inside a non-code context:
+ * string literal (single, double, or template), comment (line or block),
+ * or a template expression's string context.
+ *
+ * Handles nested template literals: `` `outer ${`inner`} still outer` ``
+ * by tracking template expression depth via a stack.
+ */
+function isInsideString(content, position) {
+    let inString = false;
+    let stringChar = "";
+    let escaped = false;
+    // Stack tracks brace depth inside template expressions.
+    // When we encounter `${`, we push 0. Nested `{` increments top.
+    // `}` at depth 0 pops the stack and re-enters the template literal.
+    const templateExprStack = [];
+    for (let i = 0; i < position && i < content.length; i++) {
+        const char = content[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        // Inside a template literal — handle ${...} expressions
+        if (inString && stringChar === "`") {
+            if (char === "$" && i + 1 < content.length && content[i + 1] === "{") {
+                // Enter template expression — temporarily leave string context
+                templateExprStack.push(0);
+                inString = false;
+                i++; // skip the `{`
+                continue;
+            }
+            if (char === "`") {
+                inString = false;
+                continue;
+            }
+            continue;
+        }
+        // Inside a non-template string
+        if (inString) {
+            if (char === stringChar) {
+                inString = false;
+            }
+            continue;
+        }
+        // Not in any string — check if we're inside a template expression
+        if (templateExprStack.length > 0) {
+            if (char === "{") {
+                templateExprStack[templateExprStack.length - 1]++;
+            }
+            else if (char === "}") {
+                if (templateExprStack[templateExprStack.length - 1] === 0) {
+                    // Closing the template expression — re-enter the template literal
+                    templateExprStack.pop();
+                    inString = true;
+                    stringChar = "`";
+                }
+                else {
+                    templateExprStack[templateExprStack.length - 1]--;
+                }
+            }
+            else if (char === "`" || char === '"' || char === "'") {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === "/" &&
+                i + 1 < content.length &&
+                content[i + 1] === "/") {
+                // Line comment — if position falls within it, return true
+                const eol = content.indexOf("\n", i);
+                const commentEnd = eol === -1 ? content.length : eol;
+                if (position <= commentEnd)
+                    return true;
+                i = commentEnd;
+            }
+            else if (char === "/" &&
+                i + 1 < content.length &&
+                content[i + 1] === "*") {
+                // Block comment — if position falls within it, return true
+                const end = content.indexOf("*/", i + 2);
+                const commentEnd = end === -1 ? content.length : end + 1;
+                if (position <= commentEnd)
+                    return true;
+                i = commentEnd;
+            }
+            continue;
+        }
+        // Top-level code
+        if (char === "`" || char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+        }
+        else if (char === "/" &&
+            i + 1 < content.length &&
+            content[i + 1] === "/") {
+            // Line comment — if position falls within it, return true
+            const eol = content.indexOf("\n", i);
+            const commentEnd = eol === -1 ? content.length : eol;
+            if (position <= commentEnd)
+                return true;
+            i = commentEnd;
+        }
+        else if (char === "/" &&
+            i + 1 < content.length &&
+            content[i + 1] === "*") {
+            // Block comment — if position falls within it, return true
+            const end = content.indexOf("*/", i + 2);
+            const commentEnd = end === -1 ? content.length : end + 1;
+            if (position <= commentEnd)
+                return true;
+            i = commentEnd;
+        }
+    }
+    return inString || templateExprStack.length > 0;
+}
+/**
+ * Extract the body of a function block (content between { and matching })
+ */
+function extractBlockBody(content) {
+    // Find the first opening brace
+    const firstBrace = content.indexOf("{");
+    if (firstBrace === -1) {
+        return "";
+    }
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    let escaped = false;
+    for (let i = firstBrace; i < content.length; i++) {
+        const char = content[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (!inString && (char === '"' || char === "'" || char === "`")) {
+            inString = true;
+            stringChar = char;
+            continue;
+        }
+        if (inString && char === stringChar) {
+            inString = false;
+            continue;
+        }
+        if (!inString) {
+            if (char === "{") {
+                depth++;
+            }
+            else if (char === "}") {
+                depth--;
+                if (depth === 0) {
+                    return content.substring(firstBrace, i + 1);
+                }
+            }
+        }
+    }
+    // If we didn't find a matching brace, return everything after the first brace
+    return content.substring(firstBrace);
+}
+/**
+ * Escape special regex characters in a string for safe use in `new RegExp()`.
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Check if a test block contains calls to any of the imported production functions
+ */
+export function testBlockCallsProductionCode(body, importedFunctions) {
+    if (importedFunctions.length === 0) {
+        return false;
+    }
+    for (const fn of importedFunctions) {
+        // Check for any reference to the imported name bounded by non-identifier chars.
+        // Uses [\w$] to match JS identifier characters (letters, digits, _, $).
+        // This catches direct calls (fn()), method calls (ns.method()),
+        // callback references (arr.map(fn)), and assignments (const x = fn).
+        const escaped = escapeRegex(fn.name);
+        const referencePattern = new RegExp(`(?<![\\w$])${escaped}(?![\\w$])`);
+        if (referencePattern.test(body)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Analyze a single test file for tautological tests
+ */
+export function analyzeTestFile(content, filePath) {
+    try {
+        const importedFunctions = extractImports(content);
+        const testBlocks = extractTestBlocks(content);
+        const analyzedBlocks = testBlocks.map((block) => ({
+            description: block.description,
+            lineNumber: block.lineNumber,
+            style: block.style,
+            isTautological: !testBlockCallsProductionCode(block.body, importedFunctions),
+        }));
+        const tautologicalCount = analyzedBlocks.filter((b) => b.isTautological).length;
+        const totalTests = analyzedBlocks.length;
+        const tautologicalPercentage = totalTests > 0 ? (tautologicalCount / totalTests) * 100 : 0;
+        return {
+            filePath,
+            totalTests,
+            tautologicalCount,
+            tautologicalPercentage,
+            testBlocks: analyzedBlocks,
+            importedFunctions,
+            parseSuccess: true,
+        };
+    }
+    catch (error) {
+        return {
+            filePath,
+            totalTests: 0,
+            tautologicalCount: 0,
+            tautologicalPercentage: 0,
+            testBlocks: [],
+            importedFunctions: [],
+            parseSuccess: false,
+            parseError: error instanceof Error ? error.message : "Unknown parse error",
+        };
+    }
+}
+/**
+ * Detect tautological tests across multiple files
+ */
+export function detectTautologicalTests(files) {
+    const fileResults = files.map((file) => analyzeTestFile(file.content, file.path));
+    const totalFiles = fileResults.length;
+    const totalTests = fileResults.reduce((sum, r) => sum + r.totalTests, 0);
+    const totalTautological = fileResults.reduce((sum, r) => sum + r.tautologicalCount, 0);
+    const overallPercentage = totalTests > 0 ? (totalTautological / totalTests) * 100 : 0;
+    return {
+        fileResults,
+        summary: {
+            totalFiles,
+            totalTests,
+            totalTautological,
+            overallPercentage,
+            exceedsBlockingThreshold: overallPercentage > 50,
+        },
+    };
+}
+/**
+ * Format tautology results as markdown for QA output
+ */
+export function formatTautologyResults(results) {
+    const lines = [];
+    lines.push("### Test Quality Review");
+    lines.push("");
+    // Summary table
+    lines.push("| Category | Status | Notes |");
+    lines.push("|----------|--------|-------|");
+    if (results.summary.totalTests === 0) {
+        lines.push("| Tautology Check | ⏭️ SKIP | No test blocks found |");
+        return lines.join("\n");
+    }
+    const status = results.summary.exceedsBlockingThreshold
+        ? "❌ FAIL"
+        : results.summary.totalTautological > 0
+            ? "⚠️ WARN"
+            : "✅ OK";
+    const notes = results.summary.totalTautological > 0
+        ? `${results.summary.totalTautological} tautological test blocks found (${results.summary.overallPercentage.toFixed(1)}%)`
+        : "All tests call production code";
+    lines.push(`| Tautology Check | ${status} | ${notes} |`);
+    lines.push("");
+    // List tautological tests if any found
+    if (results.summary.totalTautological > 0) {
+        lines.push("**Tautological Tests Found:**");
+        lines.push("");
+        for (const fileResult of results.fileResults) {
+            const tautologicalBlocks = fileResult.testBlocks.filter((b) => b.isTautological);
+            for (const block of tautologicalBlocks) {
+                lines.push(`- \`${fileResult.filePath}:${block.lineNumber}\` - \`${block.style}("${block.description}")\` - No production function calls`);
+            }
+        }
+        lines.push("");
+    }
+    // Verdict impact
+    if (results.summary.exceedsBlockingThreshold) {
+        lines.push("**Verdict Impact:** >50% tautological tests — blocks `READY_FOR_MERGE`");
+        lines.push("");
+    }
+    // Parse errors if any
+    const parseErrors = results.fileResults.filter((r) => !r.parseSuccess);
+    if (parseErrors.length > 0) {
+        lines.push("**Parse Warnings:**");
+        for (const error of parseErrors) {
+            lines.push(`- \`${error.filePath}\`: ${error.parseError}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Determine verdict impact based on tautology results
+ */
+export function getTautologyVerdictImpact(results) {
+    if (results.summary.totalTests === 0) {
+        return "none";
+    }
+    if (results.summary.exceedsBlockingThreshold) {
+        return "blocking";
+    }
+    if (results.summary.totalTautological > 0) {
+        return "warning";
+    }
+    return "none";
+}

package/dist/src/lib/workflow/git-diff-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Git diff utilities for pipeline observability (AC-1, AC-3, AC-4)
+ *
+ * Provides efficient git diff statistics for phase logging.
+ * Uses single git commands where possible to avoid redundant operations.
+ */
+import type { FileDiffStat } from "./run-log-schema.js";
+/**
+ * Result from getGitDiffStats (AC-4)
+ */
+export interface GitDiffStatsResult {
+    /** List of modified file paths (AC-1) */
+    filesModified: string[];
+    /** Per-file diff statistics (AC-3) */
+    fileDiffStats: FileDiffStat[];
+    /** Total lines added across all files */
+    totalAdditions: number;
+    /** Total lines deleted across all files */
+    totalDeletions: number;
+}
+/**
+ * Get git commit SHA for a worktree (AC-2)
+ *
+ * @param worktreePath - Path to the git worktree
+ * @returns The current HEAD commit SHA, or undefined on error
+ */
+export declare function getCommitHash(worktreePath: string): string | undefined;
+/**
+ * Get git diff statistics for a worktree (AC-1, AC-3, AC-4)
+ *
+ * Efficiently captures both filesModified and fileDiffStats using
+ * minimal git commands. Uses main...HEAD comparison by default.
+ *
+ * @param worktreePath - Path to the git worktree
+ * @param baseBranch - Branch to compare against (default: "main")
+ * @returns GitDiffStatsResult with files, stats, and totals
+ */
+export declare function getGitDiffStats(worktreePath: string, baseBranch?: string): GitDiffStatsResult;
+export type { FileDiffStat };

package/dist/src/lib/workflow/git-diff-utils.js

@@ -0,0 +1,142 @@
+/**
+ * Git diff utilities for pipeline observability (AC-1, AC-3, AC-4)
+ *
+ * Provides efficient git diff statistics for phase logging.
+ * Uses single git commands where possible to avoid redundant operations.
+ */
+import { spawnSync } from "child_process";
+/**
+ * Parse git diff --numstat output into additions/deletions per file
+ *
+ * Format: <additions>\t<deletions>\t<filepath>
+ * Binary files show: -\t-\t<filepath>
+ */
+function parseNumstat(output) {
+    const result = new Map();
+    if (!output.trim()) {
+        return result;
+    }
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const [addStr, delStr, ...pathParts] = parts;
+        const filePath = pathParts.join("\t"); // Handle filenames with tabs
+        // Binary files show "-" for additions/deletions
+        const additions = addStr === "-" ? 0 : parseInt(addStr, 10);
+        const deletions = delStr === "-" ? 0 : parseInt(delStr, 10);
+        if (!isNaN(additions) && !isNaN(deletions)) {
+            result.set(filePath, { additions, deletions });
+        }
+    }
+    return result;
+}
+/**
+ * Parse git diff --name-status output into file statuses
+ *
+ * Format: <status>\t<filepath> (or <status>\t<oldpath>\t<newpath> for renames)
+ * Status codes: A=added, M=modified, D=deleted, R=renamed, C=copied, T=type-changed
+ */
+function parseNameStatus(output) {
+    const result = new Map();
+    if (!output.trim()) {
+        return result;
+    }
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        if (parts.length < 2)
+            continue;
+        const statusCode = parts[0];
+        // For renames (R100), use the new filename (last part)
+        const filePath = parts[parts.length - 1];
+        let status;
+        if (statusCode.startsWith("A")) {
+            status = "added";
+        }
+        else if (statusCode.startsWith("D")) {
+            status = "deleted";
+        }
+        else if (statusCode.startsWith("R")) {
+            status = "renamed";
+        }
+        else {
+            // M, C, T, or anything else -> modified
+            status = "modified";
+        }
+        result.set(filePath, status);
+    }
+    return result;
+}
+/**
+ * Get git commit SHA for a worktree (AC-2)
+ *
+ * @param worktreePath - Path to the git worktree
+ * @returns The current HEAD commit SHA, or undefined on error
+ */
+export function getCommitHash(worktreePath) {
+    const result = spawnSync("git", ["-C", worktreePath, "rev-parse", "HEAD"], {
+        stdio: "pipe",
+        encoding: "utf-8",
+    });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    return result.stdout.trim();
+}
+/**
+ * Get git diff statistics for a worktree (AC-1, AC-3, AC-4)
+ *
+ * Efficiently captures both filesModified and fileDiffStats using
+ * minimal git commands. Uses main...HEAD comparison by default.
+ *
+ * @param worktreePath - Path to the git worktree
+ * @param baseBranch - Branch to compare against (default: "main")
+ * @returns GitDiffStatsResult with files, stats, and totals
+ */
+export function getGitDiffStats(worktreePath, baseBranch = "main") {
+    const diffRef = `${baseBranch}...HEAD`;
+    // Get numstat for additions/deletions
+    const numstatResult = spawnSync("git", ["-C", worktreePath, "diff", "--numstat", diffRef], { stdio: "pipe", encoding: "utf-8" });
+    // Get name-status for file status (added/modified/deleted/renamed)
+    const nameStatusResult = spawnSync("git", ["-C", worktreePath, "diff", "--name-status", diffRef], { stdio: "pipe", encoding: "utf-8" });
+    // Handle git command failures gracefully
+    if (numstatResult.status !== 0 || nameStatusResult.status !== 0) {
+        return {
+            filesModified: [],
+            fileDiffStats: [],
+            totalAdditions: 0,
+            totalDeletions: 0,
+        };
+    }
+    const numstatMap = parseNumstat(numstatResult.stdout);
+    const statusMap = parseNameStatus(nameStatusResult.stdout);
+    // Combine into fileDiffStats array
+    const fileDiffStats = [];
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const [path, stats] of numstatMap) {
+        const status = statusMap.get(path) ?? "modified";
+        fileDiffStats.push({
+            path,
+            additions: stats.additions,
+            deletions: stats.deletions,
+            status,
+        });
+        totalAdditions += stats.additions;
+        totalDeletions += stats.deletions;
+    }
+    // filesModified is just the paths
+    const filesModified = fileDiffStats.map((f) => f.path);
+    return {
+        filesModified,
+        fileDiffStats,
+        totalAdditions,
+        totalDeletions,
+    };
+}