vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/intent/auto-detect.js

@@ -0,0 +1,426 @@
+/**
+ * Auto-Detect Intent from Context
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * SEAMLESS INTENT - AUTO-DETECTION
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Automatically detect intent from:
+ * - Git branch name
+ * - Staged files
+ * - Recent commit messages
+ * - File patterns being modified
+ * 
+ * @module auto-detect
+ * @version 1.0.0
+ */
+
+"use strict";
+
+const path = require("path");
+const { execSync } = require("child_process");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INTENT INFERENCE FROM KEYWORDS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Intent type patterns - maps keywords to constraints
+ */
+const INTENT_PATTERNS = {
+  fix: {
+    type: "bugfix",
+    constraints: [
+      "No new features",
+      "Changes limited to specified file(s)",
+    ],
+  },
+  bug: {
+    type: "bugfix",
+    constraints: [
+      "No new features",
+      "Changes limited to specified file(s)",
+    ],
+  },
+  hotfix: {
+    type: "bugfix",
+    constraints: [
+      "No new features",
+      "Changes limited to specified file(s)",
+      "Minimal changes only",
+    ],
+  },
+  refactor: {
+    type: "refactor",
+    constraints: [
+      "No behavior changes",
+      "No new dependencies",
+    ],
+  },
+  feature: {
+    type: "feature",
+    constraints: [
+      "Tests required",
+    ],
+  },
+  add: {
+    type: "feature",
+    constraints: [
+      "Tests required",
+    ],
+  },
+  update: {
+    type: "update",
+    constraints: [],
+  },
+  style: {
+    type: "style",
+    constraints: [
+      "No behavior changes",
+      "UI/CSS only",
+    ],
+  },
+  docs: {
+    type: "docs",
+    constraints: [
+      "Documentation only",
+      "No code changes",
+    ],
+  },
+  test: {
+    type: "test",
+    constraints: [
+      "Test files only",
+    ],
+  },
+  security: {
+    type: "security",
+    constraints: [
+      "No permission relaxation",
+      "Review required",
+    ],
+  },
+  perf: {
+    type: "performance",
+    constraints: [
+      "No behavior changes",
+    ],
+  },
+  chore: {
+    type: "chore",
+    constraints: [],
+  },
+};
+
+/**
+ * Domain detection patterns
+ */
+const DOMAIN_PATTERNS = {
+  auth: ["auth", "login", "logout", "session", "jwt", "oauth", "password", "mfa"],
+  payments: ["payment", "stripe", "billing", "subscription", "checkout", "invoice"],
+  routes: ["route", "api", "endpoint", "router", "handler"],
+  database: ["database", "db", "prisma", "migration", "schema", "model"],
+  ui: ["component", "page", "ui", "style", "css", "button", "form", "modal"],
+  config: ["config", "env", "settings", "setup"],
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GIT CONTEXT HELPERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get current git branch name
+ * @param {string} projectRoot - Project root path
+ * @returns {string|null} Branch name or null
+ */
+function getGitBranch(projectRoot) {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return branch === "HEAD" ? null : branch;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get staged files
+ * @param {string} projectRoot - Project root path
+ * @returns {string[]} Array of staged file paths
+ */
+function getStagedFiles(projectRoot) {
+  try {
+    const output = execSync("git diff --cached --name-only", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get recently modified files (unstaged)
+ * @param {string} projectRoot - Project root path
+ * @returns {string[]} Array of modified file paths
+ */
+function getModifiedFiles(projectRoot) {
+  try {
+    const output = execSync("git diff --name-only", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get last commit message
+ * @param {string} projectRoot - Project root path
+ * @returns {string|null} Last commit message or null
+ */
+function getLastCommitMessage(projectRoot) {
+  try {
+    return execSync("git log -1 --pretty=%B", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INTENT INFERENCE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Parse branch name into intent components
+ * @param {string} branch - Branch name (e.g., "fix/login-bug", "feature/user-profile")
+ * @returns {object} Parsed intent
+ */
+function parseBranchName(branch) {
+  if (!branch) return null;
+  
+  // Common patterns: fix/xxx, feature/xxx, hotfix/xxx, etc.
+  const patterns = [
+    /^(fix|bug|hotfix|feature|feat|refactor|style|docs|test|chore|perf|security)[\/\-_](.+)$/i,
+    /^([a-z]+)[\/\-_](.+)$/i,
+  ];
+  
+  for (const pattern of patterns) {
+    const match = branch.match(pattern);
+    if (match) {
+      const type = match[1].toLowerCase();
+      const description = match[2]
+        .replace(/[-_]/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase();
+      
+      return {
+        type,
+        description,
+        summary: `${capitalizeFirst(type)}: ${description}`,
+      };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Infer intent type from summary text
+ * @param {string} summary - Intent summary
+ * @returns {object} Intent type info
+ */
+function inferTypeFromSummary(summary) {
+  const lower = summary.toLowerCase();
+  
+  for (const [keyword, info] of Object.entries(INTENT_PATTERNS)) {
+    if (lower.startsWith(keyword) || lower.includes(` ${keyword} `)) {
+      return info;
+    }
+  }
+  
+  // Default to general
+  return { type: "general", constraints: [] };
+}
+
+/**
+ * Detect domains from file paths
+ * @param {string[]} files - File paths
+ * @returns {string[]} Detected domains
+ */
+function detectDomainsFromFiles(files) {
+  const domains = new Set();
+  
+  for (const file of files) {
+    const lower = file.toLowerCase();
+    
+    for (const [domain, patterns] of Object.entries(DOMAIN_PATTERNS)) {
+      if (patterns.some(p => lower.includes(p))) {
+        domains.add(domain);
+      }
+    }
+  }
+  
+  return Array.from(domains);
+}
+
+/**
+ * Infer scope directories from files
+ * @param {string[]} files - File paths
+ * @returns {string[]} Common directories
+ */
+function inferScopeFromFiles(files) {
+  if (files.length === 0) return [];
+  
+  // Get unique directories
+  const dirs = new Set();
+  for (const file of files) {
+    const dir = path.dirname(file);
+    if (dir && dir !== ".") {
+      // Get top-level directory
+      const parts = dir.split(/[\/\\]/);
+      if (parts[0]) dirs.add(parts[0] + "/");
+      // Also add full path if different
+      if (parts.length > 1) dirs.add(dir + "/");
+    }
+  }
+  
+  return Array.from(dirs).slice(0, 5); // Limit to 5
+}
+
+/**
+ * Auto-detect intent from project context
+ * @param {string} projectRoot - Project root path
+ * @param {string} [userSummary] - Optional user-provided summary
+ * @returns {object} Inferred intent data
+ */
+function autoDetectIntent(projectRoot, userSummary = null) {
+  const context = {
+    branch: getGitBranch(projectRoot),
+    stagedFiles: getStagedFiles(projectRoot),
+    modifiedFiles: getModifiedFiles(projectRoot),
+    lastCommit: getLastCommitMessage(projectRoot),
+  };
+  
+  const files = [...context.stagedFiles, ...context.modifiedFiles];
+  const uniqueFiles = [...new Set(files)];
+  
+  // Determine summary
+  let summary = userSummary;
+  let typeInfo = null;
+  
+  if (summary) {
+    // User provided summary - infer type from it
+    typeInfo = inferTypeFromSummary(summary);
+  } else if (context.branch) {
+    // Try to parse from branch name
+    const branchInfo = parseBranchName(context.branch);
+    if (branchInfo) {
+      summary = branchInfo.summary;
+      typeInfo = INTENT_PATTERNS[branchInfo.type] || { type: branchInfo.type, constraints: [] };
+    }
+  }
+  
+  // Fallback summary
+  if (!summary) {
+    if (uniqueFiles.length > 0) {
+      const domains = detectDomainsFromFiles(uniqueFiles);
+      if (domains.length > 0) {
+        summary = `Modify ${domains.join(", ")} files`;
+      } else {
+        summary = `Modify ${uniqueFiles.length} file(s)`;
+      }
+    } else {
+      summary = "Code changes";
+    }
+    typeInfo = { type: "general", constraints: [] };
+  }
+  
+  // Build constraints
+  const constraints = typeInfo?.constraints || [];
+  
+  // Build allowed changes from files
+  const allowed_changes = uniqueFiles.map(file => ({
+    type: "file_modify",
+    target: file,
+  }));
+  
+  // Build scope
+  const scopeDirs = inferScopeFromFiles(uniqueFiles);
+  const scopeDomains = detectDomainsFromFiles(uniqueFiles);
+  
+  let scope = null;
+  if (scopeDirs.length > 0 || scopeDomains.length > 0) {
+    scope = {};
+    if (scopeDirs.length > 0) scope.directories = scopeDirs;
+    if (scopeDomains.length > 0) scope.domains = scopeDomains;
+  }
+  
+  return {
+    summary,
+    constraints,
+    allowed_changes: allowed_changes.length > 0 ? allowed_changes : undefined,
+    scope,
+    _context: {
+      branch: context.branch,
+      stagedFiles: context.stagedFiles.length,
+      modifiedFiles: context.modifiedFiles.length,
+      inferredType: typeInfo?.type,
+    },
+  };
+}
+
+/**
+ * Format a human-readable intent summary from branch name
+ * @param {string} branch - Branch name
+ * @returns {string} Formatted summary
+ */
+function formatBranchAsSummary(branch) {
+  const parsed = parseBranchName(branch);
+  if (parsed) return parsed.summary;
+  
+  // Fallback: just clean up the branch name
+  return branch
+    .replace(/[-_]/g, " ")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .replace(/\b\w/g, l => l.toUpperCase());
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  autoDetectIntent,
+  getGitBranch,
+  getStagedFiles,
+  getModifiedFiles,
+  getLastCommitMessage,
+  parseBranchName,
+  inferTypeFromSummary,
+  detectDomainsFromFiles,
+  inferScopeFromFiles,
+  formatBranchAsSummary,
+  INTENT_PATTERNS,
+  DOMAIN_PATTERNS,
+};

package/bin/runners/lib/agent-firewall/intent/index.js

@@ -0,0 +1,102 @@
+/**
+ * Intent Module - Entry Point
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * AGENT FIREWALL™ - INTENT DECLARATION SYSTEM
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * @module intent
+ * @version 2.0.0
+ */
+
+"use strict";
+
+const {
+  INTENT_SCHEMA,
+  createIntent,
+  computeIntentHash,
+  verifyIntentIntegrity,
+  updateIntent,
+  isIntentExpired,
+  createBlockingIntent,
+  CONSTRAINT_TYPES,
+  CONSTRAINT_TEMPLATES,
+} = require("./schema");
+
+const {
+  IntentStore,
+  SessionIntentTracker,
+  globalSessionTracker,
+} = require("./store");
+
+const {
+  checkAlignment,
+  checkAlignmentBatch,
+  isFileChangeAllowed,
+  isRouteAllowed,
+  isEnvVarAllowed,
+  isWithinScope,
+  isDomainAllowed,
+  checkConstraintViolations,
+  detectCodeQualityViolations,
+  VIOLATION_CODES,
+} = require("./alignment-engine");
+
+const {
+  autoDetectIntent,
+  getGitBranch,
+  getStagedFiles,
+  getModifiedFiles,
+  getLastCommitMessage,
+  parseBranchName,
+  inferTypeFromSummary,
+  detectDomainsFromFiles,
+  inferScopeFromFiles,
+  formatBranchAsSummary,
+  INTENT_PATTERNS,
+  DOMAIN_PATTERNS,
+} = require("./auto-detect");
+
+module.exports = {
+  // Schema
+  INTENT_SCHEMA,
+  createIntent,
+  computeIntentHash,
+  verifyIntentIntegrity,
+  updateIntent,
+  isIntentExpired,
+  createBlockingIntent,
+  CONSTRAINT_TYPES,
+  CONSTRAINT_TEMPLATES,
+  
+  // Storage
+  IntentStore,
+  SessionIntentTracker,
+  globalSessionTracker,
+  
+  // Alignment Engine
+  checkAlignment,
+  checkAlignmentBatch,
+  isFileChangeAllowed,
+  isRouteAllowed,
+  isEnvVarAllowed,
+  isWithinScope,
+  isDomainAllowed,
+  checkConstraintViolations,
+  detectCodeQualityViolations,
+  VIOLATION_CODES,
+  
+  // Auto-detect
+  autoDetectIntent,
+  getGitBranch,
+  getStagedFiles,
+  getModifiedFiles,
+  getLastCommitMessage,
+  parseBranchName,
+  inferTypeFromSummary,
+  detectDomainsFromFiles,
+  inferScopeFromFiles,
+  formatBranchAsSummary,
+  INTENT_PATTERNS,
+  DOMAIN_PATTERNS,
+};