sequant 1.20.3 → 2.0.1

package/dist/src/lib/solve-comment-parser.d.ts

@@ -1,110 +1,17 @@
 /**
- * Solve Comment Parser
+ * Solve Comment Parser — Backward Compatibility Re-exports
  *
- * Detects and parses /solve command output from GitHub issue comments.
- * When a solve comment exists, its phase recommendations take precedence
- * over content analysis (but not over labels).
+ * @deprecated This module is deprecated. Use `assess-comment-parser` instead.
+ * All exports are re-exported from the unified assess-comment-parser module.
  *
- * @example
+ * Migration:
  * ```typescript
+ * // Before (deprecated):
  * import { findSolveComment, parseSolveWorkflow } from './solve-comment-parser';
  *
- * const comments = [
- *   { body: "Some regular comment" },
- *   { body: "## Solve Workflow for Issues: 123\n..." },
- * ];
- *
- * const solveComment = findSolveComment(comments);
- * if (solveComment) {
- *   const phases = parseSolveWorkflow(solveComment.body);
- *   // phases: { phases: ['spec', 'exec', 'test', 'qa'], qualityLoop: false }
- * }
+ * // After:
+ * import { findAssessComment, parseAssessWorkflow } from './assess-comment-parser';
  * ```
  */
-import type { Phase } from "./workflow/types.js";
-import type { PhaseSignal } from "./phase-signal.js";
-/**
- * Result of parsing a solve comment
- */
-export interface SolveWorkflowResult {
-    /** Phases recommended by solve */
-    phases: Phase[];
-    /** Whether quality loop is recommended */
-    qualityLoop: boolean;
-    /** The issue numbers mentioned in the solve comment */
-    issueNumbers: number[];
-    /** Raw workflow string (e.g., "spec → exec → test → qa") */
-    workflowString?: string;
-}
-/**
- * Comment structure (simplified from GitHub API)
- */
-export interface IssueComment {
-    body: string;
-    author?: {
-        login: string;
-    };
-    createdAt?: string;
-}
-/**
- * Check if a comment is a solve command output
- *
- * @param body - The comment body
- * @returns True if this appears to be a solve comment
- */
-export declare function isSolveComment(body: string): boolean;
-/**
- * Find the most recent solve comment from a list of comments
- *
- * @param comments - Array of issue comments
- * @returns The solve comment if found, null otherwise
- */
-export declare function findSolveComment(comments: IssueComment[]): IssueComment | null;
-/**
- * Structured data extracted from HTML comment markers in solve comments
- */
-export interface SolveMarkers {
-    /** Recommended phases (from <!-- solve:phases=... -->) */
-    phases?: string[];
-    /** Whether to skip spec (from <!-- solve:skip-spec=... -->) */
-    skipSpec?: boolean;
-    /** Whether browser testing is needed (from <!-- solve:browser-test=... -->) */
-    browserTest?: boolean;
-    /** Whether quality loop is recommended (from <!-- solve:quality-loop=... -->) */
-    qualityLoop?: boolean;
-}
-/**
- * Parse HTML comment markers from a solve comment body
- *
- * Extracts structured data from markers like:
- * - `<!-- solve:phases=exec,qa -->`
- * - `<!-- solve:skip-spec=true -->`
- * - `<!-- solve:browser-test=false -->`
- * - `<!-- solve:quality-loop=true -->`
- *
- * @param body - The comment body
- * @returns Parsed markers
- */
-export declare function parseSolveMarkers(body: string): SolveMarkers;
-/**
- * Parse a solve comment to extract workflow information
- *
- * @param body - The solve comment body
- * @returns Parsed workflow result
- */
-export declare function parseSolveWorkflow(body: string): SolveWorkflowResult;
-/**
- * Convert solve workflow result to phase signals
- *
- * @param workflow - The parsed solve workflow
- * @returns Array of phase signals with 'solve' source
- */
-export declare function solveWorkflowToSignals(workflow: SolveWorkflowResult): PhaseSignal[];
-/**
- * Check if solve comment covers the current issue
- *
- * @param workflow - The parsed solve workflow
- * @param issueNumber - The current issue number
- * @returns True if the solve comment includes this issue
- */
-export declare function solveCoversIssue(workflow: SolveWorkflowResult, issueNumber: number): boolean;
+export { isAssessComment, findAssessComment, parseAssessMarkers, parseAssessWorkflow, assessWorkflowToSignals, assessCoversIssue, isSolveComment, findSolveComment, parseSolveMarkers, parseSolveWorkflow, solveWorkflowToSignals, solveCoversIssue, } from "./assess-comment-parser.js";
+export type { AssessWorkflowResult, AssessMarkers, AssessAction, SolveWorkflowResult, SolveMarkers, IssueComment, } from "./assess-comment-parser.js";

package/dist/src/lib/solve-comment-parser.js

@@ -1,256 +1,21 @@
 /**
- * Solve Comment Parser
+ * Solve Comment Parser — Backward Compatibility Re-exports
  *
- * Detects and parses /solve command output from GitHub issue comments.
- * When a solve comment exists, its phase recommendations take precedence
- * over content analysis (but not over labels).
+ * @deprecated This module is deprecated. Use `assess-comment-parser` instead.
+ * All exports are re-exported from the unified assess-comment-parser module.
  *
- * @example
+ * Migration:
  * ```typescript
+ * // Before (deprecated):
  * import { findSolveComment, parseSolveWorkflow } from './solve-comment-parser';
  *
- * const comments = [
- *   { body: "Some regular comment" },
- *   { body: "## Solve Workflow for Issues: 123\n..." },
- * ];
- *
- * const solveComment = findSolveComment(comments);
- * if (solveComment) {
- *   const phases = parseSolveWorkflow(solveComment.body);
- *   // phases: { phases: ['spec', 'exec', 'test', 'qa'], qualityLoop: false }
- * }
+ * // After:
+ * import { findAssessComment, parseAssessWorkflow } from './assess-comment-parser';
  * ```
  */
-/**
- * Markers that indicate a solve comment
- */
-const SOLVE_MARKERS = [
-    "## Solve Analysis",
-    "## Solve Workflow for Issues:",
-    "## Solve Workflow for Issue:",
-    "### Recommended Workflow",
-    "*📝 Generated by `/solve",
-];
-/**
- * Pattern to extract phases from solve workflow
- * Matches: `/spec`, `/exec`, `/test`, `/qa`, etc.
- * Also matches without slash: `spec`, `exec`, `test`, `qa` (for arrow notation)
- */
-const PHASE_PATTERN = /\/?(?<!\w)(spec|exec|test|qa|security-review|testgen|loop)(?!\w)/g;
-/**
- * Pattern to detect quality loop recommendation
- */
-const QUALITY_LOOP_PATTERNS = [
-    /quality\s*loop.*auto-enable/i,
-    /--quality-loop/i,
-    /quality\s*loop.*recommended/i,
-    /enable.*quality\s*loop/i,
-];
-/**
- * Pattern to extract structured data from HTML comment markers
- * Matches: <!-- solve:phases=exec,qa -->
- */
-const SOLVE_HTML_MARKER_PATTERN = /<!--\s*solve:(\w[\w-]*)=([\w,.-]+)\s*-->/g;
-/**
- * Pattern to extract issue numbers from solve header
- * Matches: "## Solve Workflow for Issues: 123, 456"
- */
-const ISSUE_NUMBER_PATTERN = /#?(\d+)/g;
-/**
- * Check if a comment is a solve command output
- *
- * @param body - The comment body
- * @returns True if this appears to be a solve comment
- */
-export function isSolveComment(body) {
-    return SOLVE_MARKERS.some((marker) => body.includes(marker));
-}
-/**
- * Find the most recent solve comment from a list of comments
- *
- * @param comments - Array of issue comments
- * @returns The solve comment if found, null otherwise
- */
-export function findSolveComment(comments) {
-    // Search from most recent to oldest (assuming comments are in chronological order)
-    for (let i = comments.length - 1; i >= 0; i--) {
-        if (isSolveComment(comments[i].body)) {
-            return comments[i];
-        }
-    }
-    return null;
-}
-/**
- * Parse phases from a solve workflow string
- *
- * @param workflowString - String like "spec → exec → test → qa"
- * @returns Array of phases
- */
-function parseWorkflowString(workflowString) {
-    const phases = [];
-    const matches = workflowString.matchAll(PHASE_PATTERN);
-    for (const match of matches) {
-        const phase = match[1];
-        if (!phases.includes(phase)) {
-            phases.push(phase);
-        }
-    }
-    return phases;
-}
-/**
- * Parse HTML comment markers from a solve comment body
- *
- * Extracts structured data from markers like:
- * - `<!-- solve:phases=exec,qa -->`
- * - `<!-- solve:skip-spec=true -->`
- * - `<!-- solve:browser-test=false -->`
- * - `<!-- solve:quality-loop=true -->`
- *
- * @param body - The comment body
- * @returns Parsed markers
- */
-export function parseSolveMarkers(body) {
-    const markers = {};
-    const matches = body.matchAll(SOLVE_HTML_MARKER_PATTERN);
-    for (const match of matches) {
-        const key = match[1];
-        const value = match[2];
-        switch (key) {
-            case "phases":
-                markers.phases = value.split(",").filter(Boolean);
-                break;
-            case "skip-spec":
-                markers.skipSpec = value === "true";
-                break;
-            case "browser-test":
-                markers.browserTest = value === "true";
-                break;
-            case "quality-loop":
-                markers.qualityLoop = value === "true";
-                break;
-        }
-    }
-    return markers;
-}
-/**
- * Parse a solve comment to extract workflow information
- *
- * @param body - The solve comment body
- * @returns Parsed workflow result
- */
-export function parseSolveWorkflow(body) {
-    const result = {
-        phases: [],
-        qualityLoop: false,
-        issueNumbers: [],
-    };
-    // Extract issue numbers from header (both old and new formats)
-    const headerMatch = body.match(/## Solve (?:Workflow for Issues?|Analysis)(?::\s*|\s+for\s+)([^\n]+)/i);
-    if (headerMatch) {
-        const numberMatches = headerMatch[1].matchAll(ISSUE_NUMBER_PATTERN);
-        for (const match of numberMatches) {
-            const num = parseInt(match[1], 10);
-            if (!isNaN(num) && !result.issueNumbers.includes(num)) {
-                result.issueNumbers.push(num);
-            }
-        }
-    }
-    // Try HTML comment markers first (most reliable, machine-readable)
-    const markers = parseSolveMarkers(body);
-    if (markers.phases && markers.phases.length > 0) {
-        result.phases = markers.phases;
-        result.workflowString = markers.phases.join(" → ");
-    }
-    if (markers.qualityLoop !== undefined) {
-        result.qualityLoop = markers.qualityLoop;
-    }
-    // If we got phases from markers, we're done
-    if (result.phases.length > 0) {
-        return result;
-    }
-    // Find workflow lines (e.g., "/spec 152" or "spec → exec → qa")
-    const lines = body.split("\n");
-    // First pass: look for arrow notation (most reliable)
-    for (const line of lines) {
-        if (line.includes("→") || line.includes("->")) {
-            const phases = parseWorkflowString(line);
-            if (phases.length > 0) {
-                result.phases = phases;
-                result.workflowString = line.trim();
-                break;
-            }
-        }
-    }
-    // Second pass: if no arrow notation found, collect phases from multiple lines
-    if (result.phases.length === 0) {
-        const collectedPhases = [];
-        for (const line of lines) {
-            // Look for slash command patterns on individual lines
-            if (line.includes("/spec") ||
-                line.includes("/exec") ||
-                line.includes("/test") ||
-                line.includes("/qa")) {
-                const linePhases = parseWorkflowString(line);
-                for (const phase of linePhases) {
-                    if (!collectedPhases.includes(phase)) {
-                        collectedPhases.push(phase);
-                    }
-                }
-            }
-        }
-        if (collectedPhases.length > 0) {
-            result.phases = collectedPhases;
-            result.workflowString = collectedPhases.map((p) => `/${p}`).join(" → ");
-        }
-    }
-    // If no phases found from lines, try full body
-    if (result.phases.length === 0) {
-        result.phases = parseWorkflowString(body);
-    }
-    // Check for quality loop recommendation (if not already set by markers)
-    if (!result.qualityLoop) {
-        for (const pattern of QUALITY_LOOP_PATTERNS) {
-            if (pattern.test(body)) {
-                result.qualityLoop = true;
-                break;
-            }
-        }
-    }
-    return result;
-}
-/**
- * Convert solve workflow result to phase signals
- *
- * @param workflow - The parsed solve workflow
- * @returns Array of phase signals with 'solve' source
- */
-export function solveWorkflowToSignals(workflow) {
-    const signals = [];
-    for (const phase of workflow.phases) {
-        signals.push({
-            phase,
-            source: "solve",
-            confidence: "high",
-            reason: `Recommended by /solve command: ${workflow.workflowString || phase}`,
-        });
-    }
-    if (workflow.qualityLoop) {
-        signals.push({
-            phase: "quality-loop",
-            source: "solve",
-            confidence: "high",
-            reason: "Quality loop recommended by /solve command",
-        });
-    }
-    return signals;
-}
-/**
- * Check if solve comment covers the current issue
- *
- * @param workflow - The parsed solve workflow
- * @param issueNumber - The current issue number
- * @returns True if the solve comment includes this issue
- */
-export function solveCoversIssue(workflow, issueNumber) {
-    return workflow.issueNumbers.includes(issueNumber);
-}
+// Re-export everything from the unified assess-comment-parser
+export { 
+// New names (preferred)
+isAssessComment, findAssessComment, parseAssessMarkers, parseAssessWorkflow, assessWorkflowToSignals, assessCoversIssue, 
+// Legacy names (deprecated but still functional)
+isSolveComment, findSolveComment, parseSolveMarkers, parseSolveWorkflow, solveWorkflowToSignals, solveCoversIssue, } from "./assess-comment-parser.js";

package/dist/src/lib/stacks.d.ts

@@ -37,6 +37,9 @@ export interface PackageManagerConfig {
     exec: string;
     install: string;
     installSilent: string;
+    addPkg: string;
+    removePkg: string;
+    updatePkg: string;
 }
 /**
  * Package manager configurations
@@ -50,6 +53,11 @@ export declare const PM_CONFIG: Record<PackageManager, PackageManagerConfig>;
  * Falls back to pip if no lockfile found but pyproject.toml/requirements.txt exists
  */
 export declare function detectPackageManager(): Promise<PackageManager | null>;
+/**
+ * Synchronous version of detectPackageManager for use in startup code.
+ * Only checks JS lockfiles (not Python) since sequant is a Node.js tool.
+ */
+export declare function detectPackageManagerSync(): PackageManager;
 /**
  * Get package manager command configuration
  */

package/dist/src/lib/stacks.js

@@ -1,6 +1,7 @@
 /**
  * Stack detection and configuration
  */
+import { existsSync } from "fs";
 import { readdir } from "fs/promises";
 import { fileExists, readFile } from "./fs.js";
 /**
@@ -29,24 +30,36 @@ export const PM_CONFIG = {
         exec: "npx",
         install: "npm install",
         installSilent: "npm install --silent",
+        addPkg: "npm install",
+        removePkg: "npm uninstall",
+        updatePkg: "npm update",
     },
     bun: {
         run: "bun run",
         exec: "bunx",
         install: "bun install",
         installSilent: "bun install --silent",
+        addPkg: "bun add",
+        removePkg: "bun remove",
+        updatePkg: "bun update",
     },
     yarn: {
         run: "yarn",
         exec: "yarn dlx",
         install: "yarn install",
         installSilent: "yarn install --silent",
+        addPkg: "yarn add",
+        removePkg: "yarn remove",
+        updatePkg: "yarn upgrade",
     },
     pnpm: {
         run: "pnpm run",
         exec: "pnpm dlx",
         install: "pnpm install",
         installSilent: "pnpm install --silent",
+        addPkg: "pnpm add",
+        removePkg: "pnpm remove",
+        updatePkg: "pnpm update",
     },
     // Python package managers
     pip: {
@@ -54,18 +67,27 @@ export const PM_CONFIG = {
         exec: "python -m",
         install: "pip install",
         installSilent: "pip install -q",
+        addPkg: "pip install",
+        removePkg: "pip uninstall",
+        updatePkg: "pip install --upgrade",
     },
     poetry: {
         run: "poetry run",
         exec: "poetry run",
         install: "poetry install",
         installSilent: "poetry install -q",
+        addPkg: "poetry add",
+        removePkg: "poetry remove",
+        updatePkg: "poetry update",
     },
     uv: {
         run: "uv run",
         exec: "uvx",
         install: "uv pip install",
         installSilent: "uv pip install -q",
+        addPkg: "uv pip install",
+        removePkg: "uv pip uninstall",
+        updatePkg: "uv pip install --upgrade",
     },
 };
 /**
@@ -118,6 +140,18 @@ export async function detectPackageManager() {
     // Not a recognized project type
     return null;
 }
+/**
+ * Synchronous version of detectPackageManager for use in startup code.
+ * Only checks JS lockfiles (not Python) since sequant is a Node.js tool.
+ */
+export function detectPackageManagerSync() {
+    for (const { file, pm } of LOCKFILE_PRIORITY) {
+        if (existsSync(file)) {
+            return pm;
+        }
+    }
+    return "npm";
+}
 /**
  * Get package manager command configuration
  */

package/dist/src/lib/system.js

@@ -3,6 +3,7 @@
  */
 import { execSync } from "child_process";
 import fs from "fs";
+import { GitHubProvider } from "./workflow/platforms/github.js";
 /**
  * Check if a command exists on the system
  */
@@ -23,13 +24,8 @@ export function commandExists(cmd) {
  * Check if gh CLI is authenticated
  */
 export function isGhAuthenticated() {
-    try {
-        execSync("gh auth status", { stdio: "ignore" });
-        return true;
-    }
-    catch {
-        return false;
-    }
+    const github = new GitHubProvider();
+    return github.checkAuthSync();
 }
 /**
  * Check if running in Windows Subsystem for Linux (WSL)

package/dist/src/lib/test-tautology-detector.d.ts

@@ -56,6 +56,8 @@ export interface TautologyFileResult {
     parseSuccess: boolean;
     /** Error message if parsing failed */
     parseError?: string;
+    /** Whether the file was skipped via @tautology-skip pragma */
+    skipped?: boolean;
 }
 /**
  * Overall tautology detection results
@@ -101,6 +103,14 @@ export declare function extractTestBlocks(content: string): Array<{
  * Check if a test block contains calls to any of the imported production functions
  */
 export declare function testBlockCallsProductionCode(body: string, importedFunctions: ImportedFunction[]): boolean;
+/**
+ * Check if a file opts out of tautology detection via pragma comment.
+ *
+ * Recognized pragmas (must appear in the first 10 lines):
+ *   // @tautology-skip: <reason>
+ *   // @tautology-skip
+ */
+export declare function hasTautologySkipPragma(content: string): boolean;
 /**
  * Analyze a single test file for tautological tests
  */

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

@@ -360,10 +360,33 @@ export function testBlockCallsProductionCode(body, importedFunctions) {
     }
     return false;
 }
+/**
+ * Check if a file opts out of tautology detection via pragma comment.
+ *
+ * Recognized pragmas (must appear in the first 10 lines):
+ *   // @tautology-skip: <reason>
+ *   // @tautology-skip
+ */
+export function hasTautologySkipPragma(content) {
+    const headerLines = content.split("\n").slice(0, 10);
+    return headerLines.some((line) => /\/\/\s*@tautology-skip/.test(line));
+}
 /**
  * Analyze a single test file for tautological tests
  */
 export function analyzeTestFile(content, filePath) {
+    if (hasTautologySkipPragma(content)) {
+        return {
+            filePath,
+            totalTests: 0,
+            tautologicalCount: 0,
+            tautologicalPercentage: 0,
+            testBlocks: [],
+            importedFunctions: [],
+            parseSuccess: true,
+            skipped: true,
+        };
+    }
     try {
         const importedFunctions = extractImports(content);
         const testBlocks = extractTestBlocks(content);
@@ -404,9 +427,11 @@ export function analyzeTestFile(content, filePath) {
  */
 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);
+    // Exclude skipped files from summary counts
+    const analyzed = fileResults.filter((r) => !r.skipped);
+    const totalFiles = analyzed.length;
+    const totalTests = analyzed.reduce((sum, r) => sum + r.totalTests, 0);
+    const totalTautological = analyzed.reduce((sum, r) => sum + r.tautologicalCount, 0);
     const overallPercentage = totalTests > 0 ? (totalTautological / totalTests) * 100 : 0;
     return {
         fileResults,
@@ -429,7 +454,21 @@ export function formatTautologyResults(results) {
     // Summary table
     lines.push("| Category | Status | Notes |");
     lines.push("|----------|--------|-------|");
-    if (results.summary.totalTests === 0) {
+    // Skipped files (via @tautology-skip pragma)
+    const skippedFiles = results.fileResults.filter((r) => r.skipped);
+    if (skippedFiles.length > 0) {
+        lines.push(`| Tautology Check | ⏭️ SKIP | ${skippedFiles.length} file(s) skipped via @tautology-skip |`);
+        lines.push("");
+        lines.push("**Skipped (@tautology-skip):**");
+        for (const file of skippedFiles) {
+            lines.push(`- \`${file.filePath}\``);
+        }
+        lines.push("");
+        if (results.summary.totalTests === 0) {
+            return lines.join("\n");
+        }
+    }
+    else if (results.summary.totalTests === 0) {
         lines.push("| Tautology Check | ⏭️ SKIP | No test blocks found |");
         return lines.join("\n");
     }