vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/context/team-conventions.js

@@ -0,0 +1,336 @@
+/**
+ * Team Conventions Learning Module
+ * Learns individual developer styles from git blame
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+/**
+ * Execute git command safely
+ */
+function execGit(command, cwd = process.cwd()) {
+  try {
+    // Prepend 'git' if not already present (Windows compatibility)
+    const gitCommand = command.startsWith('git ') ? command : `git ${command}`;
+    
+    // Handle shell pipes on Windows - use shell: true for pipes
+    const hasPipe = gitCommand.includes('|');
+    if (hasPipe && process.platform === 'win32') {
+      // On Windows, use cmd.exe for pipes
+      return execSync(gitCommand, { cwd, encoding: "utf-8", shell: true }).trim();
+    }
+    
+    return execSync(gitCommand, { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Analyze author's coding style from git blame
+ */
+function analyzeAuthorStyle(author, projectPath, fileLimit = 20) {
+  // Get files touched by author (Windows-compatible: use git's built-in deduplication)
+  // Instead of shell pipes, use git format and deduplicate in JavaScript
+  const output = execGit(`log --author="${author}" --name-only --pretty=format:""`, projectPath);
+  if (!output) return null;
+  
+  // Deduplicate files in JavaScript (Windows-compatible)
+  const fileSet = new Set();
+  output.split("\n").forEach(line => {
+    const trimmed = line.trim();
+    if (trimmed) fileSet.add(trimmed);
+  });
+  
+  const files = Array.from(fileSet)
+    .filter(f => f && (f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx")))
+    .slice(0, fileLimit);
+  
+  const style = {
+    author,
+    filesAnalyzed: files.length,
+    patterns: {
+      imports: {},
+      naming: {
+        components: {},
+        functions: {},
+        variables: {},
+      },
+      formatting: {
+        semicolons: 0,
+        quotes: { single: 0, double: 0 },
+        trailingCommas: 0,
+      },
+      comments: {
+        jsdoc: 0,
+        inline: 0,
+        block: 0,
+      },
+      react: {
+        functional: 0,
+        class: 0,
+        hooks: [],
+      },
+      typescript: {
+        explicitTypes: 0,
+        interfaces: 0,
+        types: 0,
+      },
+    },
+  };
+  
+  for (const file of files) {
+    try {
+      const blameOutput = execGit(`blame --line-porcelain "${file}"`, projectPath);
+      if (!blameOutput) continue;
+      
+      const lines = blameOutput.split("\n");
+      let currentAuthor = null;
+      let code = "";
+      
+      for (const line of lines) {
+        if (line.startsWith(`author ${author}`)) {
+          currentAuthor = author;
+        } else if (line.startsWith("author ") && currentAuthor === author) {
+          currentAuthor = null;
+        } else if (line.startsWith("\t") && currentAuthor === author) {
+          code += line.slice(1) + "\n";
+        }
+      }
+      
+      // Analyze the collected code
+      analyzeCodeStyle(code, style);
+    } catch {}
+  }
+  
+  // Calculate percentages
+  const totalLines = style.patterns.formatting.semicolons + 
+                    style.patterns.formatting.quotes.single + 
+                    style.patterns.formatting.quotes.double;
+  
+  if (totalLines > 0) {
+    style.patterns.formatting.semiconPercentage = (style.patterns.formatting.semicolons / totalLines) * 100;
+    style.patterns.formatting.singleQuotePercentage = (style.patterns.formatting.quotes.single / totalLines) * 100;
+  }
+  
+  return style;
+}
+
+/**
+ * Analyze code patterns from content
+ */
+function analyzeCodeStyle(content, style) {
+  const lines = content.split("\n");
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    
+    // Import patterns
+    if (trimmed.startsWith("import ")) {
+      if (trimmed.includes(" { ")) {
+        style.patterns.imports.named = (style.patterns.imports.named || 0) + 1;
+      } else if (trimmed.includes(" * as ")) {
+        style.patterns.imports.namespace = (style.patterns.imports.namespace || 0) + 1;
+      } else {
+        style.patterns.imports.default = (style.patterns.imports.default || 0) + 1;
+      }
+    }
+    
+    // Naming patterns
+    if (trimmed.includes("function ") || trimmed.includes("const ")) {
+      if (/^[A-Z]/.test(trimmed)) {
+        style.patterns.naming.components.pascalCase = (style.patterns.naming.components.pascalCase || 0) + 1;
+      } else if (/^[a-z][A-Z]/.test(trimmed)) {
+        style.patterns.naming.functions.camelCase = (style.patterns.naming.functions.camelCase || 0) + 1;
+      }
+    }
+    
+    // Formatting
+    if (trimmed.endsWith(";")) {
+      style.patterns.formatting.semicolons++;
+    }
+    if (trimmed.includes("'")) {
+      style.patterns.formatting.quotes.single++;
+    }
+    if (trimmed.includes('"')) {
+      style.patterns.formatting.quotes.double++;
+    }
+    if (trimmed.includes(",") && !trimmed.includes(", ")) {
+      style.patterns.formatting.trailingCommas++;
+    }
+    
+    // Comments
+    if (trimmed.startsWith("/**") || trimmed.startsWith(" *")) {
+      style.patterns.comments.jsdoc++;
+    } else if (trimmed.startsWith("//")) {
+      style.patterns.comments.inline++;
+    } else if (trimmed.startsWith("/*")) {
+      style.patterns.comments.block++;
+    }
+    
+    // React patterns
+    if (trimmed.includes("function ") && /^[A-Z]/.test(trimmed)) {
+      style.patterns.react.functional++;
+    } else if (trimmed.includes("class ") && trimmed.includes("extends")) {
+      style.patterns.react.class++;
+    }
+    
+    // Hooks
+    const hookMatch = trimmed.match(/(use[A-Z]\w+)/);
+    if (hookMatch) {
+      if (!style.patterns.react.hooks.includes(hookMatch[1])) {
+        style.patterns.react.hooks.push(hookMatch[1]);
+      }
+    }
+    
+    // TypeScript
+    if (trimmed.includes(": ")) {
+      style.patterns.typescript.explicitTypes++;
+    }
+    if (trimmed.includes("interface ")) {
+      style.patterns.typescript.interfaces++;
+    }
+    if (trimmed.includes("type ")) {
+      style.patterns.typescript.types++;
+    }
+  }
+}
+
+/**
+ * Get team conventions summary
+ */
+function getTeamConventions(projectPath) {
+  // Get unique authors (Windows-compatible: deduplicate in JavaScript)
+  const authorsRaw = execGit("log --format='%an'", projectPath);
+  if (!authorsRaw) return null;
+  
+  // Deduplicate authors in JavaScript (Windows-compatible)
+  const authorsSet = new Set();
+  authorsRaw.split("\n").forEach(line => {
+    const trimmed = line.trim();
+    if (trimmed) authorsSet.add(trimmed);
+  });
+  
+  const authors = Array.from(authorsSet).filter(a => a && a !== "GitHub Actions");
+  const conventions = {
+    authors: [],
+    commonPatterns: {
+      imports: {},
+      formatting: {
+        semicolons: { with: 0, without: 0 },
+        quotes: { single: 0, double: 0 },
+      },
+      naming: {
+        components: "PascalCase",
+        functions: "camelCase",
+      },
+    },
+    recommendations: [],
+  };
+  
+  // Analyze top contributors
+  for (const author of authors.slice(0, 5)) {
+    const style = analyzeAuthorStyle(author, projectPath, 10);
+    if (style) {
+      conventions.authors.push({
+        name: author,
+        filesContributed: style.filesAnalyzed,
+        patterns: style.patterns,
+      });
+    }
+  }
+  
+  // Find common patterns
+  if (conventions.authors.length > 0) {
+    // Import preferences
+    const importCounts = { named: 0, default: 0, namespace: 0 };
+    for (const author of conventions.authors) {
+      importCounts.named += author.patterns.imports.named || 0;
+      importCounts.default += author.patterns.imports.default || 0;
+      importCounts.namespace += author.patterns.imports.namespace || 0;
+    }
+    
+    const totalImports = importCounts.named + importCounts.default + importCounts.namespace;
+    if (totalImports > 0) {
+      if (importCounts.named / totalImports > 0.5) {
+        conventions.commonPatterns.imports.preferred = "named imports";
+      } else if (importCounts.default / totalImports > 0.5) {
+        conventions.commonPatterns.imports.preferred = "default imports";
+      }
+    }
+    
+    // Formatting preferences
+    for (const author of conventions.authors) {
+      if (author.patterns.formatting.semiconPercentage > 70) {
+        conventions.commonPatterns.formatting.semicons.with++;
+      } else {
+        conventions.commonPatterns.formatting.semicons.without++;
+      }
+      
+      if (author.patterns.formatting.singleQuotePercentage > 70) {
+        conventions.commonPatterns.formatting.quotes.single++;
+      } else {
+        conventions.commonPatterns.formatting.quotes.double++;
+      }
+    }
+    
+    // Generate recommendations
+    if (conventions.commonPatterns.formatting.semicons.with > conventions.commonPatterns.formatting.semicons.without) {
+      conventions.recommendations.push("Use semicolons consistently (team preference)");
+    }
+    
+    if (conventions.commonPatterns.formatting.quotes.single > conventions.commonPatterns.formatting.quotes.double) {
+      conventions.recommendations.push("Use single quotes for strings (team preference)");
+    }
+  }
+  
+  return conventions;
+}
+
+/**
+ * Generate team conventions report
+ */
+function generateTeamReport(projectPath) {
+  const conventions = getTeamConventions(projectPath);
+  if (!conventions) {
+    return {
+      available: false,
+      message: "No git history found",
+    };
+  }
+  
+  const report = {
+    available: true,
+    summary: {
+      teamSize: conventions.authors.length,
+      totalFilesAnalyzed: conventions.authors.reduce((sum, a) => sum + a.filesContributed, 0),
+    },
+    conventions: conventions.commonPatterns,
+    contributors: conventions.authors.map(a => ({
+      name: a.name,
+      filesContributed: a.filesContributed,
+      style: {
+        imports: a.patterns.imports,
+        formatting: {
+          usesSemicolons: a.patterns.formatting.semiconPercentage > 70,
+          prefersSingleQuotes: a.patterns.formatting.singleQuotePercentage > 70,
+        },
+        typescript: {
+          usesExplicitTypes: a.patterns.typescript.explicitTypes > 0,
+          prefersInterfaces: a.patterns.typescript.interfaces > a.patterns.typescript.types,
+        },
+      },
+    })),
+    recommendations: conventions.recommendations,
+  };
+  
+  return report;
+}
+
+module.exports = {
+  analyzeAuthorStyle,
+  getTeamConventions,
+  generateTeamReport,
+};

package/bin/runners/lib/__tests__/entitlements-v2.test.js

@@ -0,0 +1,295 @@
+/**
+ * Entitlements v2 Tests - Tier Enforcement Verification
+ * 
+ * These tests verify:
+ * 1. No bypass via env vars (VIBECHECK_SKIP_AUTH, VIBECHECK_OWNER, etc.)
+ * 2. Correct tier gating for each command/feature
+ * 3. Proper exit codes (3 = feature not allowed)
+ * 4. Downgrade behaviors work correctly
+ * 5. Help output shows correct tier labels
+ */
+
+const {
+  getTier,
+  getLimits,
+  enforce,
+  checkCommand,
+  tierMeetsMinimum,
+  getMinTierForFeature,
+  tierHasFeature,
+  TIERS,
+  ENTITLEMENTS,
+  LIMITS,
+  EXIT_FEATURE_NOT_ALLOWED,
+  EXIT_MISCONFIG,
+} = require("../entitlements-v2");
+
+describe("Entitlements v2 - Tier Enforcement", () => {
+  // Store original env
+  const originalEnv = { ...process.env };
+  
+  beforeEach(() => {
+    // Reset env before each test
+    process.env = { ...originalEnv };
+    // Clear any env vars that might bypass
+    delete process.env.VIBECHECK_SKIP_AUTH;
+    delete process.env.VIBECHECK_OWNER;
+    delete process.env.VIBECHECK_DEMO;
+    delete process.env.OWNER_MODE;
+  });
+  
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe("No Bypass Tests", () => {
+    test("VIBECHECK_SKIP_AUTH does NOT grant paid features", async () => {
+      process.env.VIBECHECK_SKIP_AUTH = "1";
+      
+      // prove is PRO-only
+      const result = await enforce("prove", { silent: true });
+      expect(result.allowed).toBe(false);
+      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+    });
+
+    test("VIBECHECK_OWNER does NOT grant paid features", async () => {
+      process.env.VIBECHECK_OWNER = "1";
+      
+      const result = await enforce("prove", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("VIBECHECK_DEMO does NOT grant paid features", async () => {
+      process.env.VIBECHECK_DEMO = "1";
+      
+      const result = await enforce("ai-test", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("OWNER_MODE does NOT grant paid features", async () => {
+      process.env.OWNER_MODE = "true";
+      
+      const result = await enforce("share", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("Offline mode defaults to FREE tier (no escalation)", async () => {
+      // Without API key, should be FREE
+      const tier = await getTier({});
+      expect(tier).toBe("free");
+    });
+  });
+
+  describe("Tier Matrix Compliance", () => {
+    describe("FREE tier commands", () => {
+      const freeCommands = [
+        "scan", "ship", "install", "init", "doctor", "status", "watch",
+        "ctx", "guard", "context", "mdc", "login", "logout", "whoami", "labs"
+      ];
+
+      test.each(freeCommands)("%s is allowed on FREE tier", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+    });
+
+    describe("STARTER tier commands", () => {
+      const starterCommands = ["gate", "launch", "pr", "badge", "mcp"];
+
+      test.each(starterCommands)("%s requires STARTER+ (blocked on FREE)", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        // Without API key = FREE tier = should be blocked
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+      });
+    });
+
+    describe("PRO tier commands", () => {
+      const proCommands = ["prove", "share", "ai-test"];
+
+      test.each(proCommands)("%s requires PRO (blocked on FREE/STARTER)", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+      });
+    });
+
+    describe("Subfeature gating", () => {
+      test("fix.plan_only is FREE", async () => {
+        const result = await enforce("fix.plan_only", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("fix.apply_patches requires PRO", async () => {
+        const result = await enforce("fix.apply_patches", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+
+      test("reality.preview is FREE", async () => {
+        const result = await enforce("reality.preview", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("reality.full requires STARTER", async () => {
+        const result = await enforce("reality.full", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+      });
+
+      test("reality.advanced_auth_boundary requires PRO", async () => {
+        const result = await enforce("reality.advanced_auth_boundary", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+
+      test("report.html_md is FREE", async () => {
+        const result = await enforce("report.html_md", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("report.sarif_csv requires STARTER", async () => {
+        const result = await enforce("report.sarif_csv", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+      });
+
+      test("report.compliance_packs requires PRO", async () => {
+        const result = await enforce("report.compliance_packs", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+    });
+  });
+
+  describe("Downgrade Behaviors", () => {
+    test("reality downgrades to reality.preview on FREE", async () => {
+      const result = await enforce("reality", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("reality.preview");
+      expect(result.caps).toBeDefined();
+    });
+
+    test("fix downgrades to fix.plan_only on FREE", async () => {
+      const result = await enforce("fix", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("fix.plan_only");
+    });
+
+    test("report downgrades to report.html_md on FREE", async () => {
+      const result = await enforce("report", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("report.html_md");
+    });
+  });
+
+  describe("Exit Codes", () => {
+    test("Returns EXIT_FEATURE_NOT_ALLOWED (3) for blocked features", async () => {
+      const result = await enforce("prove", { silent: true });
+      expect(result.exitCode).toBe(3);
+      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+    });
+
+    test("Returns EXIT_MISCONFIG (4) for unknown features", async () => {
+      const result = await enforce("nonexistent_feature", { silent: true });
+      expect(result.exitCode).toBe(4);
+      expect(result.exitCode).toBe(EXIT_MISCONFIG);
+    });
+  });
+
+  describe("Limits by Tier", () => {
+    test("FREE tier has correct limits", () => {
+      const limits = getLimits("free");
+      expect(limits.realityMaxPages).toBe(5);
+      expect(limits.realityMaxClicks).toBe(20);
+      expect(limits.realityAuthBoundary).toBe(false);
+      expect(limits.reportFormats).toEqual(["html", "md"]);
+      expect(limits.fixApplyPatches).toBe(false);
+    });
+
+    test("STARTER tier has expanded limits", () => {
+      const limits = getLimits("starter");
+      expect(limits.realityMaxPages).toBe(50);
+      expect(limits.realityAuthBoundary).toBe(true);
+      expect(limits.reportFormats).toContain("sarif");
+      expect(limits.reportFormats).toContain("csv");
+      expect(limits.fixApplyPatches).toBe(false);
+    });
+
+    test("PRO tier has full access", () => {
+      const limits = getLimits("pro");
+      expect(limits.realityMaxPages).toBe(-1); // unlimited
+      expect(limits.realityAdvancedAuth).toBe(true);
+      expect(limits.reportFormats).toContain("compliance");
+      expect(limits.fixApplyPatches).toBe(true);
+    });
+  });
+
+  describe("Tier Comparison Helpers", () => {
+    test("tierMeetsMinimum works correctly", () => {
+      expect(tierMeetsMinimum("free", "free")).toBe(true);
+      expect(tierMeetsMinimum("free", "starter")).toBe(false);
+      expect(tierMeetsMinimum("starter", "free")).toBe(true);
+      expect(tierMeetsMinimum("starter", "starter")).toBe(true);
+      expect(tierMeetsMinimum("starter", "pro")).toBe(false);
+      expect(tierMeetsMinimum("pro", "starter")).toBe(true);
+      expect(tierMeetsMinimum("pro", "pro")).toBe(true);
+      expect(tierMeetsMinimum("enterprise", "pro")).toBe(true);
+    });
+
+    test("getMinTierForFeature returns correct tier", () => {
+      expect(getMinTierForFeature("scan")).toBe("free");
+      expect(getMinTierForFeature("gate")).toBe("starter");
+      expect(getMinTierForFeature("prove")).toBe("pro");
+      expect(getMinTierForFeature("unknown")).toBe("enterprise");
+    });
+
+    test("tierHasFeature returns correct boolean", () => {
+      expect(tierHasFeature("free", "scan")).toBe(true);
+      expect(tierHasFeature("free", "gate")).toBe(false);
+      expect(tierHasFeature("starter", "gate")).toBe(true);
+      expect(tierHasFeature("starter", "prove")).toBe(false);
+      expect(tierHasFeature("pro", "prove")).toBe(true);
+    });
+  });
+
+  describe("ENTITLEMENTS Matrix Validation", () => {
+    test("All required commands are defined", () => {
+      const requiredCommands = [
+        "scan", "ship", "reality", "prove", "fix", "report",
+        "install", "init", "doctor", "status", "watch", "launch",
+        "ctx", "guard", "context", "mdc",
+        "gate", "pr", "badge", "mcp", "share", "ai-test",
+        "login", "logout", "whoami", "labs"
+      ];
+
+      for (const cmd of requiredCommands) {
+        expect(ENTITLEMENTS[cmd]).toBeDefined();
+        expect(ENTITLEMENTS[cmd].minTier).toBeDefined();
+      }
+    });
+
+    test("All tiers are valid", () => {
+      for (const [feature, def] of Object.entries(ENTITLEMENTS)) {
+        expect(TIERS[def.minTier]).toBeDefined();
+      }
+    });
+  });
+});
+
+describe("CLI Help Tier Labels", () => {
+  test("TIERS constant has correct pricing", () => {
+    expect(TIERS.free.price).toBe(0);
+    expect(TIERS.starter.price).toBe(29);
+    expect(TIERS.pro.price).toBe(99);
+    expect(TIERS.enterprise.price).toBe(499);
+  });
+
+  test("TIERS constant has correct order", () => {
+    expect(TIERS.free.order).toBeLessThan(TIERS.starter.order);
+    expect(TIERS.starter.order).toBeLessThan(TIERS.pro.order);
+    expect(TIERS.pro.order).toBeLessThan(TIERS.enterprise.order);
+  });
+});