@0dai-dev/cli 4.2.0 → 4.3.5

package/lib/shared.js

@@ -60,7 +60,7 @@ const DRIFT_TRACKED_CONFIGS = [
 ];
 
 // --- API ---
-function apiCall(endpoint, data) {
+function apiCall(endpoint, data, options = {}) {
   return new Promise((resolve) => {
     const url = new URL(endpoint, API_URL);
     const mod = url.protocol === "https:" ? https : http;
@@ -71,11 +71,16 @@ function apiCall(endpoint, data) {
       "X-CLI-Version": VERSION,
       "X-Client-Channel": "npm",
     };
-    try {
-      const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
-      const token = auth.api_key || auth.access_token || auth.token;
-      if (token) headers["Authorization"] = `Bearer ${token}`;
-    } catch {}
+    const accessToken = options && options.accessToken ? String(options.accessToken).trim() : "";
+    if (accessToken) {
+      headers["Authorization"] = `Bearer ${accessToken}`;
+    } else {
+      try {
+        const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+        const token = auth.api_key || auth.access_token || auth.token;
+        if (token) headers["Authorization"] = `Bearer ${token}`;
+      } catch {}
+    }
     const opts = {
       hostname: url.hostname,
       port: url.port || (url.protocol === "https:" ? 443 : 80),
@@ -116,12 +121,14 @@ function updateAuthState(patch) {
   saveAuthState({ ...current, ...patch });
 }
 
-async function fetchAuthStatus() {
-  const status = await apiCall("/v1/auth/status");
-  if (status && !status.error && status.email) {
+async function fetchAuthStatus(accessToken = "") {
+  const token = String(accessToken || "").trim();
+  const status = await apiCall("/v1/auth/status", null, token ? { accessToken: token } : undefined);
+  if (status && !status.error && status.email && !token) {
     updateAuthState({
       email: status.email, plan: status.plan || "free",
       name: status.name || "", license: status.license || {},
+      plan_expires_at: status.plan_expires_at || "",
     });
   }
   return status;
@@ -302,6 +309,8 @@ function mergeSettingsJson(existing, incoming) {
 function writeFiles(target, files) {
   let created = 0, updated = 0, unchanged = 0, merged = 0, skipped = 0;
   const targetResolved = path.resolve(target);
+  let backupDir = null;
+  const backupConfigs = new Set(["CLAUDE.md", "AGENTS.md"]);
   for (const [rel, content] of Object.entries(files)) {
     if (typeof rel !== "string" || !rel || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
       skipped++; continue;
@@ -314,11 +323,16 @@ function writeFiles(target, files) {
       const existing = fs.readFileSync(p, "utf8");
       if (existing === content) { unchanged++; continue; }
       if (rel.endsWith("settings.json")) { finalContent = mergeSettingsJson(existing, content); merged++; }
-      else if (rel === "AGENTS.md") {
-        if (existing.includes("managed: false")) { unchanged++; continue; }
-        const backupDir = path.join(target, "ai", ".backups");
-        fs.mkdirSync(backupDir, { recursive: true });
-        fs.writeFileSync(path.join(backupDir, "AGENTS.md.bak"), existing, "utf8");
+      else if (backupConfigs.has(rel)) {
+        if (rel === "AGENTS.md" && existing.includes("managed: false")) { unchanged++; continue; }
+        if (!backupDir) {
+          const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+          backupDir = path.join(targetResolved, "ai", ".backups", timestamp);
+          fs.mkdirSync(backupDir, { recursive: true });
+        }
+        const backupPath = path.join(backupDir, rel);
+        fs.writeFileSync(backupPath, existing, "utf8");
+        log(`backed up existing ${rel} to ${backupPath}`);
         updated++;
       } else { updated++; }
     } else { created++; }
@@ -337,6 +351,7 @@ function findRepoScript(target, scriptName) {
     path.join(target, "scripts", scriptName),
     path.join(process.cwd(), "scripts", scriptName),
     path.join(__dirname, "..", "..", "..", "scripts", scriptName),
+    path.join(__dirname, "..", "..", "..", "..", "scripts", scriptName),
   ];
   for (const c of candidates) { if (fs.existsSync(c)) return c; }
   return null;

package/lib/utils/activation_telemetry.js

@@ -0,0 +1,156 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function activationPath(target) {
+  return path.join(target, "ai", "meta", "telemetry", "activation.jsonl");
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function readEvents(target) {
+  const file = activationPath(target);
+  if (!fs.existsSync(file)) return [];
+  const lines = fs.readFileSync(file, "utf8").trim().split("\n").filter(Boolean);
+  const events = [];
+  for (const ln of lines) {
+    try {
+      const row = JSON.parse(ln);
+      if (row && row.event) events.push(row);
+    } catch { /* ignore malformed lines */ }
+  }
+  return events;
+}
+
+function appendEvent(target, entry) {
+  const file = activationPath(target);
+  try {
+    ensureDir(file);
+    fs.appendFileSync(file, JSON.stringify(entry) + "\n", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasEvent(events, eventName, projectId) {
+  return events.some((e) => e.event === eventName && e.project_id === projectId);
+}
+
+function findInitTs(events, projectId) {
+  const init = events.find((e) => e.event === "init" && e.project_id === projectId);
+  return init && init.ts ? init.ts : null;
+}
+
+function parseTs(ts) {
+  const ms = Date.parse(ts);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+// Idempotently append `{event:"init", ts, project_id}` on successful init.
+function recordActivationInit(target, projectId) {
+  try {
+    if (!projectId) return { fired: false };
+    const events = readEvents(target);
+    if (hasEvent(events, "init", projectId)) return { fired: false };
+    const entry = { event: "init", ts: nowIso(), project_id: projectId };
+    return { fired: appendEvent(target, entry) };
+  } catch {
+    return { fired: false };
+  }
+}
+
+// Idempotently append first_task with duration_ms = first_task.ts - init.ts.
+function recordActivationFirstTask(target, projectId) {
+  try {
+    if (!projectId) return { fired: false, durationMs: null };
+    const events = readEvents(target);
+    if (hasEvent(events, "first_task", projectId)) {
+      return { fired: false, durationMs: null };
+    }
+
+    const initTs = findInitTs(events, projectId);
+    const ts = nowIso();
+    let durationMs = null;
+    if (initTs) {
+      const initMs = parseTs(initTs);
+      const taskMs = parseTs(ts);
+      if (initMs != null && taskMs != null) {
+        durationMs = Math.max(0, taskMs - initMs);
+      }
+    }
+
+    const entry = {
+      event: "first_task",
+      ts,
+      project_id: projectId,
+      duration_ms: durationMs,
+    };
+    const fired = appendEvent(target, entry);
+    return { fired, durationMs };
+  } catch {
+    return { fired: false, durationMs: null };
+  }
+}
+
+function percentile(sorted, p) {
+  if (!sorted.length) return null;
+  if (sorted.length === 1) return sorted[0];
+  const idx = (sorted.length - 1) * p;
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo];
+  const weight = idx - lo;
+  return Math.round(sorted[lo] * (1 - weight) + sorted[hi] * weight);
+}
+
+function getActivationDurationStats(target) {
+  const events = readEvents(target);
+  const durations = events
+    .filter((e) => e.event === "first_task"
+      && typeof e.duration_ms === "number"
+      && Number.isFinite(e.duration_ms))
+    .map((e) => e.duration_ms)
+    .sort((a, b) => a - b);
+
+  return {
+    count: durations.length,
+    p50_ms: percentile(durations, 0.5),
+    p90_ms: percentile(durations, 0.9),
+  };
+}
+
+function formatDurationMs(ms) {
+  if (ms == null) return "?";
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+function printActivationStats(target) {
+  const stats = getActivationDurationStats(target);
+  if (stats.count === 0) return stats;
+  console.log(
+    `  activation TTFV: p50 ${formatDurationMs(stats.p50_ms)}`
+    + ` / p90 ${formatDurationMs(stats.p90_ms)}`
+    + ` (${stats.count} sample${stats.count === 1 ? "" : "s"})`,
+  );
+  return stats;
+}
+
+module.exports = {
+  activationPath,
+  readEvents,
+  recordActivationInit,
+  recordActivationFirstTask,
+  getActivationDurationStats,
+  printActivationStats,
+  formatDurationMs,
+};

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/constants.js

@@ -46,6 +46,13 @@ const SUPPORTED_CLIS = [
     altAuth: null,
     agentFiles: [".qoder/settings.json"],
   },
+  {
+    name: "cursor", bin: "cursor-agent",
+    pkg: null, pkgType: "curl",
+    install: "curl https://cursor.com/install -fsS | bash",
+    altAuth: "Cursor Pro/Business subscription",
+    agentFiles: [".cursor/mcp.json", ".cursor/hooks.json"],
+  },
 ];
 
 const MANIFEST_FILES = [

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,
 };