@quantracode/vibecheck 0.0.1

package/dist/commands/intent.js

@@ -0,0 +1,192 @@
+/**
+ * Intent Command
+ *
+ * Generates a security intent map baseline for the codebase.
+ * Useful for tracking drift over time.
+ */
+import path from "node:path";
+import { ARTIFACT_VERSION } from "@vibecheck/schema";
+import { writeFileSync, resolvePath } from "../utils/file-utils.js";
+import { hashPath } from "../utils/fingerprint.js";
+import { getGitInfo, getRepoName } from "../utils/git-info.js";
+import { buildScanContext } from "../scanners/index.js";
+import { buildRouteMap, buildMiddlewareMap, buildAllProofTraces, calculateCoverage, mineAllIntentClaims, } from "../phase3/index.js";
+/**
+ * Execute the intent command
+ */
+export async function executeIntent(targetDir, options) {
+    const absoluteTarget = resolvePath(targetDir);
+    console.log(`Mining intent map: ${absoluteTarget}`);
+    const startTime = Date.now();
+    // Build scan context
+    console.log("Building scan context...");
+    const context = await buildScanContext(absoluteTarget);
+    console.log(`Found ${context.fileIndex.allSourceFiles.length} source files`);
+    // Build Phase 3 maps
+    console.log("\nBuilding route map...");
+    const routeMap = buildRouteMap(context);
+    console.log(`  Found ${routeMap.length} routes`);
+    console.log("Building middleware map...");
+    const middlewareMap = buildMiddlewareMap(context);
+    console.log(`  Found ${middlewareMap.length} middleware configurations`);
+    console.log("Mining intent claims...");
+    const intentMap = mineAllIntentClaims(context, routeMap);
+    console.log(`  Found ${intentMap.length} intent claims`);
+    console.log("Building proof traces...");
+    const proofTraces = buildAllProofTraces(context, routeMap);
+    console.log(`  Built ${proofTraces.size} proof traces`);
+    console.log("Calculating coverage...");
+    const coverage = calculateCoverage(routeMap, proofTraces, middlewareMap);
+    const endTime = Date.now();
+    console.log(`\nCompleted in ${endTime - startTime}ms`);
+    // Create artifact
+    const artifact = createIntentArtifact(routeMap, middlewareMap, intentMap, proofTraces, coverage, absoluteTarget, options.repoName);
+    // Determine output path
+    let outputPath = options.out;
+    if (!path.isAbsolute(outputPath)) {
+        outputPath = resolvePath(absoluteTarget, outputPath);
+    }
+    // Write artifact
+    if (options.format === "json") {
+        writeFileSync(outputPath, JSON.stringify(artifact, null, 2));
+        console.log(`\nIntent map written to: ${outputPath}`);
+    }
+    // Print summary
+    printIntentSummary(artifact);
+    return 0;
+}
+/**
+ * Create intent map artifact
+ */
+function createIntentArtifact(routeMap, middlewareMap, intentMap, proofTraces, coverage, targetDir, repoName) {
+    const gitInfo = getGitInfo(targetDir);
+    const name = repoName ?? getRepoName(targetDir);
+    // Convert proofTraces Map to schema format
+    const proofTracesRecord = {};
+    for (const [key, value] of proofTraces) {
+        proofTracesRecord[key] = {
+            summary: value.authProven
+                ? "Auth proven"
+                : value.middlewareCovered
+                    ? "Protected by middleware"
+                    : "No protection proven",
+            nodes: value.steps.map((step) => ({
+                kind: "handler",
+                label: step.label,
+                file: step.file,
+                line: step.line,
+            })),
+        };
+    }
+    // Build middleware coverage
+    const allMatchers = middlewareMap.flatMap((m) => m.matchers);
+    const middlewareCoverage = routeMap.map((route) => {
+        const isRouteCovered = allMatchers.some((matcher) => {
+            const pattern = matcher.replace(/\*/g, ".*").replace(/\/:path\*/g, "/.*");
+            try {
+                return new RegExp(`^${pattern}`).test(route.path);
+            }
+            catch {
+                return route.path.startsWith(matcher.replace(/\/:path\*$/, ""));
+            }
+        });
+        return {
+            routeId: route.routeId,
+            covered: isRouteCovered,
+        };
+    });
+    // Calculate summary stats
+    const intentsByType = {};
+    const intentsBySource = {};
+    for (const intent of intentMap) {
+        intentsByType[intent.type] = (intentsByType[intent.type] || 0) + 1;
+        intentsBySource[intent.source] = (intentsBySource[intent.source] || 0) + 1;
+    }
+    return {
+        artifactVersion: ARTIFACT_VERSION,
+        generatedAt: new Date().toISOString(),
+        tool: {
+            name: "vibecheck",
+            version: "0.0.1",
+        },
+        repo: {
+            name,
+            rootPathHash: hashPath(targetDir),
+            git: gitInfo,
+        },
+        routeMap: { routes: routeMap },
+        middlewareMap: {
+            middlewareFile: middlewareMap[0]?.file,
+            matcher: allMatchers,
+            coverage: middlewareCoverage,
+        },
+        intentMap: { intents: intentMap },
+        proofTraces: proofTracesRecord,
+        coverage,
+        summary: {
+            totalRoutes: routeMap.length,
+            totalIntents: intentMap.length,
+            authCoveragePercent: Math.round(coverage.authCoverage * 100),
+            validationCoveragePercent: Math.round(coverage.validationCoverage * 100),
+            middlewareCoveragePercent: Math.round(coverage.middlewareCoverage * 100),
+            intentsByType,
+            intentsBySource,
+        },
+    };
+}
+/**
+ * Print intent map summary
+ */
+function printIntentSummary(artifact) {
+    const { summary, coverage } = artifact;
+    console.log("\n" + "=".repeat(60));
+    console.log("VibeCheck Intent Map Generated");
+    console.log("=".repeat(60));
+    console.log(`\nRoutes discovered: ${summary.totalRoutes}`);
+    console.log(`Intent claims found: ${summary.totalIntents}`);
+    console.log("\nCoverage metrics:");
+    console.log(`  Auth coverage: ${formatPercent(coverage.authCoverage)}`);
+    console.log(`  Validation coverage: ${formatPercent(coverage.validationCoverage)}`);
+    console.log(`  Middleware coverage: ${formatPercent(coverage.middlewareCoverage)}`);
+    if (summary.totalIntents > 0) {
+        console.log("\nIntents by type:");
+        for (const [type, count] of Object.entries(summary.intentsByType)) {
+            console.log(`  ${type}: ${count}`);
+        }
+        console.log("\nIntents by source:");
+        for (const [source, count] of Object.entries(summary.intentsBySource)) {
+            console.log(`  ${source}: ${count}`);
+        }
+    }
+    console.log("");
+}
+/**
+ * Format percentage with color
+ */
+function formatPercent(value) {
+    const percent = Math.round(value * 100);
+    let color = "\x1b[32m"; // Green
+    if (percent < 50) {
+        color = "\x1b[31m"; // Red
+    }
+    else if (percent < 80) {
+        color = "\x1b[33m"; // Yellow
+    }
+    return `${color}${percent}%\x1b[0m`;
+}
+/**
+ * Register intent command with commander
+ */
+export function registerIntentCommand(program) {
+    program
+        .command("intent [target]")
+        .description("Generate security intent map baseline")
+        .option("-o, --out <path>", "Output file path", "vibecheck-artifacts/intent-map.json")
+        .option("-f, --format <format>", "Output format", "json")
+        .option("--repo-name <name>", "Override repository name")
+        .action(async (target, options) => {
+        const targetDir = target ?? process.cwd();
+        const exitCode = await executeIntent(targetDir, options);
+        process.exit(exitCode);
+    });
+}

package/dist/commands/scan.d.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import { type Severity } from "@vibecheck/schema";
+/**
+ * Valid output formats
+ */
+export type OutputFormat = "json" | "sarif" | "both";
+/**
+ * Valid fail-on thresholds
+ */
+export type FailThreshold = "off" | Severity;
+/**
+ * Scan command options
+ */
+export interface ScanOptions {
+    /** Output file/directory path */
+    out: string;
+    /** Output format: json, sarif, or both */
+    format: OutputFormat;
+    /** Override repository name */
+    repoName?: string;
+    /** Fail threshold: off, info, low, medium, high, critical */
+    failOn: FailThreshold;
+    /** Only scan changed files (not implemented) */
+    changed: boolean;
+    /** Include route map in output (default: true) */
+    emitRouteMap: boolean;
+    /** Include intent claims in output (default: true) */
+    emitIntents: boolean;
+    /** Include proof traces in output (default: true) */
+    emitTraces: boolean;
+    /** Additional glob patterns to exclude */
+    exclude: string[];
+    /** Include test files in scan */
+    includeTests: boolean;
+}
+/**
+ * Execute the scan command
+ */
+export declare function executeScan(targetDir: string, options: ScanOptions): Promise<number>;
+/**
+ * Register scan command with commander
+ */
+export declare function registerScanCommand(program: Command): void;
+//# sourceMappingURL=scan.d.ts.map

package/dist/commands/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/commands/scan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,mBAAmB,CAAC;AA0B3B;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,MAAM,EAAE,YAAY,CAAC;IACrB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,MAAM,EAAE,aAAa,CAAC;IACtB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,YAAY,EAAE,OAAO,CAAC;IACtB,sDAAsD;IACtD,WAAW,EAAE,OAAO,CAAC;IACrB,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iCAAiC;IACjC,YAAY,EAAE,OAAO,CAAC;CACvB;AA0VD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,CAwMjB;AASD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkH1D"}