pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/secrets.js

@@ -1,109 +0,0 @@
-/**
- * Secrets scanner runner
- *
- * Scans file content for potential secret patterns before write.
- * Works on all file types via regex matching.
- *
- * Patterns detected:
- * - Stripe/OpenAI keys (sk-*)
- * - GitHub tokens (ghp_*, gho_*, github_pat_*)
- * - AWS keys (AKIA*)
- * - Slack tokens (xoxp-*, xoxb-*)
- * - Private keys (BEGIN PRIVATE KEY)
- * - Generic API key patterns
- */
-const SECRET_PATTERNS = [
-    {
-        pattern: /sk-[a-zA-Z0-9]{20,}/g,
-        name: "stripe-openai-key",
-        message: "Possible Stripe or OpenAI API key (sk-*)",
-    },
-    {
-        pattern: /ghp_[a-zA-Z0-9]{36}/g,
-        name: "github-personal-token",
-        message: "GitHub personal access token (ghp_*)",
-    },
-    {
-        pattern: /gho_[a-zA-Z0-9]{36}/g,
-        name: "github-oauth-token",
-        message: "GitHub OAuth token (gho_*)",
-    },
-    {
-        pattern: /github_pat_[a-zA-Z_]{82}/g,
-        name: "github-fine-grained-pat",
-        message: "GitHub fine-grained PAT (github_pat_*)",
-    },
-    {
-        pattern: /AKIA[0-9A-Z]{16}/g,
-        name: "aws-access-key",
-        message: "AWS access key ID (AKIA*)",
-    },
-    {
-        pattern: /xox[bp]-[a-zA-Z0-9]{10,}/g,
-        name: "slack-token",
-        message: "Slack token (xoxb-*/xoxp-*)",
-    },
-    {
-        pattern: /-----BEGIN\s+(RSA\s+)?PRIVATE KEY-----/g,
-        name: "private-key",
-        message: "Private key material detected",
-    },
-    {
-        pattern: /password\s*[:=]\s*["'][^"']{8,}["']/gi,
-        name: "hardcoded-password",
-        message: "Possible hardcoded password",
-    },
-    {
-        pattern: /(?:secret|api_?key|token)\s*[:=]\s*["'][a-zA-Z0-9]{20,}["']/gi,
-        name: "generic-api-secret",
-        message: "Possible hardcoded secret, API key, or token",
-    },
-];
-function scanContent(content) {
-    const findings = [];
-    const lines = content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        for (const secret of SECRET_PATTERNS) {
-            secret.pattern.lastIndex = 0; // Reset regex state
-            const match = secret.pattern.exec(line);
-            if (match) {
-                findings.push({
-                    line: i + 1,
-                    pattern: secret,
-                    match: match[0].slice(0, 20) + "...",
-                });
-            }
-        }
-    }
-    return findings;
-}
-async function run(ctx) {
-    const diagnostics = [];
-    // Get the content being written - check both full content and the diff
-    const content = ctx.content;
-    if (!content)
-        return { diagnostics };
-    const findings = scanContent(content);
-    for (const finding of findings) {
-        diagnostics.push({
-            id: `secrets-${finding.pattern.name}-${finding.line}`,
-            message: `${finding.pattern.message} at line ${finding.line}. Remove before committing.`,
-            filePath: ctx.filePath,
-            line: finding.line,
-            severity: "error",
-            semantic: "blocking", // Always blocking - secrets should never be committed
-            tool: "secrets",
-            rule: finding.pattern.name,
-            fixable: false,
-        });
-    }
-    return { diagnostics };
-}
-const runner = {
-    id: "secrets",
-    appliesTo: ["*"], // All file types
-    priority: 0, // Run first - block before other checks
-    run,
-};
-export default runner;

package/commands/fix.js

@@ -1,244 +0,0 @@
-/**
- * Fix command for pi-lens
- *
- * Automated fix loop that scans for issues and generates fix plans.
- * Supports --loop flag for automatic iteration via auto-loop engine.
- */
-import * as childProcess from "node:child_process";
-import * as nodeFs from "node:fs";
-import * as path from "node:path";
-import { createAutoLoop } from "../clients/auto-loop.js";
-import { scanAll, } from "../clients/fix-scanners.js";
-// --- Auto-loop singleton ---
-let fixLoop = null;
-function getFixLoop(pi) {
-    if (!fixLoop) {
-        fixLoop = createAutoLoop(pi, {
-            name: "fix",
-            maxIterations: 3,
-            command: "/lens-booboo-fix --loop",
-            exitPatterns: [
-                /✅ BOOBOO FIX LOOP COMPLETE/,
-                /⚠️ BOOBOO FIX LOOP STOPPED/,
-                /No more fixable issues/,
-                /Max iterations.*reached/,
-            ],
-        });
-    }
-    return fixLoop;
-}
-function loadSession(sessionFile) {
-    try {
-        const session = JSON.parse(nodeFs.readFileSync(sessionFile, "utf-8"));
-        return {
-            iteration: session.iteration || 0,
-            counts: session.counts || {},
-            falsePositives: session.falsePositives || [],
-        };
-    }
-    catch {
-        return { iteration: 0, counts: {}, falsePositives: [] };
-    }
-}
-function saveSession(sessionFile, session) {
-    nodeFs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-    nodeFs.writeFileSync(sessionFile, JSON.stringify(session, null, 2), "utf-8");
-}
-function resetSession(sessionFile) {
-    try {
-        nodeFs.unlinkSync(sessionFile);
-    }
-    catch {
-        // Ignore if doesn't exist
-    }
-    return { iteration: 0, counts: {}, falsePositives: [] };
-}
-// --- Issue ID helpers ---
-const issueId = (type, file, line) => line !== undefined ? `${type}:${file}:${line}` : `${type}:${file}`;
-const isFalsePositive = (id, session) => session.falsePositives.includes(id);
-// --- Plan generation ---
-function generatePlan(results, session, _isTsProject, prevCounts) {
-    const MAX_ITERATIONS = 3;
-    // Filter out false positives
-    const filteredDups = results.duplicates.filter((c) => !isFalsePositive(issueId("duplicate", c.fileA, c.startA), session));
-    const filteredDeadCode = results.deadCode.filter((i) => !isFalsePositive(issueId("dead_code", i.file ?? i.name), session));
-    const filteredBiome = results.biomeIssues.filter((i) => !isFalsePositive(issueId("biome", i.file, i.line), session));
-    const filteredSlop = results.slopFiles.filter((f) => !isFalsePositive(issueId("slop", f.file), session));
-    // Filter ast issues (exclude skip rules and false positives)
-    const agentTasks = results.astIssues.filter((i) => !isFalsePositive(issueId("ast", i.file, i.line), session));
-    const totalFixable = filteredDups.length +
-        filteredDeadCode.length +
-        agentTasks.length +
-        filteredBiome.length +
-        filteredSlop.length;
-    // Check for no progress
-    const prevTotal = Object.values(prevCounts).reduce((a, b) => a + b, 0);
-    const noProgress = session.iteration > 1 && prevTotal === totalFixable && totalFixable > 0;
-    // Completion/stopped messages
-    if (totalFixable === 0) {
-        const fpNote = session.falsePositives.length > 0
-            ? `\n\n📝 ${session.falsePositives.length} item(s) marked as false positives.`
-            : "";
-        return `✅ BOOBOO FIX LOOP COMPLETE — No more fixable issues found after ${session.iteration} iteration(s).${fpNote}`;
-    }
-    if (noProgress) {
-        return `⚠️ BOOBOO FIX LOOP STOPPED — No progress after ${session.iteration} iteration(s).\n\nRemaining items may be false positives. Mark with: /lens-booboo-fix --false-positive "<type>:<file>:<line>"`;
-    }
-    // --- Write TSV plan file for agent to read ---
-    const reportDir = path.join(process.cwd(), ".pi-lens", "reports");
-    nodeFs.mkdirSync(reportDir, { recursive: true });
-    const reportPath = path.join(reportDir, "fix-plan.tsv");
-    const tsvRows = ["type\tfile\trule\tmessage"];
-    // Duplicates
-    for (const clone of filteredDups) {
-        tsvRows.push(`dup\t${clone.fileA}:${clone.startA}\tduplicate-code\t${clone.lines} lines duplicated with ${clone.fileB}:${clone.startB}`);
-    }
-    // Dead code
-    for (const issue of filteredDeadCode) {
-        tsvRows.push(`dead\t${issue.file || issue.name}\t${issue.type}\t${issue.name} is unused`);
-    }
-    // AST issues
-    for (const issue of agentTasks) {
-        tsvRows.push(`ast\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`);
-    }
-    // Biome
-    for (const issue of filteredBiome) {
-        tsvRows.push(`biome\t${issue.file}:${issue.line}\t${issue.rule}\t${issue.message}`);
-    }
-    // Slop
-    for (const { file, warnings } of filteredSlop) {
-        for (const w of warnings) {
-            tsvRows.push(`slop\t${file}\tcomplexity\t${w}`);
-        }
-    }
-    nodeFs.writeFileSync(reportPath, tsvRows.join("\n"), "utf-8");
-    // --- Build actionable list for terminal (no TSV reading needed) ---
-    const lines = [];
-    lines.push(`📋 FIX PLAN — Iteration ${session.iteration}/${MAX_ITERATIONS} — ${totalFixable} issues:\n`);
-    // Duplicates
-    if (filteredDups.length > 0) {
-        for (const clone of filteredDups.slice(0, 10)) {
-            lines.push(`🔁 ${clone.fileA}:${clone.startA} — ${clone.lines} dup from ${clone.fileB}:${clone.startB}`);
-        }
-        if (filteredDups.length > 10)
-            lines.push(`   ... +${filteredDups.length - 10} more`);
-        lines.push("");
-    }
-    // Dead code
-    if (filteredDeadCode.length > 0) {
-        for (const issue of filteredDeadCode.slice(0, 10)) {
-            lines.push(`🗑️ ${issue.file || issue.name} — ${issue.name} unused`);
-        }
-        if (filteredDeadCode.length > 10)
-            lines.push(`   ... +${filteredDeadCode.length - 10} more`);
-        lines.push("");
-    }
-    // AST lint
-    if (agentTasks.length > 0) {
-        for (const issue of agentTasks.slice(0, 15)) {
-            lines.push(`🔨 ${issue.file}:${issue.line} — ${issue.rule}`);
-        }
-        if (agentTasks.length > 15)
-            lines.push(`   ... +${agentTasks.length - 15} more`);
-        lines.push("");
-    }
-    // Biome
-    if (filteredBiome.length > 0) {
-        for (const issue of filteredBiome.slice(0, 10)) {
-            lines.push(`🟠 ${issue.file}:${issue.line} — ${issue.rule}`);
-        }
-        if (filteredBiome.length > 10)
-            lines.push(`   ... +${filteredBiome.length - 10} more`);
-        lines.push("");
-    }
-    // AI Slop
-    if (filteredSlop.length > 0) {
-        for (const { file, warnings } of filteredSlop.slice(0, 5)) {
-            lines.push(`🤖 ${file} — ${warnings[0]}`);
-        }
-        if (filteredSlop.length > 5)
-            lines.push(`   ... +${filteredSlop.length - 5} more`);
-        lines.push("");
-    }
-    lines.push("---");
-    lines.push("🚀 Fix items above, then run `/lens-booboo-fix --loop`");
-    lines.push('🚫 False positive: `/lens-booboo-fix --false-positive "type:file:line"`');
-    return lines.join("\n");
-}
-// --- Main handler ---
-export async function handleFix(args, ctx, clients, pi, _ruleActions) {
-    const resetRequested = args.includes("--reset");
-    const loopMode = args.includes("--loop");
-    const fpMatch = args.match(/--false-positive\s+"([^"]+)"/);
-    const falsePositiveId = fpMatch?.[1];
-    // Clean args
-    const cleanArgs = args
-        .replace("--reset", "")
-        .replace("--loop", "")
-        .replace(/--false-positive\s+"[^"]+"/, "")
-        .trim();
-    const targetPath = cleanArgs || ctx.cwd || process.cwd();
-    const sessionFile = path.join(process.cwd(), ".pi-lens", "fix-session.json");
-    const configPath = path.join(typeof __dirname !== "undefined" ? __dirname : ".", "..", "rules", "ast-grep-rules", ".sgconfig.yml");
-    // Load session
-    let session = loadSession(sessionFile);
-    if (resetRequested) {
-        session = resetSession(sessionFile);
-        ctx.ui.notify("🔄 Fix session reset.", "info");
-    }
-    // Handle false positive marking
-    if (falsePositiveId) {
-        if (!session.falsePositives.includes(falsePositiveId)) {
-            session.falsePositives.push(falsePositiveId);
-            saveSession(sessionFile, session);
-            ctx.ui.notify(`✅ Marked as false positive: "${falsePositiveId}"`, "info");
-        }
-        return;
-    }
-    // Start auto-loop if requested
-    const loop = getFixLoop(pi);
-    if (loopMode && !loop.getState().active) {
-        loop.start(ctx);
-    }
-    ctx.ui.notify("🔧 Running booboo fix loop...", "info");
-    const isTsProject = nodeFs.existsSync(path.join(targetPath, "tsconfig.json"));
-    // Auto-fix with Biome + Ruff
-    if (!pi.getFlag("no-biome") && clients.biome.isAvailable()) {
-        childProcess.spawnSync("npx", ["@biomejs/biome", "check", "--write", "--unsafe", targetPath], {
-            encoding: "utf-8",
-            timeout: 30000,
-            shell: true,
-        });
-    }
-    if (!pi.getFlag("no-ruff") && clients.ruff.isAvailable()) {
-        childProcess.spawnSync("ruff", ["check", "--fix", targetPath], {
-            encoding: "utf-8",
-            timeout: 15000,
-            shell: true,
-        });
-        childProcess.spawnSync("ruff", ["format", targetPath], {
-            encoding: "utf-8",
-            timeout: 15000,
-            shell: true,
-        });
-    }
-    // Run all scanners
-    const prevCounts = { ...session.counts };
-    session.iteration++;
-    const results = scanAll(clients, targetPath, isTsProject, configPath);
-    // Update session counts
-    session.counts = {
-        duplicates: results.duplicates.length,
-        dead_code: results.deadCode.length,
-        ast_issues: results.astIssues.length,
-        biome_issues: results.biomeIssues.length,
-        slop_files: results.slopFiles.length,
-    };
-    saveSession(sessionFile, session);
-    // Generate and send plan
-    const plan = generatePlan(results, session, isTsProject, prevCounts);
-    const planPath = path.join(process.cwd(), ".pi-lens", "fix-plan.md");
-    nodeFs.writeFileSync(planPath, `# Fix Plan — Iteration ${session.iteration}\n\n${plan}`, "utf-8");
-    ctx.ui.notify(`📄 Fix plan saved: ${planPath}`, "info");
-    pi.sendUserMessage(plan, { deliverAs: "followUp" });
-}