@0dai-dev/cli 4.2.0 → 4.3.4

package/lib/utils/auth.js

@@ -85,6 +85,7 @@ async function fetchAuthStatus(apiCallFn, API_URL) {
       plan: status.plan || "free",
       name: status.name || "",
       license: status.license || {},
+      plan_expires_at: status.plan_expires_at || "",
     });
   }
   return status;

package/lib/utils/canonical-counts.js

@@ -0,0 +1,54 @@
+/**
+ * Runtime reader for generated canonical product counts.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { SUPPORTED_CLIS } = require("./constants");
+
+const FALLBACK = Object.freeze({
+  schema_version: 0,
+  supported_agents: SUPPORTED_CLIS.map((cli) => cli.name),
+  supported_agents_total: SUPPORTED_CLIS.length,
+  supported_runtime_agents: SUPPORTED_CLIS.map((cli) => cli.name),
+  supported_runtime_agents_total: SUPPORTED_CLIS.length,
+  supported_agent_clis: SUPPORTED_CLIS.map((cli) => cli.name),
+  supported_agent_cli_display_names: SUPPORTED_CLIS.map((cli) => cli.name),
+  agent_clis_total: SUPPORTED_CLIS.length,
+  mcp_tools_total: null,
+  free_mcp_tools_total: null,
+  pro_mcp_tools_total: null,
+  cli_commands_total: null,
+  integrations_total: null,
+});
+
+function candidatePaths() {
+  const envPath = process.env.ODAI_CANONICAL_COUNTS_PATH;
+  return [
+    envPath,
+    path.resolve(__dirname, "../../../../ai/manifest/canonical-counts.json"),
+    path.resolve(process.cwd(), "ai/manifest/canonical-counts.json"),
+  ].filter(Boolean);
+}
+
+function loadCanonicalCounts() {
+  for (const candidate of candidatePaths()) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      if (parsed && typeof parsed === "object") {
+        return { ...FALLBACK, ...parsed };
+      }
+    } catch {}
+  }
+  return { ...FALLBACK };
+}
+
+function mcpToolsLabel(counts = loadCanonicalCounts()) {
+  return Number.isInteger(counts.mcp_tools_total)
+    ? `${counts.mcp_tools_total} MCP tools`
+    : "MCP tools";
+}
+
+module.exports = { loadCanonicalCounts, mcpToolsLabel };

package/lib/utils/diff-preview.js

@@ -0,0 +1,192 @@
+"use strict";
+
+const crypto = require("crypto");
+const readline = require("readline");
+
+function _lines(text) {
+  if (text == null) return [];
+  const s = String(text);
+  return s.length === 0 ? [] : s.split(/\r?\n/);
+}
+
+function unifiedDiff(relPath, before, after, context = 3) {
+  const a = _lines(before);
+  const b = _lines(after);
+  if (a.join("\n") === b.join("\n")) return "";
+
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      if (a[i] === b[j]) dp[i][j] = dp[i + 1][j + 1] + 1;
+      else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+
+  const ops = [];
+  let i = 0, j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) { ops.push(["=", a[i]]); i++; j++; }
+    else if (dp[i + 1][j] >= dp[i][j + 1]) { ops.push(["-", a[i]]); i++; }
+    else { ops.push(["+", b[j]]); j++; }
+  }
+  while (i < n) { ops.push(["-", a[i++]]); }
+  while (j < m) { ops.push(["+", b[j++]]); }
+
+  const hunks = [];
+  let k = 0;
+  while (k < ops.length) {
+    if (ops[k][0] === "=") { k++; continue; }
+    let start = Math.max(0, k - context);
+    let end = k;
+    while (end < ops.length) {
+      if (ops[end][0] !== "=") { end++; continue; }
+      let run = 0;
+      let peek = end;
+      while (peek < ops.length && ops[peek][0] === "=") { peek++; run++; }
+      if (run > context * 2 || peek === ops.length) {
+        end += Math.min(run, context);
+        break;
+      }
+      end = peek;
+    }
+    hunks.push([start, end]);
+    k = end;
+  }
+
+  const out = [`--- a/${relPath}`, `+++ b/${relPath}`];
+  for (const [hs, he] of hunks) {
+    let oldStart = 0, oldLen = 0, newStart = 0, newLen = 0;
+    for (let p = 0; p < hs; p++) {
+      if (ops[p][0] !== "+") oldStart++;
+      if (ops[p][0] !== "-") newStart++;
+    }
+    for (let p = hs; p < he; p++) {
+      if (ops[p][0] !== "+") oldLen++;
+      if (ops[p][0] !== "-") newLen++;
+    }
+    out.push(`@@ -${oldStart + 1},${oldLen} +${newStart + 1},${newLen} @@`);
+    for (let p = hs; p < he; p++) {
+      const [tag, line] = ops[p];
+      const prefix = tag === "=" ? " " : tag;
+      out.push(prefix + line);
+    }
+  }
+  return out.join("\n");
+}
+
+function isHashOnlyFile(value) {
+  return !!(
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Number.isFinite(Number(value.size)) &&
+    typeof value.sha256 === "string" &&
+    /^[a-f0-9]{64}$/i.test(value.sha256)
+  );
+}
+
+function formatFileSize(size) {
+  const bytes = Number(size) || 0;
+  if (bytes < 1000) return `${bytes}B`;
+  if (bytes < 1000 * 1000) return `${Math.round(bytes / 1000)}KB`;
+  return `${Math.round(bytes / 100000) / 10}MB`;
+}
+
+function shortSha256(sha256) {
+  const value = String(sha256 || "");
+  return value.length > 12 ? `${value.slice(0, 12)}...` : value;
+}
+
+function hashText(text) {
+  return crypto.createHash("sha256").update(String(text), "utf8").digest("hex");
+}
+
+function descriptorForText(text) {
+  const value = String(text);
+  return {
+    size: Buffer.byteLength(value, "utf8"),
+    sha256: hashText(value),
+    compare: "hash-only",
+  };
+}
+
+function formatHashOnlyFile(value) {
+  return `size: ${formatFileSize(value.size)} sha256: ${shortSha256(value.sha256)} [hash-only compare]`;
+}
+
+function fileValueEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a == null && b == null;
+  const aHashOnly = isHashOnlyFile(a);
+  const bHashOnly = isHashOnlyFile(b);
+  if (!aHashOnly && !bHashOnly) return false;
+  const aDescriptor = aHashOnly ? a : descriptorForText(a);
+  const bDescriptor = bHashOnly ? b : descriptorForText(b);
+  return Number(aDescriptor.size) === Number(bDescriptor.size) &&
+    String(aDescriptor.sha256).toLowerCase() === String(bDescriptor.sha256).toLowerCase();
+}
+
+function valueForDiff(value, peerValue) {
+  if (isHashOnlyFile(value)) return formatHashOnlyFile(value);
+  if (value == null) return "";
+  if (isHashOnlyFile(peerValue)) return formatHashOnlyFile(descriptorForText(value));
+  return String(value);
+}
+
+function renderFileMapDiff(changes, currentFiles = {}) {
+  const parts = [];
+  const summary = { added: [], modified: [], removed: [] };
+  for (const rel of Object.keys(changes).sort()) {
+    const hasCurrent = Object.prototype.hasOwnProperty.call(currentFiles, rel);
+    const before = hasCurrent ? currentFiles[rel] : "";
+    const after = changes[rel];
+    if (fileValueEqual(before, after)) continue;
+    if (!hasCurrent) summary.added.push(rel);
+    else if (after == null) summary.removed.push(rel);
+    else summary.modified.push(rel);
+    const d = unifiedDiff(rel, valueForDiff(before, after), valueForDiff(after, before));
+    if (d) parts.push(d);
+  }
+  return { diff: parts.join("\n"), summary };
+}
+
+function shouldAutoYes(args = []) {
+  if (args.includes("--yes") || args.includes("-y")) return true;
+  if (process.env.ODAI_ASSUME_YES === "1") return true;
+  if (process.env.CI === "true") return true;
+  if (!process.stdin.isTTY) return true;
+  return false;
+}
+
+function promptConfirm(question, defaultYes = false) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) { resolve(defaultYes); return; }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+    rl.question(question + suffix, (ans) => {
+      rl.close();
+      const a = String(ans || "").trim().toLowerCase();
+      if (!a) return resolve(defaultYes);
+      resolve(a === "y" || a === "yes");
+    });
+  });
+}
+
+async function confirmOrExit({ args = [], quiet = false, message = "Apply these changes?", defaultYes = false } = {}) {
+  if (quiet) return true;
+  if (shouldAutoYes(args)) return true;
+  const ok = await promptConfirm(message, defaultYes);
+  return ok;
+}
+
+module.exports = {
+  unifiedDiff,
+  renderFileMapDiff,
+  isHashOnlyFile,
+  formatHashOnlyFile,
+  shouldAutoYes,
+  promptConfirm,
+  confirmOrExit,
+};

package/lib/utils/identity.js

@@ -30,31 +30,85 @@ function deviceFingerprint() {
 }
 
 function registerProject(projectPath, name, stack, CONFIG_DIR, PROJECTS_FILE) {
+  if (!CONFIG_DIR || !PROJECTS_FILE) {
+    throw new Error("registerProject requires CONFIG_DIR and PROJECTS_FILE");
+  }
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  let projects = [];
+  if (fs.existsSync(PROJECTS_FILE)) {
+    const parsed = JSON.parse(fs.readFileSync(PROJECTS_FILE, "utf8"));
+    projects = Array.isArray(parsed && parsed.projects) ? parsed.projects : [];
+  }
+
+  const abs = path.resolve(projectPath);
+  const idx = projects.findIndex(p => p.path === abs);
+  const entry = { path: abs, name: name || path.basename(abs), stack: stack || "?", last_seen: new Date().toISOString() };
+  if (idx >= 0) projects[idx] = entry;
+  else projects.unshift(entry);
+  fs.writeFileSync(PROJECTS_FILE, JSON.stringify({ projects: projects.slice(0, 50) }, null, 2));
+  return entry;
+}
+
+function scrubRemoteUrl(url) {
+  return String(url || "").replace(/^(https?:\/\/)[^@/\s]+@/, "$1");
+}
+
+function parseScalar(value) {
+  return String(value || "").trim().replace(/^["']|["']$/g, "");
+}
+
+function readProjectManifest(target) {
+  const file = path.join(target, "ai", "manifest", "project.yaml");
+  const result = {};
+  let inProject = false;
   try {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    let projects = [];
-    try { projects = JSON.parse(fs.readFileSync(PROJECTS_FILE, "utf8")).projects || []; } catch {}
-    const abs = path.resolve(projectPath);
-    const idx = projects.findIndex(p => p.path === abs);
-    const entry = { path: abs, name: name || path.basename(abs), stack: stack || "?", last_seen: new Date().toISOString() };
-    if (idx >= 0) projects[idx] = entry;
-    else projects.unshift(entry);
-    fs.writeFileSync(PROJECTS_FILE, JSON.stringify({ projects: projects.slice(0, 50) }, null, 2));
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line || line.startsWith("#")) continue;
+      const topLevel = raw.length === raw.trimStart().length;
+      if (topLevel) inProject = false;
+      if (topLevel && line === "project:") {
+        inProject = true;
+        continue;
+      }
+      if (topLevel && line.startsWith("name:")) result.name = parseScalar(line.split(":", 2)[1]);
+      else if (topLevel && line.startsWith("stack:")) result.stack = parseScalar(line.split(":", 2)[1]);
+      else if (topLevel && line.startsWith("repo:")) result.repo = scrubRemoteUrl(parseScalar(line.split(":", 2)[1]));
+      else if (inProject && line.startsWith("name:") && !result.name) result.name = parseScalar(line.split(":", 2)[1]);
+      else if (inProject && line.startsWith("stack:") && !result.stack) result.stack = parseScalar(line.split(":", 2)[1]);
+      else if (inProject && line.startsWith("type:") && !result.stack) result.stack = parseScalar(line.split(":", 2)[1]);
+      else if (inProject && line.startsWith("repo:") && !result.repo) result.repo = scrubRemoteUrl(parseScalar(line.split(":", 2)[1]));
+    }
   } catch {}
+  return result;
+}
+
+function readDiscovery(target) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(target, "ai", "manifest", "discovery.json"), "utf8"));
+  } catch {
+    return {};
+  }
 }
 
 function projectIdFor(target, projectName, remoteOrigin) {
   const crypto = require("crypto");
-  const seed = JSON.stringify({ name: projectName, origin: remoteOrigin || path.resolve(target) });
+  const seed = projectIdSeed(projectName, remoteOrigin || path.resolve(target));
   return "prj_" + crypto.createHash("sha256").update(seed).digest("hex").slice(0, 16);
 }
 
+function projectIdSeed(projectName, origin) {
+  return `{"name": ${JSON.stringify(projectName)}, "origin": ${JSON.stringify(origin)}}`;
+}
+
 function getGitRemoteOrigin(target) {
   try {
     const { execFileSync } = require("child_process");
-    return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+    return scrubRemoteUrl(execFileSync("git", ["config", "--get", "remote.origin.url"], {
       cwd: target, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 5000,
-    }).trim();
+    }).trim());
   } catch { return ""; }
 }
 
@@ -127,21 +181,25 @@ function collectMetadata(target) {
 }
 
 function buildProjectIdentity(target, metadata, detectedStack = "") {
-  const projectName = inferProjectName(target, metadata.manifestContents);
+  const manifest = readProjectManifest(target);
+  const discovery = readDiscovery(target);
+  const projectName = manifest.name || inferProjectName(target, metadata.manifestContents);
   const remoteOrigin = getGitRemoteOrigin(target);
+  const originValue = remoteOrigin || manifest.repo || path.resolve(target);
   return {
     project_name: projectName,
-    stack: detectedStack || detectStackHint(metadata.projectFiles, metadata.manifestContents),
-    project_id: projectIdFor(target, projectName, remoteOrigin),
-    origin: remoteOrigin ? "git" : "local",
-    remote_origin: remoteOrigin,
+    stack: detectedStack || manifest.stack || discovery.stack || detectStackHint(metadata.projectFiles, metadata.manifestContents),
+    project_id: projectIdFor(target, projectName, originValue),
+    origin: remoteOrigin ? "git" : (manifest.repo ? "manifest" : "local"),
+    remote_origin: remoteOrigin || manifest.repo || "",
     binding_source: "npm-cli",
   };
 }
 
 module.exports = {
   MANIFEST_FILES, PROBE_DIRS,
-  deviceFingerprint, registerProject, projectIdFor,
+  deviceFingerprint, registerProject, projectIdFor, projectIdSeed,
+  scrubRemoteUrl, readProjectManifest, readDiscovery,
   getGitRemoteOrigin, inferProjectName, detectStackHint,
   collectMetadata, buildProjectIdentity,
 };