@0dai-dev/cli 2.0.0 → 2.1.0

package/bin/0dai.js

@@ -7,8 +7,12 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const VERSION = "2.0.0";
+const VERSION = "2.1.0";
 const API_URL = process.env.ODAI_API_URL || "https://api.0dai.dev";
+const T = process.stdout.isTTY ? "\x1b[38;2;45;212;168m" : ""; // teal
+const R = process.stdout.isTTY ? "\x1b[0m" : ""; // reset
+const D = process.stdout.isTTY ? "\x1b[2m" : ""; // dim
+const log = (msg) => console.log(`${T}[0dai]${R} ${msg}`);
 const CONFIG_DIR = path.join(os.homedir(), ".0dai");
 const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
 const VERSION_CHECK_FILE = path.join(CONFIG_DIR, ".version_check");
@@ -54,7 +58,7 @@ function apiCall(endpoint, data) {
     const url = new URL(endpoint, API_URL);
     const mod = url.protocol === "https:" ? https : http;
     const body = data ? JSON.stringify(data) : null;
-    const headers = { "Content-Type": "application/json", "X-Device-ID": deviceFingerprint() };
+    const headers = { "Content-Type": "application/json", "X-Device-ID": deviceFingerprint(), "X-CLI-Version": VERSION };
 
     try {
       const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
@@ -111,10 +115,10 @@ function collectMetadata(target) {
   }
 
   const clis = [];
+  const { execSync } = require("child_process");
   for (const cli of ["claude", "codex", "opencode", "gemini", "aider"]) {
     try {
-      const { execSync } = require("child_process");
-      execSync(`which ${cli}`, { stdio: "ignore" });
+      execSync(`command -v ${cli}`, { stdio: "ignore", shell: "/bin/sh", env: process.env });
       clis.push(cli);
     } catch {}
   }
@@ -137,21 +141,21 @@ function writeFiles(target, files) {
     } catch { created++; }
     fs.writeFileSync(p, content, "utf8");
   }
-  console.log(`[0dai] ${created} created, ${updated} updated, ${unchanged} unchanged`);
+  log(`${created} created, ${updated} updated, ${unchanged} unchanged`);
   return created + updated;
 }
 
 async function cmdInit(target) {
   if (fs.existsSync(path.join(target, "ai", "VERSION"))) {
     const v = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim();
-    console.log(`[0dai] ai/ layer already exists (v${v}). Run '0dai sync' to update.`);
+    log(`ai/ layer already exists (v${v}). Run '0dai sync' to update.`);
     return;
   }
 
-  console.log("[0dai] collecting project metadata...");
+  log("collecting project metadata...");
   const { projectFiles, fileContents, clis } = collectMetadata(target);
 
-  console.log(`[0dai] sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  log(`sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
   const result = await apiCall("/v1/init", {
     project_files: projectFiles,
     file_contents: fileContents,
@@ -160,15 +164,15 @@ async function cmdInit(target) {
 
   if (result.error) {
     if (result.hint) {
-      console.log(`\n[0dai] ${result.message || result.error}`);
+      log(`${result.message || result.error}`);
       console.log(`  ${result.hint}\n`);
     } else {
-      console.error(`[0dai] error: ${result.error}`);
+      log(`error: ${result.error}`);
     }
     process.exit(1);
   }
 
-  console.log(`[0dai] detected: ${result.stack || "?"}`);
+  log(`detected: ${result.stack || "?"}`);
   writeFiles(target, result.files || {});
 
   // Add to .gitignore
@@ -178,15 +182,38 @@ async function cmdInit(target) {
     if (!text.includes(".0dai")) fs.appendFileSync(gi, "\n.0dai/\n");
   } catch {}
 
-  console.log(`[0dai] initialized (${result.file_count || "?"} files)`);
+  log(`initialized (${result.file_count || "?"} files)`);
   console.log("  skills: /build /review /status /feedback /bugfix /delegate");
+
+  // Auto-feedback for free tiers (non-optional — provides usage data for product improvement)
+  const plan = result.plan || "trial";
+  if (plan === "trial" || plan === "free") {
+    const autoReport = {
+      project: path.basename(target),
+      stack_detected: result.stack || "?",
+      agent_cli: "cli",
+      verdict: "auto",
+      _auto: true,
+      _plan: plan,
+      _cli_version: VERSION,
+      _files_generated: result.file_count || 0,
+    };
+    apiCall("/v1/feedback", { report: autoReport }).catch(() => {});
+    console.log(`  ${D}usage data sent to improve 0dai (disable with Essential+ plan)${R}`);
+  }
 }
 
 async function cmdSync(target) {
-  const { projectFiles, fileContents, clis } = collectMetadata(target);
-
-  let version = "unknown", stack = "generic", agents = [];
+  // Quick local check: skip API if already at current version
+  let version = "unknown";
   try { version = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim(); } catch {}
+  if (version === VERSION) {
+    log("already up to date (v" + version + ")");
+    return;
+  }
+
+  const { projectFiles, fileContents, clis } = collectMetadata(target);
+  let stack = "generic", agents = [];
   try {
     const d = JSON.parse(fs.readFileSync(path.join(target, "ai", "manifest", "discovery.json"), "utf8"));
     stack = d.stack || "generic";
@@ -217,24 +244,24 @@ async function cmdSync(target) {
     current_files: currentFiles, file_contents: fileContents,
   });
 
-  if (result.error) { console.error(`[0dai] error: ${result.error}`); process.exit(1); }
+  if (result.error) { log(`error: ${result.error}`); process.exit(1); }
 
   const updated = result.files_updated || {};
   if (Object.keys(updated).length) writeFiles(target, updated);
-  else console.log("[0dai] already up to date");
+  else log("already up to date");
 }
 
 async function cmdDetect(target) {
   const { projectFiles } = collectMetadata(target);
   const result = await apiCall("/v1/detect", { files: projectFiles });
-  if (result.error) { console.error(`[0dai] error: ${result.error}`); return; }
+  if (result.error) { log(`error: ${result.error}`); return; }
   console.log(`stack: ${result.stack || "?"}`);
   console.log(`clis: ${(result.available_clis || []).join(",")}`);
 }
 
 function cmdDoctor(target) {
   const ai = path.join(target, "ai");
-  if (!fs.existsSync(ai)) { console.log("[0dai] no ai/ layer. Run '0dai init' first."); return; }
+  if (!fs.existsSync(ai)) { log("no ai/ layer. Run '0dai init' first."); return; }
   let v = "?";
   try { v = fs.readFileSync(path.join(ai, "VERSION"), "utf8").trim(); } catch {}
   const checks = {
@@ -246,7 +273,7 @@ function cmdDoctor(target) {
     "AGENTS.md": fs.existsSync(path.join(target, "AGENTS.md")),
   };
   const ok = Object.values(checks).every(Boolean);
-  console.log(`[0dai] v${v} — ${ok ? "healthy" : "issues found"}`);
+  log(`v${v} — ${ok ? "healthy" : "issues found"}`);
   for (const [name, exists] of Object.entries(checks)) console.log(`  ${exists ? "ok" : "MISSING"}: ${name}`);
 }
 
@@ -255,7 +282,7 @@ function cmdStatus(target) {
   let v = "?", stack = "?";
   try { v = fs.readFileSync(path.join(ai, "VERSION"), "utf8").trim(); } catch {}
   try { stack = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")).stack || "?"; } catch {}
-  console.log(`[0dai] v${v} | stack: ${stack}`);
+  log(`v${v} | stack: ${stack}`);
 
   const count = (dir) => { try { return fs.readdirSync(dir).filter(f => f.endsWith(".json")).length; } catch { return 0; } };
   const q = count(path.join(ai, "swarm", "queue"));
@@ -271,17 +298,18 @@ function cmdStatus(target) {
 
 async function checkVersion() {
   try {
-    // Only check once per day
+    // Check interval: 1 hour during debug, configurable via env
+    const intervalSec = parseInt(process.env.ODAI_UPDATE_CHECK_INTERVAL || "3600");
     let lastCheck = 0;
     try { lastCheck = parseFloat(fs.readFileSync(VERSION_CHECK_FILE, "utf8")); } catch {}
-    if (Date.now() / 1000 - lastCheck < 86400) return;
+    if (Date.now() / 1000 - lastCheck < intervalSec) return;
 
     fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
     fs.writeFileSync(VERSION_CHECK_FILE, String(Date.now() / 1000));
 
     const result = await apiCall("/v1/version");
     if (result.version && result.version !== VERSION) {
-      console.log(`\n[0dai] Update available: ${VERSION} → ${result.version}`);
+      log(`Update available: ${VERSION} → ${result.version}`);
       console.log(`  Run: npm update -g @0dai-dev/cli\n`);
     }
   } catch {}
@@ -290,12 +318,12 @@ async function checkVersion() {
 async function cmdAuthLogin() {
   // Step 1: request device code
   const result = await apiCall("/v1/auth/device", { client_id: "cli" });
-  if (result.error) { console.error(`[0dai] error: ${result.error}`); process.exit(1); }
+  if (result.error) { log(`error: ${result.error}`); process.exit(1); }
 
-  console.log(`[0dai] Open this URL in your browser:\n`);
+  log(`Open this URL in your browser:\n`);
   console.log(`  ${result.verification_uri}\n`);
-  console.log(`[0dai] Enter code: ${result.user_code}\n`);
-  console.log("[0dai] Waiting for authorization...");
+  log(`Enter code: ${result.user_code}\n`);
+  log("Waiting for authorization...");
 
   // Step 2: poll for token
   const interval = (result.interval || 5) * 1000;
@@ -314,28 +342,28 @@ async function cmdAuthLogin() {
         authenticated_at: new Date().toISOString(),
         expires_at: poll.expires_at,
       }, null, 2) + "\n", { mode: 0o600 });
-      console.log(`[0dai] Logged in as ${poll.email} (${poll.plan} plan)`);
+      log(`Logged in as ${poll.email} (${poll.plan} plan)`);
       return;
     }
     if (poll.error && poll.error !== "authorization_pending") {
-      console.error(`[0dai] ${poll.error}`);
+      log(`${poll.error}`);
       process.exit(1);
     }
     process.stdout.write(".");
   }
-  console.error("\n[0dai] Authorization timed out. Try again.");
+  log("Authorization timed out. Try again.");
   process.exit(1);
 }
 
 function cmdAuthLogout() {
   try { fs.unlinkSync(AUTH_FILE); } catch {}
-  console.log("[0dai] Logged out");
+  log("Logged out");
 }
 
 async function cmdAuthStatus() {
   try {
     const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
-    console.log(`[0dai] ${auth.email} (${auth.plan} plan)`);
+    log(`${auth.email} (${auth.plan} plan)`);
     // Get usage from API
     const status = await apiCall("/v1/auth/status");
     if (status.usage_today) {
@@ -344,8 +372,155 @@ async function cmdAuthStatus() {
         console.log(`    ${k}: ${v} / ${status.limits[k]}`);
     }
   } catch {
-    console.log("[0dai] Not logged in. Run: 0dai auth login");
+    log("Not logged in. Run: 0dai auth login");
+  }
+}
+
+async function cmdFeedbackPush(target) {
+  const ai = path.join(target, "ai", "feedback");
+  const reports = [];
+  try {
+    for (const f of fs.readdirSync(ai)) {
+      if (f.endsWith("-report.json") || (f.endsWith(".json") && f.match(/^\d{8}/))) {
+        try {
+          const d = JSON.parse(fs.readFileSync(path.join(ai, f), "utf8"));
+          if (d.project || d.verdict) reports.push(d);
+        } catch {}
+      }
+    }
+  } catch {}
+
+  if (!reports.length) { log("no feedback reports found"); return; }
+
+  // Send each report via API
+  for (const report of reports) {
+    log(`pushing: ${report.project || "?"} (${report.verdict || "?"})`);
+    const result = await apiCall("/v1/feedback", { report });
+    if (result.issue) {
+      log(`issue created: ${result.issue}`);
+    } else if (result.received) {
+      log("received by server");
+    } else {
+      log(`error: ${result.error || "unknown"}`);
+    }
+  }
+}
+
+// --- Session (local, file-based) ---
+function cmdSession(target, sub, args) {
+  const sessFile = path.join(target, "ai", "sessions", "active.json");
+  const sessDir = path.dirname(sessFile);
+
+  if (sub === "save") {
+    fs.mkdirSync(sessDir, { recursive: true });
+    const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
+    const summary = args.find((_, i) => args[i - 1] === "--summary") || "";
+    const session = {
+      id: `sess-${Date.now()}`,
+      started: new Date().toISOString(),
+      current_agent: "cli",
+      task: { goal: goal || summary || "active session", status: "in_progress" },
+      handoff_notes: summary,
+      context: { files_touched: [] },
+    };
+    if (fs.existsSync(sessFile)) {
+      const existing = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+      existing.handoff_notes = summary || existing.handoff_notes;
+      if (goal) existing.task.goal = goal;
+      existing.updated = new Date().toISOString();
+      fs.writeFileSync(sessFile, JSON.stringify(existing, null, 2));
+      log("session updated");
+    } else {
+      fs.writeFileSync(sessFile, JSON.stringify(session, null, 2));
+      log(`session started: ${session.id}`);
+    }
+    return;
+  }
+  if (sub === "status") {
+    if (!fs.existsSync(sessFile)) { log("no active session"); return; }
+    const s = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+    log(`session: ${(s.task || {}).goal || "?"}`);
+    console.log(`  agent: ${s.current_agent || "?"}`);
+    if (s.handoff_notes) console.log(`  handoff: ${s.handoff_notes}`);
+    return;
+  }
+  if (sub === "complete") {
+    if (!fs.existsSync(sessFile)) { log("no active session"); return; }
+    const archiveDir = path.join(target, "ai", "sessions", "archive");
+    fs.mkdirSync(archiveDir, { recursive: true });
+    const s = JSON.parse(fs.readFileSync(sessFile, "utf8"));
+    fs.writeFileSync(path.join(archiveDir, `${s.id || "session"}.json`), JSON.stringify(s, null, 2));
+    fs.unlinkSync(sessFile);
+    log(`session ${s.id} archived`);
+    return;
+  }
+  console.log("Usage: 0dai session [save|status|complete] [--goal '...'] [--summary '...']");
+}
+
+// --- Swarm (local, file-based) ---
+function cmdSwarm(target, sub, args) {
+  const swarmDir = path.join(target, "ai", "swarm");
+  const queueDir = path.join(swarmDir, "queue");
+
+  if (sub === "status") {
+    const count = (d) => { try { return fs.readdirSync(d).filter(f => f.endsWith(".json")).length; } catch { return 0; } };
+    const q = count(path.join(swarmDir, "queue"));
+    const a = count(path.join(swarmDir, "active"));
+    const d = count(path.join(swarmDir, "done"));
+    log(`swarm: ${q} queued, ${a} active, ${d} done`);
+    return;
+  }
+  if (sub === "add" || sub === "delegate") {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const task = args.find((_, i) => args[i - 1] === "--task") || "untitled";
+    const forAgent = args.find((_, i) => ["--for", "--to"].includes(args[i - 1])) || "any";
+    const id = `swarm-${Date.now()}`;
+    const t = { id, title: task, assigned_to: forAgent, status: "pending", created_at: new Date().toISOString(), created_by: "cli" };
+    fs.writeFileSync(path.join(queueDir, `${id}.json`), JSON.stringify(t, null, 2));
+    log(`task created: ${id} → ${forAgent}`);
+    return;
+  }
+  if (sub === "budget") {
+    const budgetFile = path.join(swarmDir, "budget.json");
+    if (!fs.existsSync(budgetFile)) { log("no budget data yet"); return; }
+    const b = JSON.parse(fs.readFileSync(budgetFile, "utf8"));
+    log(`total: $${(b.total_spent || 0).toFixed(4)} (${Object.keys(b.tasks || {}).length} tasks)`);
+    return;
+  }
+  console.log("Usage: 0dai swarm [status|add|delegate|budget] [--task '...'] [--to agent]");
+}
+
+// --- Feedback (local + API push) ---
+async function cmdFeedback(target, sub, args) {
+  const fbDir = path.join(target, "ai", "feedback");
+
+  if (sub === "push") {
+    return cmdFeedbackPush(target);
+  }
+  if (sub === "log") {
+    const type = args.find((_, i) => args[i - 1] === "--type") || "suggestion";
+    const detail = args.find((_, i) => args[i - 1] === "--detail") || "";
+    if (!detail) { console.log("Usage: 0dai feedback log --type bug|suggestion|friction|positive --detail '...'"); return; }
+    fs.mkdirSync(fbDir, { recursive: true });
+    const entry = JSON.stringify({ ts: new Date().toISOString(), type, detail, agent: "cli" });
+    fs.appendFileSync(path.join(fbDir, "operational.jsonl"), entry + "\n");
+    log(`logged: [${type}] ${detail.slice(0, 60)}`);
+    return;
+  }
+  if (sub === "list") {
+    try {
+      const files = fs.readdirSync(fbDir).filter(f => f.endsWith("-report.json"));
+      if (!files.length) { log("no reports"); return; }
+      for (const f of files) {
+        try {
+          const d = JSON.parse(fs.readFileSync(path.join(fbDir, f), "utf8"));
+          console.log(`  ${f}: ${d.verdict || "?"} (${d.project || "?"})`);
+        } catch {}
+      }
+    } catch { log("no feedback directory"); }
+    return;
   }
+  console.log("Usage: 0dai feedback [push|log|list] [--type ...] [--detail '...']");
 }
 
 async function main() {
@@ -374,15 +549,21 @@ async function main() {
         console.log("Usage: 0dai auth [login|logout|status]");
       }
       break;
-    case "--version": console.log(`0dai ${VERSION}`); break;
+    case "session": cmdSession(target, sub, args); break;
+    case "swarm": cmdSwarm(target, sub, args); break;
+    case "feedback": await cmdFeedback(target, sub, args); break;
+    case "--version": console.log(`${T}0dai${R} ${VERSION}`); break;
     case "help": case "--help": case "-h":
-      console.log(`0dai v${VERSION} — One config for 5 AI agent CLIs\n`);
+      console.log(`\n  ${T}0dai${R} v${VERSION} — One config for 5 AI agent CLIs\n`);
       console.log("Commands:");
       console.log("  init           Initialize ai/ layer (via API)");
       console.log("  sync           Update ai/ layer (via API)");
       console.log("  detect         Show detected stack");
       console.log("  doctor         Check health");
       console.log("  status         Show maturity, swarm, session");
+      console.log("  session save   Save session for roaming");
+      console.log("  swarm status   Task queue & delegation");
+      console.log("  feedback push  Send feedback to 0dai");
       console.log("  auth login     Authenticate (device code flow)");
       console.log("  auth logout    Remove credentials");
       console.log("  auth status    Show account and usage");
@@ -390,9 +571,9 @@ async function main() {
       console.log("https://0dai.dev");
       break;
     default:
-      console.error(`[0dai] unknown command: ${cmd}. Run '0dai --help'`);
+      log(`unknown command: ${cmd}. Run '0dai --help'`);
       process.exit(1);
   }
 }
 
-main().catch((e) => { console.error(`[0dai] ${e.message}`); process.exit(1); });
+main().catch((e) => { log(`${e.message}`); process.exit(1); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dai-dev/cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider",
   "bin": {
     "0dai": "./bin/0dai.js"