capscan 0.1.0

package/src/reporters/terminal.ts

@@ -0,0 +1,128 @@
+import type { ScanResult, CapabilityCategory, Permission, CapabilityFinding, PackageResult } from '@capscan/engine';
+
+const CATEGORY_ICONS: Record<CapabilityCategory, string> = {
+  filesystem: '📁',
+  network: '🌐',
+  process: '⚙️',
+  environment: '🔑',
+  crypto: '🔐',
+  dynamic_code: '📦',
+  native: '🧩',
+  installation: '🔧',
+  obfuscation: '🎭',
+};
+
+const CATEGORY_LABELS: Record<CapabilityCategory, string> = {
+  filesystem: 'Filesystem',
+  network: 'Network',
+  process: 'Process',
+  environment: 'Environment',
+  crypto: 'Crypto',
+  dynamic_code: 'Dynamic Code',
+  native: 'Native',
+  installation: 'Installation',
+  obfuscation: 'Obfuscation',
+};
+
+const CONFIDENCE_COLORS: Record<string, (s: string) => string> = {
+  high: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  medium: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  low: (s: string) => `\x1b[31m${s}\x1b[0m`,
+};
+
+function padRight(str: string, len: number): string {
+  return str.length >= len ? str : str + ' '.repeat(len - str.length);
+}
+
+function groupByCategory(findings: CapabilityFinding[]): Map<CapabilityCategory, CapabilityFinding[]> {
+  const grouped = new Map<CapabilityCategory, CapabilityFinding[]>();
+  for (const f of findings) {
+    const arr = grouped.get(f.capability.category) || [];
+    arr.push(f);
+    grouped.set(f.capability.category, arr);
+  }
+  return grouped;
+}
+
+function formatEvidenceLine(e: { file: string; line: number; symbol: string; confidence: string }, indent: string): string {
+  const confColor = CONFIDENCE_COLORS[e.confidence] || CONFIDENCE_COLORS.medium;
+  const location = e.line > 0 ? `${e.file}:${e.line}` : e.file;
+  return `${indent}${confColor('●')} ${dim(location)}  ${bold(e.symbol)}`;
+}
+
+function dim(s: string): string { return `\x1b[2m${s}\x1b[0m`; }
+function bold(s: string): string { return `\x1b[1m${s}\x1b[0m`; }
+
+function formatPackage(pkg: PackageResult): string[] {
+  const lines: string[] = [];
+  const grouped = groupByCategory(pkg.capabilities);
+  lines.push(`  \x1b[33m●\x1b[0m ${bold(pkg.name)}@${dim(pkg.version)}`);
+
+  for (const [category, findings] of grouped) {
+    const icon = CATEGORY_ICONS[category];
+    const label = CATEGORY_LABELS[category];
+    lines.push(`     ${icon} ${bold(label)}`);
+
+    const byPermission = new Map<string, CapabilityFinding[]>();
+    for (const f of findings) {
+      const perm = f.capability.permission;
+      const arr = byPermission.get(perm) || [];
+      arr.push(f);
+      byPermission.set(perm, arr);
+    }
+
+    for (const [perm, permFindings] of byPermission) {
+      lines.push(`       ${dim(perm)}`);
+      for (const f of permFindings.slice(0, 3)) {
+        for (const e of f.evidence.slice(0, 2)) {
+          lines.push(formatEvidenceLine(e, '         '));
+        }
+      }
+      if (permFindings.length > 3) lines.push(dim(`         ... and ${permFindings.length - 3} more`));
+    }
+  }
+
+  return lines;
+}
+
+export function reportTerminal(result: ScanResult): string {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`${bold('\x1b[36mCapScan\x1b[0m')} ${dim('v0.1.0 — deterministic capability analysis engine')}`);
+  lines.push('');
+  lines.push(`${bold('Project:')} ${result.meta.scanPath}`);
+  lines.push(`${bold('Package Manager:')} ${result.meta.packageManager}`);
+  lines.push(`${bold('Dependencies:')} ${result.summary.totalPackages.toString()}`);
+  lines.push('');
+  lines.push(bold('\x1b[4mCapabilities\x1b[0m'));
+  lines.push(' ' + '─'.repeat(35));
+
+  for (const [cat, perms] of Object.entries(result.summary.capabilities)) {
+    const catLabel = CATEGORY_LABELS[cat as CapabilityCategory];
+    const icon = CATEGORY_ICONS[cat as CapabilityCategory];
+    const entries = Object.entries(perms).filter(([, c]) => c > 0);
+    if (entries.length === 0) continue;
+    lines.push(`  ${icon} ${bold(catLabel)}`);
+    for (const [perm, count] of entries) {
+      const dots = '.'.repeat(Math.max(0, 25 - perm.length));
+      const pkgText = count === 1 ? 'package' : 'packages';
+      lines.push(`    ${dim(perm)} ${dots} ${count.toString()} ${pkgText}`);
+    }
+  }
+
+  const packagesWithCaps = result.packages.filter(p => p.capabilities.length > 0);
+  if (packagesWithCaps.length > 0) {
+    lines.push('');
+    lines.push(bold('\x1b[4mPackages with Capabilities\x1b[0m'));
+    lines.push(' ' + '─'.repeat(35));
+    lines.push('');
+    for (const pkg of packagesWithCaps) {
+      lines.push(...formatPackage(pkg));
+      lines.push('');
+    }
+  }
+
+  lines.push(dim(` Scan completed at ${result.meta.timestamp}`));
+  lines.push('');
+  return lines.join('\n');
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: { index: 'src/index.ts' },
+  format: ['esm'],
+  clean: true,
+  sourcemap: true,
+  splitting: false,
+  banner: { js: '#!/usr/bin/env node' },
+});