codehere 0.1.1 → 0.2.1

package/dist/presentation/cli/commands/trust-command.js

@@ -1,301 +1,290 @@
 /**
- * CLI Command: Trust Dashboard
- * Shows agent reliability metrics and trust scores
+ * CLI Command: trust
  *
- * Phase 1: v0.5.0-alpha.0
+ * Layer 0 trust scorer — instant static analysis, zero API calls.
+ * Runs on a file, directory, or piped git diff.
+ *
+ * Produces a trust score 0–100 with plain-English explanation:
+ *   100 = no findings
+ *   80+ = minor issues, safe to merge
+ *   60-79 = review recommended
+ *   40-59 = high-risk, human review required
+ *   < 40 = block until resolved
+ *
+ * Usage:
+ *   codehere trust src/utils.ts          # score a file
+ *   codehere trust .                     # score all files in directory
+ *   git diff HEAD | codehere trust       # score a diff
+ *   codehere trust --diff HEAD           # equivalent using git directly
+ *   codehere trust --badge               # output badge markdown
  */
-import { colors, sectionHeader, success, error, warning, info, newline, createBanner, createTable, formatNumber, separator, } from '../../../ui.js';
-import { agentFeedbackManager } from '../../../infrastructure/validation/agent-feedback.js';
-export async function executeTrustCommand(action = 'status', options = {}) {
-    console.log(createBanner('Trust Dashboard', 'Agent reliability and performance metrics'));
-    newline();
-    switch (action) {
-        case 'status':
-            await showTrustStatus(options);
-            break;
-        case 'history':
-            await showTrustHistory(options.limit || 20);
-            break;
-        case 'reset':
-            console.log(warning('Reset not implemented in alpha. Feedback is stored in memory only.'));
-            break;
-        default:
-            console.log(error(`Unknown action: ${action}`));
-            console.log(info('Available actions: status, history, reset'));
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { join, extname, relative, isAbsolute } from 'path';
+import { execSync } from 'child_process';
+import { scoreFile } from '../../../infrastructure/security/trust-scorer.js';
+import { colors, sectionHeader, error, newline, info, randomCleanScan } from '../../../ui.js';
+import { loadProductContext, adjustRecommendation } from '../../../infrastructure/config/product-context.js';
+// ── File collection ──────────────────────────────────────────────────────────
+const CODE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rb', '.go', '.java', '.cs', '.php',
+    '.sh', '.bash', '.zsh',
+    '.sql', '.html', '.vue', '.svelte',
+]);
+const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', '.codehere', '.codehere-cache']);
+function collectFiles(target) {
+    const stat = statSync(target);
+    if (stat.isFile())
+        return [target];
+    const files = [];
+    function walk(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (CODE_EXTENSIONS.has(extname(entry.name))) {
+                files.push(full);
+            }
+        }
     }
+    walk(target);
+    return files;
 }
-async function showTrustStatus(options = {}) {
-    const metrics = calculateTrustMetrics();
-    if (options.json) {
-        console.log(JSON.stringify(metrics, null, 2));
-        return;
-    }
-    // Overall Trust Score
-    sectionHeader('Overall Trust Score');
-    newline();
-    const trustScore = Math.round(metrics.successRate * 100);
-    const trustBar = createTrustBar(trustScore);
-    const trustColor = getTrustColor(trustScore);
-    console.log(`  ${trustBar} ${trustColor(`${trustScore}%`)}`);
-    console.log(colors.dim(`  Based on ${metrics.totalOperations} operations`));
-    newline();
-    // Trust Level
-    const trustLevel = getTrustLevel(trustScore);
-    console.log(`  Trust Level: ${trustColor(trustLevel.name)}`);
-    console.log(colors.dim(`  ${trustLevel.description}`));
-    newline();
-    // Trend
-    const trendIcon = getTrendIcon(metrics.recentTrend);
-    console.log(`  Recent Trend: ${trendIcon} ${metrics.recentTrend.replace('_', ' ')}`);
-    newline();
-    // Breakdown by Operation
-    if (Object.keys(metrics.byOperation).length > 0) {
-        sectionHeader('Trust by Operation');
-        const operationRows = Object.entries(metrics.byOperation)
-            .sort((a, b) => b[1].total - a[1].total)
-            .map(([op, data]) => {
-            const rate = Math.round(data.rate * 100);
-            const rateColor = getTrustColor(rate);
-            return [
-                op,
-                formatNumber(data.success),
-                formatNumber(data.total),
-                rateColor(`${rate}%`),
-            ];
-        });
-        const operationTable = createTable(['Operation', 'Success', 'Total', 'Trust'], operationRows);
-        console.log(operationTable.toString());
-        newline();
-    }
-    // Breakdown by Agent
-    if (Object.keys(metrics.byAgent).length > 0) {
-        sectionHeader('Trust by Agent');
-        const agentRows = Object.entries(metrics.byAgent)
-            .sort((a, b) => b[1].total - a[1].total)
-            .map(([agent, data]) => {
-            const rate = Math.round(data.rate * 100);
-            const rateColor = getTrustColor(rate);
-            return [
-                agent,
-                formatNumber(data.success),
-                formatNumber(data.total),
-                rateColor(`${rate}%`),
-            ];
-        });
-        const agentTable = createTable(['Agent', 'Success', 'Total', 'Trust'], agentRows);
-        console.log(agentTable.toString());
-        newline();
-    }
-    // Recommendations
-    sectionHeader('Recommendations');
-    const recommendations = getRecommendations(metrics);
-    if (recommendations.length === 0) {
-        console.log(success('All systems operating within expected parameters.'));
-    }
-    else {
-        recommendations.forEach(rec => {
-            console.log(`  ${rec.icon} ${rec.message}`);
-        });
+// ── Git diff mode ────────────────────────────────────────────────────────────
+function parseDiffFiles(diff) {
+    const files = [];
+    const fileBlocks = diff.split(/^diff --git /m).filter(Boolean);
+    for (const block of fileBlocks) {
+        const filenameMatch = block.match(/^a\/(.+?) b\/(.+?)$/m);
+        if (!filenameMatch)
+            continue;
+        const filepath = filenameMatch[2];
+        // Skip internal backup/cache directories to avoid false findings from old code
+        if (filepath.startsWith('.codehere/') || filepath.startsWith('.codehere-cache/'))
+            continue;
+        // Extract added lines only (lines starting with +, excluding +++)
+        const addedLines = block
+            .split('\n')
+            .filter(l => l.startsWith('+') && !l.startsWith('+++'))
+            .map(l => l.substring(1))
+            .join('\n');
+        if (addedLines.trim()) {
+            files.push({ filepath, code: addedLines });
+        }
     }
-    newline();
-    // Tips
-    console.log(separator('─', 60));
-    console.log(colors.dim('Tips:'));
-    console.log(colors.dim('  • Use --review flag for destructive operations'));
-    console.log(colors.dim('  • Lower trust scores may indicate need for more context'));
-    console.log(colors.dim('  • Run "codehere trust history" to see recent operations'));
-    newline();
+    return files;
 }
-async function showTrustHistory(limit) {
-    const records = agentFeedbackManager.getAllFeedback(limit);
-    if (records.length === 0) {
-        console.log(info('No operation history yet.'));
-        console.log(colors.dim('Run some commands to start building trust metrics.'));
-        newline();
-        return;
+// ── Report formatting ────────────────────────────────────────────────────────
+function gradeColor(grade) {
+    switch (grade) {
+        case 'A': return colors.green(grade);
+        case 'B': return colors.cyan(grade);
+        case 'C': return colors.yellow(grade);
+        case 'D': return colors.red(grade);
+        case 'F': return colors.red(colors.bold(grade));
+        default: return grade;
     }
-    sectionHeader(`Recent Operations (${records.length})`);
-    newline();
-    const historyRows = records.slice(0, limit).map(record => {
-        const outcomeIcon = getOutcomeIcon(record.outcome);
-        const time = record.timestamp
-            ? new Date(record.timestamp).toLocaleString()
-            : 'Unknown';
-        return [
-            outcomeIcon,
-            record.operation || record.agentName,
-            truncate(record.query || '-', 30),
-            record.outcome,
-            time,
-        ];
-    });
-    const historyTable = createTable(['', 'Operation', 'Query', 'Outcome', 'Time'], historyRows);
-    console.log(historyTable.toString());
-    newline();
 }
-function calculateTrustMetrics() {
-    const records = agentFeedbackManager.getAllFeedback(500);
-    if (records.length === 0) {
-        return {
-            totalOperations: 0,
-            successRate: 1,
-            approvalRate: 1,
-            byOperation: {},
-            byAgent: {},
-            recentTrend: 'insufficient_data',
-            lastUpdated: Date.now(),
-        };
+function scoreBar(score, width = 20) {
+    const filled = Math.round((score / 100) * width);
+    const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+    if (score >= 75)
+        return colors.green(bar);
+    if (score >= 60)
+        return colors.yellow(bar);
+    return colors.red(bar);
+}
+function badgeMarkdown(report) {
+    const color = report.grade === 'A' ? 'brightgreen'
+        : report.grade === 'B' ? 'green'
+            : report.grade === 'C' ? 'yellow'
+                : report.grade === 'D' ? 'orange'
+                    : 'red';
+    return `![codehere trust](https://img.shields.io/badge/codehere%20trust-${report.overallScore}%25%20${report.grade}-${color}?logo=shield)`;
+}
+// ── Main command ─────────────────────────────────────────────────────────────
+export async function executeTrustCommand(target, options = {}) {
+    const cwd = process.cwd();
+    let filesToScan = [];
+    // ── Input source ──────────────────────────────────────────────────────────
+    if (options.diff !== undefined) {
+        // Run git diff and scan added lines
+        try {
+            const ref = options.diff || 'HEAD';
+            const diffOutput = execSync(`git diff ${ref}`, { cwd, encoding: 'utf-8' });
+            filesToScan = parseDiffFiles(diffOutput);
+            if (filesToScan.length === 0) {
+                console.log(info('No changed files to scan'));
+                return;
+            }
+        }
+        catch (e) {
+            console.error(error('git diff failed: ' + String(e)));
+            process.exit(1);
+        }
     }
-    let successCount = 0;
-    let approvalCount = 0;
-    let reviewedCount = 0;
-    const byOperation = {};
-    const byAgent = {};
-    for (const record of records) {
-        const isSuccess = record.outcome === 'success';
-        // Overall
-        if (isSuccess)
-            successCount++;
-        // By operation
-        const op = record.operation || 'unknown';
-        if (!byOperation[op]) {
-            byOperation[op] = { success: 0, total: 0, rate: 0 };
+    else if (!process.stdin.isTTY && !target) {
+        // Piped input (e.g., git diff HEAD | codehere trust)
+        let diffInput = '';
+        for await (const chunk of process.stdin) {
+            diffInput += chunk;
         }
-        byOperation[op].total++;
-        if (isSuccess)
-            byOperation[op].success++;
-        // By agent
-        const agent = record.agentName || 'unknown';
-        if (!byAgent[agent]) {
-            byAgent[agent] = { success: 0, total: 0, rate: 0 };
+        if (diffInput.trim().startsWith('diff --git')) {
+            filesToScan = parseDiffFiles(diffInput);
         }
-        byAgent[agent].total++;
-        if (isSuccess)
-            byAgent[agent].success++;
-        // Approvals
-        if (record.userAction === 'approved' || record.userAction === 'rejected') {
-            reviewedCount++;
-            if (record.userAction === 'approved')
-                approvalCount++;
+        else {
+            // Treat as raw code
+            filesToScan = [{ filepath: 'stdin', code: diffInput }];
         }
+        if (filesToScan.length === 0) {
+            console.log(info('No content to scan'));
+            return;
+        }
+    }
+    else {
+        // File or directory
+        const resolved = target ? (isAbsolute(target) ? target : join(cwd, target)) : cwd;
+        if (!existsSync(resolved)) {
+            console.error(error(`Not found: ${resolved}`));
+            process.exit(1);
+        }
+        const paths = collectFiles(resolved);
+        filesToScan = paths.map(p => ({
+            filepath: relative(cwd, p),
+            code: readFileSync(p, 'utf-8'),
+        }));
     }
-    // Calculate rates
-    Object.values(byOperation).forEach(data => {
-        data.rate = data.total > 0 ? data.success / data.total : 0;
-    });
-    Object.values(byAgent).forEach(data => {
-        data.rate = data.total > 0 ? data.success / data.total : 0;
-    });
-    // Calculate trend
-    const recentTrend = calculateTrend(records);
-    return {
-        totalOperations: records.length,
-        successRate: records.length > 0 ? successCount / records.length : 1,
-        approvalRate: reviewedCount > 0 ? approvalCount / reviewedCount : 1,
-        byOperation,
-        byAgent,
-        recentTrend,
-        lastUpdated: Date.now(),
+    // ── Scan ──────────────────────────────────────────────────────────────────
+    const results = filesToScan.map(f => scoreFile(f.filepath, f.code));
+    const totalFindings = results.reduce((s, r) => s + r.findings.length, 0);
+    const criticalCount = results.reduce((s, r) => s + r.findings.filter(f => f.severity === 'critical').length, 0);
+    const highCount = results.reduce((s, r) => s + r.findings.filter(f => f.severity === 'high').length, 0);
+    const mediumCount = results.reduce((s, r) => s + r.findings.filter(f => f.severity === 'medium').length, 0);
+    const lowCount = results.reduce((s, r) => s + r.findings.filter(f => f.severity === 'low').length, 0);
+    const overallScore = results.length > 0
+        ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length)
+        : 100;
+    const grade = overallScore >= 90 ? 'A' : overallScore >= 75 ? 'B' : overallScore >= 60 ? 'C' : overallScore >= 40 ? 'D' : 'F';
+    const baseRecommendation = criticalCount > 0
+        ? `${criticalCount} critical ${criticalCount === 1 ? 'issue' : 'issues'} — worth sorting before this merges.`
+        : highCount > 0
+            ? `Nothing critical, but ${highCount} high-severity ${highCount === 1 ? 'pattern' : 'patterns'} worth a look.`
+            : overallScore >= 75
+                ? 'Clean scan. Nothing blocking a merge.'
+                : 'A few things to look at — nothing critical, but worth a pass.';
+    const productCtx = loadProductContext(process.cwd());
+    const recommendation = adjustRecommendation(baseRecommendation, criticalCount, highCount, overallScore, productCtx);
+    const report = {
+        files: results,
+        overallScore,
+        grade,
+        totalFindings,
+        criticalCount,
+        highCount,
+        mediumCount,
+        lowCount,
+        recommendation,
+        scannedAt: new Date().toISOString(),
     };
-}
-function calculateTrend(records) {
-    if (records.length < 10)
-        return 'insufficient_data';
-    const recent = records.slice(0, Math.min(10, records.length));
-    const older = records.slice(Math.min(10, records.length), Math.min(20, records.length));
-    if (older.length < 5)
-        return 'insufficient_data';
-    const recentSuccess = recent.filter(r => r.outcome === 'success').length / recent.length;
-    const olderSuccess = older.filter(r => r.outcome === 'success').length / older.length;
-    const diff = recentSuccess - olderSuccess;
-    if (diff > 0.1)
-        return 'improving';
-    if (diff < -0.1)
-        return 'declining';
-    return 'stable';
-}
-function createTrustBar(percentage) {
-    const width = 30;
-    const filled = Math.round((percentage / 100) * width);
-    const empty = width - filled;
-    let bar = '';
-    const color = getTrustColor(percentage);
-    bar = color('█'.repeat(filled)) + colors.dim('░'.repeat(empty));
-    return `[${bar}]`;
-}
-function getTrustColor(percentage) {
-    if (percentage >= 80)
-        return colors.green;
-    if (percentage >= 60)
-        return colors.yellow;
-    return colors.red;
-}
-function getTrustLevel(percentage) {
-    if (percentage >= 90) {
-        return { name: 'HIGH', description: 'Agent operations are highly reliable' };
+    // Track CI failure — will throw after display so the CLI action handler catches it
+    const ciFailed = options.ci && (overallScore < 60 || criticalCount > 0);
+    // ── Output ────────────────────────────────────────────────────────────────
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        if (options.ci && (overallScore < 60 || criticalCount > 0))
+            process.exit(1);
+        return;
     }
-    if (percentage >= 75) {
-        return { name: 'GOOD', description: 'Agent operations are generally reliable' };
+    if (options.badge) {
+        console.log(badgeMarkdown(report));
+        return;
     }
-    if (percentage >= 60) {
-        return { name: 'MODERATE', description: 'Consider using --review for important operations' };
+    // Human-readable report
+    newline();
+    sectionHeader('codehere Trust Report');
+    newline();
+    console.log(`  Score    ${scoreBar(overallScore)}  ${colors.bold(String(overallScore))}/100  ${gradeColor(grade)}`);
+    newline();
+    // Findings summary
+    const rows = [
+        criticalCount > 0 ? `  ${colors.red('●')} ${colors.red(String(criticalCount) + ' critical')}` : null,
+        highCount > 0 ? `  ${colors.yellow('●')} ${colors.yellow(String(highCount) + ' high')}` : null,
+        mediumCount > 0 ? `  ${colors.dim('●')} ${mediumCount} medium` : null,
+        lowCount > 0 ? `  ${colors.dim('●')} ${lowCount} low` : null,
+    ].filter(Boolean);
+    if (rows.length === 0) {
+        console.log(`  ${colors.green('✓')} ${randomCleanScan()}`);
     }
-    if (percentage >= 40) {
-        return { name: 'LOW', description: 'Recommend using --review flag for all operations' };
+    else {
+        rows.forEach(r => console.log(r));
     }
-    return { name: 'CRITICAL', description: 'Agent requires review - check recent errors' };
-}
-function getTrendIcon(trend) {
-    switch (trend) {
-        case 'improving': return colors.green('↑');
-        case 'declining': return colors.red('↓');
-        case 'stable': return colors.blue('→');
-        default: return colors.dim('?');
+    newline();
+    // Per-file results (show worst first)
+    if (results.length > 1) {
+        const sorted = [...results].sort((a, b) => a.score - b.score);
+        console.log(colors.bold('Files:'));
+        for (const r of sorted.slice(0, 10)) {
+            const icon = r.score >= 75 ? colors.green('✓') : r.score >= 60 ? colors.yellow('⚠') : colors.red('✗');
+            console.log(`  ${icon} ${gradeColor(r.grade)}  ${String(r.score).padStart(3)}/100  ${colors.dim(r.filepath)}`);
+        }
+        if (sorted.length > 10) {
+            console.log(colors.dim(`  ... and ${sorted.length - 10} more files`));
+        }
+        newline();
     }
-}
-function getOutcomeIcon(outcome) {
-    switch (outcome) {
-        case 'success': return colors.green('✓');
-        case 'failure': return colors.red('✗');
-        case 'cancelled': return colors.yellow('○');
-        case 'partial': return colors.yellow('◐');
-        default: return colors.dim('?');
+    // Verbose: show all findings
+    if (options.verbose) {
+        for (const r of results) {
+            if (r.findings.length === 0)
+                continue;
+            console.log(colors.bold(r.filepath) + ':');
+            for (const f of r.findings) {
+                const sev = f.severity === 'critical' ? colors.red(f.severity)
+                    : f.severity === 'high' ? colors.yellow(f.severity)
+                        : colors.dim(f.severity);
+                const line = f.line ? colors.dim(`:${f.line}`) : '';
+                const cwe = f.cwe ? colors.dim(` [${f.cwe}]`) : '';
+                console.log(`  ${sev}  ${f.category}${cwe}${line} — ${f.description}`);
+            }
+            newline();
+        }
     }
-}
-function getRecommendations(metrics) {
-    const recommendations = [];
-    if (metrics.totalOperations < 10) {
-        recommendations.push({
-            icon: colors.blue('ℹ'),
-            message: 'Run more operations to build reliable trust metrics',
+    else if (criticalCount + highCount > 0) {
+        // Show only critical/high findings without verbose flag
+        console.log(colors.bold('Top findings:'));
+        const allFindings = results.flatMap(r => r.findings
+            .filter(f => f.severity === 'critical' || f.severity === 'high')
+            .map(f => ({ ...f, filepath: r.filepath })));
+        // Show critical first, then high
+        const sorted = allFindings.sort((a, b) => {
+            if (a.severity === 'critical' && b.severity !== 'critical')
+                return -1;
+            if (a.severity !== 'critical' && b.severity === 'critical')
+                return 1;
+            return 0;
         });
+        for (const f of sorted.slice(0, 5)) {
+            const sev = f.severity === 'critical' ? colors.red(f.severity) : colors.yellow(f.severity);
+            const line = f.line ? `:${f.line}` : '';
+            console.log(`  ${sev}  ${f.filepath}${line} — ${f.description}`);
+        }
+        newline();
     }
-    if (metrics.successRate < 0.6) {
-        recommendations.push({
-            icon: colors.yellow('⚠'),
-            message: 'Low success rate - consider providing more context in queries',
-        });
+    // Recommendation
+    const recColor = criticalCount > 0 ? colors.red : highCount > 0 ? colors.yellow : colors.green;
+    console.log(recColor(recommendation));
+    newline();
+    // Helpful tips
+    if (results.length > 0 && !options.ci) {
+        console.log(colors.dim('  codehere trust --badge') + colors.dim('  Add a badge to your README'));
+        console.log(colors.dim('  codehere trust --ci') + colors.dim('     Exit 1 on critical findings (for CI)'));
+        newline();
     }
-    if (metrics.recentTrend === 'declining') {
-        recommendations.push({
-            icon: colors.red('!'),
-            message: 'Trust declining - review recent failures for patterns',
-        });
+    if (ciFailed) {
+        throw new Error(`CI_FAIL:${criticalCount > 0 ? criticalCount + ' critical finding(s)' : 'score ' + overallScore + ' below threshold 60'}`);
     }
-    // Check for problematic operations
-    Object.entries(metrics.byOperation).forEach(([op, data]) => {
-        if (data.total >= 5 && data.rate < 0.5) {
-            recommendations.push({
-                icon: colors.yellow('⚠'),
-                message: `"${op}" has low success rate (${Math.round(data.rate * 100)}%) - may need more specific queries`,
-            });
-        }
-    });
-    return recommendations;
-}
-function truncate(str, maxLen) {
-    if (str.length <= maxLen)
-        return str;
-    return str.substring(0, maxLen - 1) + '…';
 }
 //# sourceMappingURL=trust-command.js.map

package/dist/presentation/cli/commands/undo-command.js

@@ -79,7 +79,7 @@ async function undoFile(filepath) {
         console.log(colors.dim(`  Backup: ${latestBackup}`));
         newline();
         await rollbackFile(fullPath, latestBackup);
-        console.log(success('File restored successfully'));
+        console.log(success('File restored'));
         newline();
     }
     catch (err) {
@@ -135,7 +135,7 @@ async function restoreFromBackup(filepath, backupPath) {
         console.log(colors.dim(`  Backup: ${backupPath}`));
         newline();
         await rollbackFile(fullPath, backupPath);
-        console.log(success('File restored successfully'));
+        console.log(success('File restored'));
         newline();
     }
     catch (err) {