avorelo 0.3.8 → 0.4.0-rc.2

package/scripts/lib/package-runtime.js

@@ -0,0 +1,278 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { builtinModules } = require("module");
+
+const BUILTIN_MODULES = new Set([
+  ...builtinModules,
+  ...builtinModules.map((name) => name.replace(/^node:/, "")),
+  ...builtinModules.map((name) => (name.startsWith("node:") ? name : `node:${name}`)),
+]);
+const REQUIRE_PATTERN = /require\((["'])([^"']+)\1\)/g;
+const OPTIONAL_REQUIRE_LOOKAROUND = 240;
+
+function ensureDir(dirPath) {
+  if (!dirPath) return dirPath;
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function readJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    return null;
+  }
+}
+
+function readPackageJson(cwd) {
+  return readJson(path.join(cwd, "package.json"));
+}
+
+function getBinEntries(pkg) {
+  if (!pkg || !pkg.bin) return {};
+  return typeof pkg.bin === "string" ? { [pkg.name || "avorelo"]: pkg.bin } : { ...pkg.bin };
+}
+
+function getPublishConfig(pkg) {
+  return pkg && pkg.publishConfig && typeof pkg.publishConfig === "object"
+    ? { ...pkg.publishConfig }
+    : null;
+}
+
+function createCacheDir(label = "default") {
+  const safeLabel = String(label).replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+  return ensureDir(path.join(os.tmpdir(), "avorelo-npm-cache", safeLabel));
+}
+
+function createTempDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix || "avorelo-"));
+}
+
+function buildPackageManagerEnv(options = {}) {
+  const env = {
+    ...process.env,
+    ...(options.env || {}),
+  };
+  env.npm_config_cache = options.cacheDir || createCacheDir(options.cacheLabel || "default");
+  env.npm_config_update_notifier = "false";
+  env.npm_config_fund = "false";
+  env.npm_config_audit = "false";
+  env.npm_config_loglevel = env.npm_config_loglevel || "warn";
+  return env;
+}
+
+function runPackageManagerCommand(tool, args, options = {}) {
+  const commandArgs = Array.isArray(args) ? args.slice() : [];
+  const env = buildPackageManagerEnv(options);
+  const spawnCommand = process.platform === "win32" ? "cmd" : tool;
+  const spawnArgs = process.platform === "win32" ? ["/c", tool, ...commandArgs] : commandArgs;
+  const result = spawnSync(spawnCommand, spawnArgs, {
+    cwd: options.cwd || process.cwd(),
+    env,
+    encoding: "utf8",
+    timeout: options.timeoutMs || 120000,
+    stdio: "pipe",
+  });
+
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  return {
+    success: result.status === 0,
+    status: result.status,
+    signal: result.signal || null,
+    stdout,
+    stderr,
+    combinedOutput: [stdout, stderr].filter(Boolean).join("\n").trim(),
+    errorSummary: [stderr, stdout].find(Boolean) || (result.error ? String(result.error) : ""),
+    cacheDir: env.npm_config_cache,
+  };
+}
+
+function runNpm(args, options = {}) {
+  return runPackageManagerCommand("npm", args, options);
+}
+
+function runNpx(args, options = {}) {
+  return runPackageManagerCommand("npx", args, options);
+}
+
+function normalizeRelativePath(filePath) {
+  return String(filePath || "").replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function packageNameFromSpecifier(specifier) {
+  const normalized = String(specifier || "").replace(/^node:/, "");
+  if (!normalized || normalized.startsWith(".") || normalized.startsWith("/")) return null;
+  if (normalized.startsWith("@")) {
+    const parts = normalized.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : normalized;
+  }
+  return normalized.split("/")[0];
+}
+
+function isFile(candidate) {
+  try {
+    return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function resolveLocalModule(fromFile, specifier) {
+  const absoluteBase = path.resolve(path.dirname(fromFile), specifier);
+  const candidates = [
+    `${absoluteBase}.js`,
+    `${absoluteBase}.json`,
+    path.join(absoluteBase, "index.js"),
+    path.join(absoluteBase, "index.json"),
+    absoluteBase,
+  ];
+  return candidates.find((candidate) => isFile(candidate)) || null;
+}
+
+function isLikelyOptionalRequire(source, matchIndex) {
+  const start = Math.max(0, matchIndex - OPTIONAL_REQUIRE_LOOKAROUND);
+  const end = Math.min(source.length, matchIndex + OPTIONAL_REQUIRE_LOOKAROUND);
+  const before = source.slice(start, matchIndex);
+  const after = source.slice(matchIndex, end);
+  return /\btry\s*\{[^{}]*$/s.test(before) && /\}\s*catch\b/s.test(after);
+}
+
+function getPublicRuntimeEntryFiles(cwd) {
+  const root = path.resolve(cwd);
+  return [
+    path.join(root, "scripts", "lib", "alpha-activation.js"),
+    path.join(root, "scripts", "cco-status.js"),
+    path.join(root, "scripts", "cco-dashboard.js"),
+  ].filter((filePath) => fs.existsSync(filePath));
+}
+
+function collectRuntimeDependencyGraph(cwd, options = {}) {
+  const root = path.resolve(cwd);
+  const entryFiles = (options.entryFiles || [path.join(root, "bin", "avorelo")]).map((filePath) => path.resolve(filePath));
+  const visited = new Set();
+  const externalPackages = new Set();
+  const localFiles = new Set();
+  const missingLocalFiles = new Set();
+  const queue = entryFiles.slice();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current) || !fs.existsSync(current)) continue;
+    visited.add(current);
+    localFiles.add(normalizeRelativePath(path.relative(root, current)));
+
+    let source = "";
+    try {
+      source = fs.readFileSync(current, "utf8");
+    } catch {
+      continue;
+    }
+
+    REQUIRE_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = REQUIRE_PATTERN.exec(source)) !== null) {
+      const specifier = match[2];
+      const optionalRequire = isLikelyOptionalRequire(source, match.index);
+      if (!specifier) continue;
+      if (specifier.startsWith(".")) {
+        const resolved = resolveLocalModule(current, specifier);
+        if (resolved) {
+          queue.push(resolved);
+        } else if (!optionalRequire) {
+          missingLocalFiles.add(normalizeRelativePath(path.relative(root, path.resolve(path.dirname(current), specifier))));
+        }
+        continue;
+      }
+
+      const packageName = packageNameFromSpecifier(specifier);
+      if (!packageName || BUILTIN_MODULES.has(packageName) || BUILTIN_MODULES.has(specifier) || optionalRequire) continue;
+      externalPackages.add(packageName);
+    }
+  }
+
+  return {
+    entryFiles: entryFiles.map((filePath) => normalizeRelativePath(path.relative(root, filePath))),
+    localFiles: Array.from(localFiles).sort(),
+    externalPackages: Array.from(externalPackages).sort(),
+    missingLocalFiles: Array.from(missingLocalFiles).sort(),
+  };
+}
+
+function findMissingRuntimeDependencies(pkg, runtimeGraph) {
+  const dependencies = pkg && pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : {};
+  return (runtimeGraph && Array.isArray(runtimeGraph.externalPackages) ? runtimeGraph.externalPackages : [])
+    .filter((packageName) => !Object.prototype.hasOwnProperty.call(dependencies, packageName))
+    .sort();
+}
+
+function buildPathRedactions(paths = []) {
+  const redactions = [];
+  for (const value of paths) {
+    if (!value) continue;
+    const normalized = String(value);
+    redactions.push([normalized, "<redacted-temp-path>"]);
+    redactions.push([normalized.replace(/\\/g, "/"), "<redacted-temp-path>"]);
+    redactions.push([normalized.replace(/\\/g, "\\\\"), "<redacted-temp-path>"]);
+  }
+  return redactions.sort((left, right) => right[0].length - left[0].length);
+}
+
+function redactPathsInText(text, paths = []) {
+  if (typeof text !== "string" || !text) return text;
+  let redacted = text;
+  for (const [target, replacement] of buildPathRedactions(paths)) {
+    redacted = redacted.split(target).join(replacement);
+  }
+  return redacted;
+}
+
+function redactPathsInValue(value, paths = []) {
+  if (typeof value === "string") return redactPathsInText(value, paths);
+  if (Array.isArray(value)) return value.map((entry) => redactPathsInValue(entry, paths));
+  if (!value || typeof value !== "object") return value;
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    next[key] = redactPathsInValue(entry, paths);
+  }
+  return next;
+}
+
+function mapDistributionStateToStatus(distributionState) {
+  switch (distributionState) {
+    case "publish_blocked":
+      return "blocked";
+    case "private_local_only":
+    case "local_verified":
+      return "local_only";
+    case "ready_to_publish":
+    case "published_verified":
+      return "pass";
+    default:
+      return "warn";
+  }
+}
+
+module.exports = {
+  ensureDir,
+  readJson,
+  readPackageJson,
+  getBinEntries,
+  getPublishConfig,
+  createCacheDir,
+  createTempDir,
+  runNpm,
+  runNpx,
+  normalizeRelativePath,
+  collectRuntimeDependencyGraph,
+  findMissingRuntimeDependencies,
+  getPublicRuntimeEntryFiles,
+  redactPathsInText,
+  redactPathsInValue,
+  mapDistributionStateToStatus,
+};

package/scripts/lib/plan-surface.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const { PLAN_ENV, getCurrentPlan, getHistoryRetention, canExportReports } = require("./entitlements");
+const { getPlan, listBucketsForPlan, comparePlans } = require("./plans");
+const { buildVisualQaSurface } = require("./visual-qa");
+const { buildPlanSecuritySurface } = require("./agent-enforcement");
+
+function buildIncludedLine(planName, visualQaSurface) {
+  if (planName === "pro") {
+    return "Included: Better AI Coding Tasks, Advanced Context Optimization, more Visual QA, and advanced Agent Security.";
+  }
+  const quota = visualQaSurface?.quota;
+  const visualQaLabel = quota?.tracked ? `${quota.limit} Visual QA/${quota.period}` : "Visual QA";
+  return `Included: Better AI Coding Tasks, Basic Context Optimization, ${visualQaLabel}, and Basic Agent Security.`;
+}
+
+function buildUpgradeLine() {
+  return "Pro unlocks advanced task compilation, deeper context optimization, more Visual QA, least-privilege protection, and evidence history/export.";
+}
+
+function buildPlanSurface(cwd) {
+  const planName = getCurrentPlan({ cwd });
+  const plan = getPlan(planName) || getPlan("free");
+  const buckets = listBucketsForPlan(planName);
+  const visualQa = buildVisualQaSurface(cwd, { plan: planName });
+  const security = buildPlanSecuritySurface(cwd, { plan: planName });
+  const comparison = comparePlans();
+  const overrideValue = String(process.env[PLAN_ENV] || "").trim().toLowerCase();
+  const overrideNote = overrideValue === planName
+    ? `${PLAN_ENV}=${overrideValue} override active for local development/testing.`
+    : null;
+  return {
+    plan: planName,
+    planLabel: plan.name,
+    planSource: overrideNote ? "env_override" : "default_resolution",
+    overrideNote,
+    subtitle: plan.subtitle,
+    promise: plan.promise,
+    buckets: buckets.map((bucket) => bucket.label),
+    bucketDetails: buckets,
+    includedLine: buildIncludedLine(planName, visualQa),
+    upgradeLine: buildUpgradeLine(),
+    historyRetention: getHistoryRetention(planName),
+    canExportReports: canExportReports(planName),
+    visualQa,
+    security,
+    upgradeUnlocks: comparison.upgradeUnlocks,
+  };
+}
+
+module.exports = {
+  buildPlanSurface,
+};