sapper-ai 0.2.2 → 0.3.0

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAUA,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CA2BpF"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAWA,wBAAsB,MAAM,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAiCpF"}

package/dist/cli.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
 const node_fs_1 = require("node:fs");
 const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const readline = __importStar(require("node:readline"));
 const presets_1 = require("./presets");
@@ -52,7 +53,12 @@ async function runCli(argv = process.argv.slice(2)) {
             printUsage();
             return 1;
         }
-        return (0, scan_1.runScan)(parsed);
+        const scanOptions = await resolveScanOptions(parsed);
+        if (!scanOptions) {
+            printUsage();
+            return 1;
+        }
+        return (0, scan_1.runScan)(scanOptions);
     }
     if (argv[0] === 'dashboard') {
         return runDashboard();
@@ -69,8 +75,12 @@ function printUsage() {
 sapper-ai - AI security guardrails
 
 Usage:
-  sapper-ai scan          Scan environment for threats
-  sapper-ai scan --fix    Scan and quarantine blocked files
+  sapper-ai scan              Interactive scan scope (TTY only)
+  sapper-ai scan .            Current directory only (no subdirectories)
+  sapper-ai scan --deep       Current directory + subdirectories
+  sapper-ai scan --system     AI system paths (~/.claude, ~/.cursor, ...)
+  sapper-ai scan ./path       Scan a specific file/directory
+  sapper-ai scan --fix        Quarantine blocked files
   sapper-ai init          Interactive setup wizard
   sapper-ai dashboard     Launch web dashboard
   sapper-ai --help        Show this help
@@ -81,17 +91,89 @@ Learn more: https://github.com/sapper-ai/sapperai
 function parseScanArgs(argv) {
     const targets = [];
     let fix = false;
+    let deep = false;
+    let system = false;
     for (const arg of argv) {
         if (arg === '--fix') {
             fix = true;
             continue;
         }
+        if (arg === '--deep') {
+            deep = true;
+            continue;
+        }
+        if (arg === '--system') {
+            system = true;
+            continue;
+        }
         if (arg.startsWith('-')) {
             return null;
         }
         targets.push(arg);
     }
-    return { targets, fix };
+    return { targets, fix, deep, system };
+}
+function displayPath(path) {
+    const home = (0, node_os_1.homedir)();
+    if (path === home)
+        return '~';
+    return path.startsWith(home + '/') ? `~/${path.slice(home.length + 1)}` : path;
+}
+async function promptScanScope(cwd) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((res) => rl.question(q, res));
+    try {
+        console.log('\n  SapperAI Security Scanner\n');
+        console.log('  ? Scan scope:');
+        console.log(`  ❯ 1) Current directory only     ${displayPath(cwd)}`);
+        console.log(`    2) Current + subdirectories   ${displayPath((0, node_path_1.join)(cwd, '**'))}`);
+        console.log('    3) AI system scan              ~/.claude, ~/.cursor, ~/.vscode ...');
+        console.log();
+        const answer = await ask('  Choose [1-3] (default: 2): ');
+        const picked = Number.parseInt(answer.trim(), 10);
+        if (picked === 1)
+            return 'shallow';
+        if (picked === 3)
+            return 'system';
+        return 'deep';
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveScanOptions(args) {
+    const cwd = process.cwd();
+    if (args.system) {
+        if (args.targets.length > 0) {
+            return null;
+        }
+        return { system: true, fix: args.fix, scopeLabel: 'AI system scan' };
+    }
+    if (args.targets.length > 0) {
+        if (args.targets.length === 1 && args.targets[0] === '.' && !args.deep) {
+            return { targets: [cwd], deep: false, fix: args.fix, scopeLabel: 'Current directory only' };
+        }
+        return {
+            targets: args.targets,
+            deep: true,
+            fix: args.fix,
+            scopeLabel: args.targets.length === 1 && args.targets[0] === '.' ? 'Current + subdirectories' : 'Custom path',
+        };
+    }
+    if (args.deep) {
+        return { targets: [cwd], deep: true, fix: args.fix, scopeLabel: 'Current + subdirectories' };
+    }
+    if (process.stdout.isTTY !== true) {
+        return { targets: [cwd], deep: true, fix: args.fix, scopeLabel: 'Current + subdirectories' };
+    }
+    const scope = await promptScanScope(cwd);
+    if (scope === 'system') {
+        return { system: true, fix: args.fix, scopeLabel: 'AI system scan' };
+    }
+    if (scope === 'shallow') {
+        return { targets: [cwd], deep: false, fix: args.fix, scopeLabel: 'Current directory only' };
+    }
+    return { targets: [cwd], deep: true, fix: args.fix, scopeLabel: 'Current + subdirectories' };
 }
 async function runDashboard() {
     const configuredPort = process.env.PORT;

package/dist/scan.d.ts

@@ -1,6 +1,9 @@
 export interface ScanOptions {
     targets?: string[];
     fix?: boolean;
+    deep?: boolean;
+    system?: boolean;
+    scopeLabel?: string;
 }
 export declare function runScan(options?: ScanOptions): Promise<number>;
 //# sourceMappingURL=scan.d.ts.map

package/dist/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,GAAG,CAAC,EAAE,OAAO,CAAA;CACd;AAqMD,wBAAsB,OAAO,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwDxE"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AA6TD,wBAAsB,OAAO,CAAC,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsGxE"}

package/dist/scan.js

@@ -8,6 +8,20 @@ const node_path_1 = require("node:path");
 const core_1 = require("@sapper-ai/core");
 const presets_1 = require("./presets");
 const CONFIG_FILE_NAMES = ['sapperai.config.yaml', 'sapperai.config.yml'];
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+const SYSTEM_SCAN_PATHS = (() => {
+    const home = (0, node_os_1.homedir)();
+    return [
+        (0, node_path_1.join)(home, '.claude'),
+        (0, node_path_1.join)(home, '.config', 'claude-code'),
+        (0, node_path_1.join)(home, '.cursor'),
+        (0, node_path_1.join)(home, '.vscode', 'extensions'),
+        (0, node_path_1.join)(home, 'Library', 'Application Support', 'Claude'),
+    ];
+})();
 function findConfigFile(cwd) {
     for (const name of CONFIG_FILE_NAMES) {
         const fullPath = (0, node_path_1.resolve)(cwd, name);
@@ -30,15 +44,11 @@ function getThresholds(policy) {
     const blockMinConfidence = typeof extended.thresholds?.blockMinConfidence === 'number' ? extended.thresholds.blockMinConfidence : 0.5;
     return { riskThreshold, blockMinConfidence };
 }
-function toDefaultTargets(cwd) {
-    const home = (0, node_os_1.homedir)();
-    return [(0, node_path_1.join)(home, '.claude', 'plugins'), (0, node_path_1.join)(home, '.config', 'claude-code'), cwd];
-}
 function shouldSkipDir(dirName) {
     const base = (0, node_path_1.basename)(dirName);
     return base === 'node_modules' || base === '.git' || base === 'dist';
 }
-async function collectFiles(targetPath) {
+async function collectFiles(targetPath, deep) {
     try {
         const info = await (0, promises_1.stat)(targetPath);
         if (info.isFile()) {
@@ -51,6 +61,21 @@ async function collectFiles(targetPath) {
     catch {
         return [];
     }
+    if (!deep) {
+        try {
+            const entries = await (0, promises_1.readdir)(targetPath, { withFileTypes: true });
+            const results = [];
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                results.push((0, node_path_1.join)(targetPath, entry.name));
+            }
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }
     const results = [];
     const stack = [targetPath];
     while (stack.length > 0) {
@@ -80,6 +105,85 @@ async function collectFiles(targetPath) {
     }
     return results;
 }
+function riskColor(risk) {
+    if (risk >= 0.8)
+        return RED;
+    if (risk >= 0.5)
+        return YELLOW;
+    return GREEN;
+}
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function truncateToWidth(text, maxWidth) {
+    if (maxWidth <= 0) {
+        return '';
+    }
+    if (text.length <= maxWidth) {
+        return text;
+    }
+    if (maxWidth <= 3) {
+        return '.'.repeat(maxWidth);
+    }
+    return `...${text.slice(text.length - (maxWidth - 3))}`;
+}
+function renderProgressBar(current, total, width) {
+    const safeTotal = Math.max(1, total);
+    const pct = Math.floor((current / safeTotal) * 100);
+    const filled = Math.floor((current / safeTotal) * width);
+    const bar = '█'.repeat(filled) + '░'.repeat(Math.max(0, width - filled));
+    return `  ${bar}  ${pct}% │ ${current}/${total} files`;
+}
+function extractPatternLabel(decision) {
+    const reason = decision.reasons[0];
+    if (!reason)
+        return 'threat';
+    return reason.startsWith('Detected pattern: ') ? reason.slice('Detected pattern: '.length) : reason;
+}
+function padRight(text, width) {
+    if (text.length >= width)
+        return text;
+    return text + ' '.repeat(width - text.length);
+}
+function padRightVisual(text, width) {
+    const visLen = stripAnsi(text).length;
+    if (visLen >= width)
+        return text;
+    return text + ' '.repeat(width - visLen);
+}
+function padLeft(text, width) {
+    if (text.length >= width)
+        return text;
+    return ' '.repeat(width - text.length) + text;
+}
+function renderFindingsTable(findings, opts) {
+    const rows = findings.map((f, i) => {
+        const file = f.filePath.startsWith(opts.cwd + '/') ? f.filePath.slice(opts.cwd.length + 1) : f.filePath;
+        const pattern = extractPatternLabel(f.decision);
+        const riskValue = f.decision.risk.toFixed(2);
+        const riskPlain = padLeft(riskValue, 4);
+        const risk = opts.color ? `${riskColor(f.decision.risk)}${riskPlain}${RESET}` : riskPlain;
+        return { idx: String(i + 1), file, risk, pattern };
+    });
+    const idxWidth = Math.max(1, ...rows.map((r) => r.idx.length));
+    const riskWidth = 4;
+    const patternWidth = Math.min(20, Math.max('Pattern'.length, ...rows.map((r) => r.pattern.length)));
+    const baseWidth = 2 + idxWidth + 2 + 2 + riskWidth + 2 + 2 + patternWidth + 2;
+    const maxTableWidth = Math.max(60, Math.min(opts.columns || 80, 120));
+    const fileWidth = Math.max(20, Math.min(50, maxTableWidth - baseWidth));
+    const top = `  ┌${'─'.repeat(idxWidth + 2)}┬${'─'.repeat(fileWidth + 2)}┬${'─'.repeat(riskWidth + 2)}┬${'─'.repeat(patternWidth + 2)}┐`;
+    const header = `  │ ${padRight('#', idxWidth)} │ ${padRight('File', fileWidth)} │ ${padRight('Risk', riskWidth)} │ ${padRight('Pattern', patternWidth)} │`;
+    const sep = `  ├${'─'.repeat(idxWidth + 2)}┼${'─'.repeat(fileWidth + 2)}┼${'─'.repeat(riskWidth + 2)}┼${'─'.repeat(patternWidth + 2)}┤`;
+    const lines = [top, header, sep];
+    for (const r of rows) {
+        const file = truncateToWidth(r.file, fileWidth);
+        const pattern = truncateToWidth(r.pattern, patternWidth);
+        lines.push(`  │ ${padRight(r.idx, idxWidth)} │ ${padRight(file, fileWidth)} │ ${padRightVisual(r.risk, riskWidth)} │ ${padRight(pattern, patternWidth)} │`);
+    }
+    const bottom = `  └${'─'.repeat(idxWidth + 2)}┴${'─'.repeat(fileWidth + 2)}┴${'─'.repeat(riskWidth + 2)}┴${'─'.repeat(patternWidth + 2)}┘`;
+    lines.push(bottom);
+    return lines;
+}
 function isThreat(decision, policy) {
     const { riskThreshold, blockMinConfidence } = getThresholds(policy);
     return decision.risk >= riskThreshold && decision.confidence >= blockMinConfidence;
@@ -142,60 +246,87 @@ async function scanFile(filePath, policy, scanner, detectors, fix, quarantineMan
     }
     return { scanned: true, finding: { filePath, decision: bestThreat } };
 }
-function formatFindingLine(index, finding) {
-    const reason = finding.decision.reasons[0];
-    const label = reason?.startsWith('Detected pattern: ')
-        ? reason.slice('Detected pattern: '.length)
-        : reason ?? 'threat';
-    const risk = finding.decision.risk.toFixed(2);
-    const quarantineSuffix = finding.quarantinedId ? ` (quarantined: ${finding.quarantinedId})` : '';
-    return `  ${index}. ${finding.filePath}\n     Risk: ${risk} | ${label}${quarantineSuffix}`;
-}
 async function runScan(options = {}) {
     const cwd = process.cwd();
     const policy = resolvePolicy(cwd);
     const fix = options.fix === true;
-    const targets = options.targets && options.targets.length > 0 ? options.targets : toDefaultTargets(cwd);
+    const deep = options.system ? true : options.deep !== false;
+    const targets = options.system === true
+        ? SYSTEM_SCAN_PATHS
+        : options.targets && options.targets.length > 0
+            ? options.targets
+            : [cwd];
     const scanner = new core_1.Scanner();
     const detectors = (0, core_1.createDetectors)({ policy });
     const quarantineDir = process.env.SAPPERAI_QUARANTINE_DIR;
     const quarantineManager = quarantineDir ? new core_1.QuarantineManager({ quarantineDir }) : new core_1.QuarantineManager();
-    console.log('\n  SapperAI Environment Scan\n');
-    console.log('  Scanning:');
-    for (const target of targets) {
-        console.log(`    ${target}`);
-    }
+    const isTTY = process.stdout.isTTY === true;
+    const color = isTTY;
+    const scopeLabel = options.scopeLabel ??
+        (options.system
+            ? 'AI system scan'
+            : deep
+                ? 'Current + subdirectories'
+                : 'Current directory only');
+    console.log('\n  SapperAI Security Scanner\n');
+    console.log(`  Scope: ${scopeLabel}`);
     console.log();
     const fileSet = new Set();
     for (const target of targets) {
-        const files = await collectFiles(target);
+        const files = await collectFiles(target, deep);
         for (const f of files) {
             fileSet.add(f);
         }
     }
-    let scannedFiles = 0;
+    const files = Array.from(fileSet).sort();
+    console.log(`  Collecting files...  ${files.length} files found`);
+    console.log();
     const findings = [];
-    for (const filePath of Array.from(fileSet).sort()) {
-        const result = await scanFile(filePath, policy, scanner, detectors, fix, quarantineManager);
-        if (result.scanned) {
-            scannedFiles += 1;
+    const total = files.length;
+    const progressWidth = Math.max(10, Math.min(30, (process.stdout.columns ?? 80) - 30));
+    for (let i = 0; i < files.length; i += 1) {
+        const filePath = files[i];
+        if (isTTY && total > 0) {
+            const bar = renderProgressBar(i + 1, total, progressWidth);
+            const label = '  Scanning: ';
+            const maxPath = Math.max(10, (process.stdout.columns ?? 80) - stripAnsi(bar).length - label.length);
+            const scanning = `${label}${truncateToWidth(filePath, maxPath)}`;
+            if (i === 0) {
+                process.stdout.write(`${bar}\n${scanning}\n`);
+            }
+            else {
+                process.stdout.write(`\x1b[2A\x1b[2K\r${bar}\n\x1b[2K\r${scanning}\n`);
+            }
         }
+        const result = await scanFile(filePath, policy, scanner, detectors, fix, quarantineManager);
         if (result.finding) {
             findings.push(result.finding);
         }
     }
-    console.log('  Results:');
-    console.log(`    ${scannedFiles} files scanned, ${findings.length} threats detected`);
+    if (isTTY && total > 0) {
+        process.stdout.write('\x1b[2A\x1b[2K\r\x1b[1B\x1b[2K\r');
+    }
+    if (findings.length === 0) {
+        const msg = `  ✓ All clear — ${total} files scanned, 0 threats detected`;
+        console.log(color ? `${GREEN}${msg}${RESET}` : msg);
+        console.log();
+        return 0;
+    }
+    const warn = `  ⚠ ${total} files scanned, ${findings.length} threats detected`;
+    console.log(color ? `${RED}${warn}${RESET}` : warn);
     console.log();
-    if (findings.length > 0) {
-        findings.forEach((finding, idx) => {
-            console.log(formatFindingLine(idx + 1, finding));
-            console.log();
-        });
-        if (!fix) {
-            console.log("  Run 'npx sapper-ai scan --fix' to quarantine blocked files.");
-            console.log();
-        }
+    const tableLines = renderFindingsTable(findings, {
+        cwd,
+        columns: process.stdout.columns ?? 80,
+        color,
+    });
+    for (const line of tableLines) {
+        console.log(line);
+    }
+    console.log();
+    if (!fix) {
+        console.log("  Run 'npx sapper-ai scan --fix' to quarantine blocked files.");
+        console.log();
     }
-    return findings.length > 0 ? 1 : 0;
+    return 1;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sapper-ai",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "AI security guardrails - single install, sensible defaults",
   "keywords": [
     "security",