avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/context-budget-scanner.js

@@ -0,0 +1,257 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const SKIP_DIRS = new Set([
+  ".git", "node_modules", "dist", "build", "coverage", ".next",
+  "vendor", "target", "tmp", "temp", "out", ".turbo", ".cache",
+]);
+
+const SENSITIVE_NAMES = [
+  ".env", "credentials", "secret", "private_key", "privatekey",
+  "api_key", "apikey", "api-key", "token", "password", "passwd",
+  "auth_token", "authtoken", "access_token",
+];
+
+const LOCKFILE_NAMES = new Set([
+  "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+  "composer.lock", "Gemfile.lock", "poetry.lock",
+  "Cargo.lock", "go.sum",
+]);
+
+const BINARY_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp",
+  ".woff", ".woff2", ".ttf", ".eot", ".otf",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv", ".webm",
+  ".zip", ".tar", ".gz", ".7z", ".rar", ".tgz",
+  ".pdf", ".exe", ".dll", ".so", ".dylib", ".bin", ".dat",
+  ".db", ".sqlite", ".sqlite3",
+  ".class", ".jar", ".war", ".ear",
+  ".pyc", ".pyo",
+]);
+
+const SOURCE_EXTS = new Set([
+  ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs",
+  ".py", ".rb", ".go", ".rs", ".java",
+  ".c", ".cpp", ".cc", ".h", ".hpp", ".hh",
+  ".cs", ".php", ".swift", ".kt", ".scala",
+  ".sh", ".bash", ".zsh", ".fish", ".ps1",
+  ".vue", ".svelte",
+]);
+
+const CONFIG_EXTS = new Set([
+  ".json", ".yaml", ".yml", ".toml", ".ini",
+  ".cfg", ".conf", ".xml", ".env",
+]);
+
+const DOC_EXTS = new Set([
+  ".md", ".txt", ".rst", ".adoc", ".asciidoc", ".rtf",
+]);
+
+const TEST_NAME_PATTERNS = [
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/,
+  /\.test\.py$/,
+  /\.spec\.py$/,
+];
+
+const TEST_PATH_PATTERNS = [
+  /(?:^|\/)tests?\//,
+  /(?:^|\/)__tests__\//,
+  /(?:^|\/)test\//,
+  /(?:^|\/)spec\//,
+];
+
+const LARGE_FILE_TOKEN_THRESHOLD = 10000; // ~40 KB
+const LARGE_FOLDER_TOKEN_THRESHOLD = 20000;
+
+function estimateTokens(byteCount) {
+  return Math.ceil(byteCount / 4);
+}
+
+function isSensitivePath(relPath) {
+  const base = path.basename(relPath).toLowerCase();
+  return SENSITIVE_NAMES.some((s) => base.includes(s));
+}
+
+function isLockfile(relPath) {
+  return LOCKFILE_NAMES.has(path.basename(relPath));
+}
+
+function isLogFile(relPath) {
+  const base = path.basename(relPath).toLowerCase();
+  return base.endsWith(".log") || base.endsWith(".log.txt");
+}
+
+function isBinaryExt(relPath) {
+  const ext = path.extname(relPath).toLowerCase();
+  return BINARY_EXTS.has(ext);
+}
+
+function isTestFile(relPath) {
+  const normalized = relPath.replace(/\\/g, "/");
+  return (
+    TEST_NAME_PATTERNS.some((p) => p.test(normalized)) ||
+    TEST_PATH_PATTERNS.some((p) => p.test(normalized))
+  );
+}
+
+function classifyFile(relPath, byteCount, maxFileBytes) {
+  if (isSensitivePath(relPath)) {
+    return { kind: "sensitive", reasonCodes: ["sensitive_context"] };
+  }
+  if (isBinaryExt(relPath)) {
+    return { kind: "binary", reasonCodes: ["binary_or_unknown"] };
+  }
+  if (isLockfile(relPath)) {
+    return { kind: "lockfile", reasonCodes: ["lockfile"] };
+  }
+  if (isLogFile(relPath)) {
+    return { kind: "log", reasonCodes: ["log_file"] };
+  }
+  if (byteCount > maxFileBytes) {
+    return { kind: "too_large", reasonCodes: ["too_large_to_read"] };
+  }
+
+  const ext = path.extname(relPath).toLowerCase();
+  const codes = [];
+
+  if (SOURCE_EXTS.has(ext)) codes.push("source_file");
+  else if (CONFIG_EXTS.has(ext)) codes.push("config_file");
+  else if (DOC_EXTS.has(ext)) codes.push("documentation_file");
+  else codes.push("binary_or_unknown");
+
+  if (isTestFile(relPath)) codes.push("test_file");
+
+  const tokens = estimateTokens(byteCount);
+  if (tokens >= LARGE_FILE_TOKEN_THRESHOLD) {
+    codes.push("large_file");
+  } else {
+    codes.push("small_enough");
+  }
+
+  return { kind: "regular", reasonCodes: codes };
+}
+
+function getSkipDirInfo(dirName) {
+  if (dirName === "node_modules" || dirName === "vendor") {
+    return { reasonCodes: ["dependency_folder"], recommendation: "skip" };
+  }
+  return { reasonCodes: ["generated_or_build_artifact"], recommendation: "ignore_generated" };
+}
+
+function scanRepo(cwd, config = {}) {
+  const maxFilesScanned = Number.isFinite(Number(config.maxFilesScanned))
+    ? Math.max(1, Number(config.maxFilesScanned)) : 2000;
+  const maxFileBytes = Number.isFinite(Number(config.maxFileBytes))
+    ? Math.max(1024, Number(config.maxFileBytes)) : 1000000;
+  const maxDepth = Number.isFinite(Number(config.maxDepth))
+    ? Math.max(1, Number(config.maxDepth)) : 12;
+
+  const fileEntries = [];
+  const skippedDirs = [];
+  let scannedFiles = 0;
+  let skippedFiles = 0;
+
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    if (scannedFiles >= maxFilesScanned) return;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (scannedFiles >= maxFilesScanned) break;
+
+      const absPath = path.join(dir, entry.name);
+      const relPath = path.relative(cwd, absPath).replace(/\\/g, "/");
+
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) {
+          const info = getSkipDirInfo(entry.name);
+          skippedDirs.push({
+            path: relPath,
+            type: "folder",
+            estimatedTokens: 0,
+            reasonCodes: info.reasonCodes,
+            recommendation: info.recommendation,
+          });
+          skippedFiles++;
+          continue;
+        }
+        walk(absPath, depth + 1);
+        continue;
+      }
+
+      if (!entry.isFile()) continue;
+
+      let byteCount = 0;
+      try {
+        byteCount = fs.statSync(absPath).size;
+      } catch {
+        skippedFiles++;
+        continue;
+      }
+
+      const classification = classifyFile(relPath, byteCount, maxFileBytes);
+      const estimatedTokens = estimateTokens(byteCount);
+
+      fileEntries.push({
+        path: relPath,
+        type: "file",
+        byteCount,
+        estimatedTokens,
+        reasonCodes: classification.reasonCodes,
+        kind: classification.kind,
+      });
+      scannedFiles++;
+    }
+  }
+
+  walk(cwd, 0);
+
+  const folderAggregates = {};
+  for (const f of fileEntries) {
+    const parts = f.path.split("/");
+    for (let i = 1; i < parts.length; i++) {
+      const folderPath = parts.slice(0, i).join("/");
+      if (!folderAggregates[folderPath]) {
+        folderAggregates[folderPath] = { path: folderPath, estimatedTokens: 0, fileCount: 0 };
+      }
+      folderAggregates[folderPath].estimatedTokens += f.estimatedTokens;
+      folderAggregates[folderPath].fileCount++;
+    }
+  }
+
+  const largeFolders = Object.values(folderAggregates)
+    .filter((f) => f.estimatedTokens >= LARGE_FOLDER_TOKEN_THRESHOLD)
+    .sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+
+  return {
+    fileEntries,
+    skippedDirs,
+    folderAggregates,
+    largeFolders,
+    scannedFiles,
+    skippedFiles: skippedFiles + skippedDirs.length,
+  };
+}
+
+module.exports = {
+  scanRepo,
+  estimateTokens,
+  classifyFile,
+  isSensitivePath,
+  isLockfile,
+  isLogFile,
+  isTestFile,
+  isBinaryExt,
+  SKIP_DIRS,
+  LARGE_FILE_TOKEN_THRESHOLD,
+  LARGE_FOLDER_TOKEN_THRESHOLD,
+};

package/scripts/lib/context-budget.js

@@ -0,0 +1,167 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const { safeReadJson } = require("./fsx");
+
+const BUDGET_CLASSES = ["small", "medium", "large", "oversized", "unknown"];
+
+const STATE_DIRS = [
+  ".claude/cco/state",
+  ".claude/cco/reports",
+  ".claude/cco/security",
+  ".claude/cco/events",
+  ".claude/cco/memory",
+  ".claude/cco/orchestration",
+  ".claude/cco/evidence",
+];
+
+const NOISE_PATTERNS = [
+  /\.log$/i,
+  /\.tmp$/i,
+  /\.bak$/i,
+  /node_modules/,
+  /\.next\//,
+  /dist\//,
+  /build\//,
+  /coverage\//,
+];
+
+function countJsonFiles(cwd, relDir) {
+  const abs = path.join(cwd, relDir);
+  try {
+    return fs.readdirSync(abs).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).length;
+  } catch {
+    return 0;
+  }
+}
+
+function estimateStateArtifacts(cwd) {
+  let total = 0;
+  let totalBytes = 0;
+  for (const dir of STATE_DIRS) {
+    const abs = path.join(cwd, dir);
+    try {
+      const entries = fs.readdirSync(abs, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile()) {
+          total++;
+          try {
+            totalBytes += fs.statSync(path.join(abs, e.name)).size;
+          } catch {}
+        } else if (e.isDirectory()) {
+          try {
+            const sub = fs.readdirSync(path.join(abs, e.name));
+            total += sub.length;
+            for (const sf of sub) {
+              try {
+                totalBytes += fs.statSync(path.join(abs, e.name, sf)).size;
+              } catch {}
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return { count: total, bytes: totalBytes };
+}
+
+function detectDuplicateContextRefs(changedFiles) {
+  const seen = new Map();
+  let dupes = 0;
+  for (const f of changedFiles || []) {
+    const base = path.basename(f);
+    if (seen.has(base)) dupes++;
+    else seen.set(base, f);
+  }
+  return dupes;
+}
+
+function detectStaleArtifacts(cwd) {
+  const stale = [];
+  const now = Date.now();
+  const maxAge = 7 * 24 * 60 * 60 * 1000;
+  for (const dir of STATE_DIRS) {
+    const abs = path.join(cwd, dir);
+    try {
+      const entries = fs.readdirSync(abs, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile()) {
+          try {
+            const stat = fs.statSync(path.join(abs, e.name));
+            if (now - stat.mtimeMs > maxAge) {
+              stale.push(path.posix.join(dir, e.name));
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return stale;
+}
+
+function detectNoisyFiles(changedFiles) {
+  return (changedFiles || []).filter((f) =>
+    NOISE_PATTERNS.some((re) => re.test(f))
+  );
+}
+
+function computeContextBudget(cwd, options = {}) {
+  const startMs = Date.now();
+  const changedFiles = options.changedFiles || [];
+  const reasonCodes = [];
+
+  const stateArtifactOverride = options.stateArtifactOverride || null;
+  const stateArtifacts = stateArtifactOverride
+    ? { count: stateArtifactOverride.count || 0, bytes: stateArtifactOverride.bytes || 0 }
+    : estimateStateArtifacts(cwd);
+  const duplicateCount = detectDuplicateContextRefs(changedFiles);
+  const staleRefs = detectStaleArtifacts(cwd);
+  const noisyFiles = detectNoisyFiles(changedFiles);
+
+  const estimatedInputBytes = stateArtifacts.bytes + changedFiles.length * 500;
+  const estimatedItems = stateArtifacts.count + changedFiles.length;
+  const heuristicTokens = Math.round(estimatedInputBytes / 4);
+
+  let budgetClass = "small";
+  if (estimatedItems > 200 || estimatedInputBytes > 500000) {
+    budgetClass = "oversized";
+  } else if (estimatedItems > 80 || estimatedInputBytes > 200000) {
+    budgetClass = "large";
+  } else if (estimatedItems > 30 || estimatedInputBytes > 50000) {
+    budgetClass = "medium";
+  }
+
+  let status = "pass";
+  if (budgetClass === "oversized") {
+    status = "warn";
+    reasonCodes.push("CONTEXT_BUDGET_EXCEEDED");
+  } else if (budgetClass === "large") {
+    status = "warn";
+    reasonCodes.push("CONTEXT_BUDGET_WARN");
+  } else {
+    reasonCodes.push("CONTEXT_BUDGET_OK");
+  }
+
+  if (duplicateCount > 0) reasonCodes.push("DUPLICATE_CONTEXT_SIGNAL");
+  if (staleRefs.length > 0) reasonCodes.push("STALE_CONTEXT_SIGNAL");
+  if (noisyFiles.length > 0) reasonCodes.push("NOISY_OUTPUT_SIGNAL");
+
+  return {
+    status,
+    budgetClass,
+    estimatedInputBytes,
+    estimatedContextItems: estimatedItems,
+    heuristicTokenEstimate: heuristicTokens,
+    duplicateContextCount: duplicateCount,
+    staleContextCount: staleRefs.length,
+    staleContextRefs: staleRefs.slice(0, 10),
+    suppressedContextCount: noisyFiles.length,
+    noisyFileRefs: noisyFiles.slice(0, 10),
+    reasonCodes,
+    durationMs: Date.now() - startMs,
+  };
+}
+
+module.exports = { computeContextBudget, BUDGET_CLASSES };

package/scripts/lib/context-claim-safety.js

@@ -0,0 +1,116 @@
+"use strict";
+
+const BLOCKED_CLAIM_TERMS = [
+  "guaranteed",
+  "fully secure",
+  "autonomous",
+  "company brain",
+  "remembers everything",
+  "full memory",
+  "guaranteed recall",
+  "saves dollars",
+  "saves credits",
+  "saves money",
+  "perfect proof",
+  "production certified",
+];
+
+const BLOCKED_PATTERNS = BLOCKED_CLAIM_TERMS.map(
+  (term) => ({ term, pattern: new RegExp(term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") })
+);
+
+const NEGATION_PREFIX_RE = /\b(?:does\s+not|do\s+not|don['']t|doesn['']t|cannot|can['']t|no\s+|not\s+|never\s+)/i;
+
+const VALID_SUPPORT_LEVELS = new Set(["measured", "inferred", "estimated", "unverified", "blocked"]);
+
+function isNegation(text, matchIndex) {
+  const prefix = text.slice(Math.max(0, matchIndex - 40), matchIndex);
+  return NEGATION_PREFIX_RE.test(prefix);
+}
+
+function checkClaimSafety(text, options = {}) {
+  const { allowInternalContext = false } = options;
+  const blockedClaims = [];
+
+  if (!text || typeof text !== "string") {
+    return {
+      publicClaimsAllowed: true,
+      unsupportedClaimsBlocked: 0,
+      blockedClaims: [],
+      supportLevel: "unverified",
+    };
+  }
+
+  for (const { term, pattern } of BLOCKED_PATTERNS) {
+    const match = pattern.exec(text);
+    if (!match) continue;
+    if (isNegation(text, match.index)) continue;
+    if (allowInternalContext) continue;
+    blockedClaims.push({
+      term,
+      position: match.index,
+      context: text.slice(Math.max(0, match.index - 20), match.index + term.length + 20).trim(),
+      blocked: true,
+    });
+  }
+
+  return {
+    publicClaimsAllowed: blockedClaims.length === 0,
+    unsupportedClaimsBlocked: blockedClaims.length,
+    blockedClaims,
+    supportLevel: blockedClaims.length > 0 ? "blocked" : "unverified",
+  };
+}
+
+function checkRefClaimSafety(ref) {
+  if (!ref) return { safe: true, issues: [] };
+  const issues = [];
+  if (ref.type === "planning_doc" && ref.allowedForClaims) {
+    issues.push("planning_doc cannot support public claims");
+  }
+  if (ref.internalOnly && ref.allowedForClaims && ref.type !== "proof_artifact") {
+    issues.push("internal-only source claims need proof backing");
+  }
+  return { safe: issues.length === 0, issues };
+}
+
+function determineSupportLevel(ref) {
+  if (!ref) return "unverified";
+  if (ref.type === "proof_artifact" && ref.evidenceRefs && ref.evidenceRefs.length > 0) return "measured";
+  if (ref.type === "dogfood_artifact") return "measured";
+  if (ref.type === "release_doc") return "inferred";
+  if (ref.type === "public_article") return "inferred";
+  if (ref.type === "capability_manifest") return "inferred";
+  if (ref.type === "planning_doc") return "unverified";
+  if (ref.type === "reentry_memory") return "unverified";
+  return "estimated";
+}
+
+function buildClaimSafetyReport(refs, textContent) {
+  const textCheck = textContent ? checkClaimSafety(textContent) : null;
+  const refIssues = [];
+  for (const ref of refs || []) {
+    const check = checkRefClaimSafety(ref);
+    if (!check.safe) refIssues.push({ ref: ref.ref, issues: check.issues });
+  }
+  return {
+    publicClaimsAllowed: (!textCheck || textCheck.publicClaimsAllowed) && refIssues.length === 0,
+    unsupportedClaimsBlocked: (textCheck ? textCheck.unsupportedClaimsBlocked : 0) + refIssues.length,
+    blockedClaims: [
+      ...(textCheck ? textCheck.blockedClaims : []),
+      ...refIssues.map((ri) => ({ ref: ri.ref, issues: ri.issues, blocked: true })),
+    ],
+    supportLevel: textCheck ? textCheck.supportLevel : "unverified",
+  };
+}
+
+module.exports = {
+  BLOCKED_CLAIM_TERMS,
+  BLOCKED_PATTERNS,
+  VALID_SUPPORT_LEVELS,
+  checkClaimSafety,
+  checkRefClaimSafety,
+  determineSupportLevel,
+  buildClaimSafetyReport,
+  isNegation,
+};