@0dai-dev/cli 4.2.0 → 4.3.4

package/lib/commands/ci.js

@@ -0,0 +1,329 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const shared = require("../shared");
+const { T, R, D, E, G, fs, path, spawnSync, findRepoScript, log } = shared;
+
+const DEFAULT_API_VERSION = "0dai.ci/v0";
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+function readArg(args, name, fallback = "") {
+  const index = args.indexOf(name);
+  if (index >= 0 && args[index + 1]) return args[index + 1];
+  return fallback;
+}
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function pipelineDir(target) {
+  return path.join(target, "ai", "ci", "pipelines");
+}
+
+function controlPlanePath(target) {
+  return path.join(target, "ai", "manifest", "ci-control-plane.json");
+}
+
+function listPipelines(target) {
+  const dir = pipelineDir(target);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((name) => name.endsWith(".json"))
+    .map((name) => {
+      const filePath = path.join(dir, name);
+      const pipeline = readJson(filePath);
+      return {
+        id: pipeline.id || path.basename(name, ".json"),
+        path: filePath,
+        name: pipeline.name || pipeline.id || path.basename(name, ".json"),
+        status: pipeline.status || "unknown",
+        jobs: Array.isArray(pipeline.jobs) ? pipeline.jobs.length : 0,
+      };
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function resolvePipelinePath(target, value) {
+  const requested = value || "0dai-ci";
+  if (requested.endsWith(".json") || requested.includes("/") || requested.includes("\\")) {
+    return path.isAbsolute(requested) ? requested : path.resolve(process.cwd(), requested);
+  }
+  return path.join(pipelineDir(target), `${requested}.json`);
+}
+
+function normalizeNeeds(job) {
+  if (!job.needs) return [];
+  if (Array.isArray(job.needs)) return job.needs.map(String);
+  return [String(job.needs)];
+}
+
+function assertPipelineShape(pipeline) {
+  if (pipeline.error) throw new Error(`invalid pipeline JSON: ${pipeline.error}`);
+  if (pipeline.apiVersion !== DEFAULT_API_VERSION) {
+    throw new Error(`unsupported pipeline apiVersion: ${pipeline.apiVersion || "missing"}`);
+  }
+  if (!pipeline.id || typeof pipeline.id !== "string") throw new Error("pipeline.id is required");
+  if (!Array.isArray(pipeline.jobs) || pipeline.jobs.length === 0) {
+    throw new Error("pipeline.jobs must contain at least one job");
+  }
+  const seen = new Set();
+  for (const job of pipeline.jobs) {
+    if (!job.id || typeof job.id !== "string") throw new Error("each job requires a string id");
+    if (seen.has(job.id)) throw new Error(`duplicate job id: ${job.id}`);
+    seen.add(job.id);
+    if (!Array.isArray(job.run) || job.run.length === 0) {
+      throw new Error(`job ${job.id} requires a non-empty run array`);
+    }
+  }
+}
+
+function topoSortJobs(jobs) {
+  const byId = new Map(jobs.map((job) => [job.id, job]));
+  for (const job of jobs) {
+    for (const dep of normalizeNeeds(job)) {
+      if (!byId.has(dep)) throw new Error(`job ${job.id} needs unknown job ${dep}`);
+    }
+  }
+
+  const order = [];
+  const state = new Map();
+  const stack = [];
+
+  function visit(job) {
+    const current = state.get(job.id);
+    if (current === "done") return;
+    if (current === "visiting") {
+      const cycleStart = stack.indexOf(job.id);
+      const cycle = [...stack.slice(Math.max(cycleStart, 0)), job.id].join(" -> ");
+      throw new Error(`pipeline contains dependency cycle: ${cycle}`);
+    }
+    state.set(job.id, "visiting");
+    stack.push(job.id);
+    for (const dep of normalizeNeeds(job)) visit(byId.get(dep));
+    stack.pop();
+    state.set(job.id, "done");
+    order.push(job);
+  }
+
+  for (const job of jobs) visit(job);
+  return order;
+}
+
+function deterministicJobId({ tenant, pipelineId, sha, jobId, matrixKey }) {
+  return crypto
+    .createHash("sha256")
+    .update([tenant, pipelineId, sha, jobId, matrixKey || ""].join(":"))
+    .digest("hex")
+    .slice(0, 24);
+}
+
+function profileFor(controlPlane, job) {
+  const profiles = ((controlPlane || {}).worker_profiles || {});
+  const id = job.worker_profile || job.profile || "ci-light";
+  return { id, ...(profiles[id] || {}) };
+}
+
+function buildPlan(controlPlane, pipeline, options = {}) {
+  assertPipelineShape(pipeline);
+  const ordered = topoSortJobs(pipeline.jobs);
+  const tenant = String(options.tenant || pipeline.tenant || "0dai");
+  const repo = String(options.repo || pipeline.repo || "iGeezmo/0dai");
+  const sha = String(options.sha || "HEAD");
+  const event = String(options.event || "manual");
+  const jobs = ordered.map((job, index) => {
+    const profile = profileFor(controlPlane, job);
+    const timeout = Number(job.timeout_minutes || 10);
+    const costPerMinute = Number(profile.cost_per_minute_usd || 0);
+    return {
+      order: index + 1,
+      id: job.id,
+      deterministic_id: deterministicJobId({
+        tenant,
+        pipelineId: pipeline.id,
+        sha,
+        jobId: job.id,
+        matrixKey: job.matrix_key || "",
+      }),
+      name: job.name || job.id,
+      lane: job.lane || pipeline.default_lane || "lane-ci-general",
+      worker_profile: profile.id,
+      image: job.image || profile.default_image || "ubuntu:24.04",
+      timeout_minutes: timeout,
+      estimated_max_cost_usd: Number((timeout * costPerMinute).toFixed(4)),
+      needs: normalizeNeeds(job),
+      run: job.run,
+      secrets: job.secrets || [],
+      artifacts: job.artifacts || [],
+    };
+  });
+  const lane_summary = {};
+  for (const job of jobs) {
+    lane_summary[job.lane] = lane_summary[job.lane] || {
+      jobs: 0,
+      timeout_minutes: 0,
+      estimated_max_cost_usd: 0,
+      worker_profiles: [],
+    };
+    lane_summary[job.lane].jobs += 1;
+    lane_summary[job.lane].timeout_minutes += job.timeout_minutes;
+    lane_summary[job.lane].estimated_max_cost_usd = Number(
+      (lane_summary[job.lane].estimated_max_cost_usd + job.estimated_max_cost_usd).toFixed(4),
+    );
+    if (!lane_summary[job.lane].worker_profiles.includes(job.worker_profile)) {
+      lane_summary[job.lane].worker_profiles.push(job.worker_profile);
+    }
+  }
+
+  return {
+    schema_version: 1,
+    command: "ci plan",
+    mode: "read-only-local-plan",
+    warning: "0dai.ci/v0 is unstable and does not execute jobs",
+    issue: "https://github.com/iGeezmo/0dai/issues/2503",
+    tenant,
+    repo,
+    sha,
+    event,
+    pipeline: {
+      apiVersion: pipeline.apiVersion,
+      id: pipeline.id,
+      name: pipeline.name || pipeline.id,
+      status: pipeline.status || "pilot",
+      default_lane: pipeline.default_lane || "lane-ci-general",
+    },
+    control_plane: {
+      apiVersion: (controlPlane || {}).apiVersion || DEFAULT_API_VERSION,
+      phase: (controlPlane || {}).phase || "phase-1-dry-run",
+      queue_backend: ((controlPlane || {}).queue || {}).backend || "planned-do-managed-postgres",
+      mutates_prod: Boolean((controlPlane || {}).mutates_prod),
+    },
+    jobs,
+    lane_summary,
+    safeguards: (controlPlane || {}).safeguards || [],
+    non_scope: (controlPlane || {}).non_scope || [],
+    next_actions: (controlPlane || {}).next_actions || [],
+  };
+}
+
+function printPlanHuman(plan) {
+  console.log(`\n  ${T}0dai CI plan${R}`);
+  console.log(`  pipeline: ${plan.pipeline.id} (${plan.pipeline.status})`);
+  console.log(`  repo: ${plan.repo}`);
+  console.log(`  sha: ${plan.sha}`);
+  console.log(`  mode: ${plan.mode}`);
+  console.log("\n  Jobs");
+  for (const job of plan.jobs) {
+    const deps = job.needs.length ? ` needs=${job.needs.join(",")}` : "";
+    console.log(`  - ${String(job.order).padStart(2, " ")} ${job.id.padEnd(22)} lane=${job.lane} profile=${job.worker_profile}${deps}`);
+  }
+  console.log("\n  Lane summary");
+  for (const [lane, summary] of Object.entries(plan.lane_summary)) {
+    console.log(`  - ${lane}: jobs=${summary.jobs} timeout=${summary.timeout_minutes}m max_cost=$${summary.estimated_max_cost_usd}`);
+  }
+  console.log(`\n  ${D}${plan.warning}${R}\n`);
+}
+
+function runMergeQueueStatus(target, forwarded) {
+  const script = findRepoScript(target, "merge_queue_state.py");
+  if (!script) {
+    log("merge queue state inspector not found");
+    console.log(`  ${D}expected: scripts/merge_queue_state.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`merge queue status failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function cmdCi(target, sub, args) {
+  const command = sub && !sub.startsWith("-") ? sub : "plan";
+  const forwarded = command === sub ? args.slice(2) : args.slice(1);
+  const asJson = hasFlag(forwarded, "--json") || hasFlag(args, "--json");
+
+  if (command === "list") {
+    const pipelines = listPipelines(target);
+    if (asJson) {
+      console.log(JSON.stringify({ schema_version: 1, command: "ci list", pipelines }, null, 2));
+      return;
+    }
+    console.log(`\n  ${T}0dai CI pipelines${R}`);
+    for (const pipeline of pipelines) {
+      console.log(`  - ${pipeline.id.padEnd(18)} status=${pipeline.status} jobs=${pipeline.jobs}`);
+    }
+    if (!pipelines.length) console.log(`  ${D}no pipelines found in ai/ci/pipelines${R}`);
+    console.log("");
+    return;
+  }
+
+  if (command === "mq-status") {
+    runMergeQueueStatus(target, forwarded);
+    return;
+  }
+
+  if (command !== "plan") {
+    console.log("Usage: 0dai ci [list|plan|mq-status] [--pipeline ID|PATH] [--repo OWNER/REPO] [--sha SHA] [--event EVENT] [--json]");
+    process.exitCode = 1;
+    return;
+  }
+
+  const manifest = readJson(controlPlanePath(target));
+  if (manifest.error) {
+    log(`ci-control-plane manifest not found or invalid: ${manifest.error}`);
+    console.log(`  ${D}expected: ai/manifest/ci-control-plane.json${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const pipelinePath = resolvePipelinePath(target, readArg(forwarded, "--pipeline", "0dai-ci"));
+  const pipeline = readJson(pipelinePath);
+  if (pipeline.error) {
+    log(`pipeline not found or invalid: ${pipeline.error}`);
+    console.log(`  ${D}expected: ai/ci/pipelines/<id>.json or a JSON path${R}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const plan = buildPlan(manifest, pipeline, {
+      tenant: readArg(forwarded, "--tenant", ""),
+      repo: readArg(forwarded, "--repo", ""),
+      sha: readArg(forwarded, "--sha", ""),
+      event: readArg(forwarded, "--event", ""),
+    });
+    if (asJson) {
+      console.log(JSON.stringify(plan, null, 2));
+      return;
+    }
+    printPlanHuman(plan);
+  } catch (err) {
+    log(`ci plan failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  buildPlan,
+  cmdCi,
+  deterministicJobId,
+  topoSortJobs,
+};

package/lib/commands/compliance.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const shared = require("../shared");
+const { D, R, findRepoScript, log, spawnSync } = shared;
+
+function cmdCompliance(target, args) {
+  const complianceScript = findRepoScript(target, "compliance_report.py");
+  if (!complianceScript) {
+    log("compliance helper unavailable in this environment");
+    console.log(`  ${D}Expected scripts/compliance_report.py in repo checkout${R}`);
+    process.exit(1);
+  }
+
+  const forwarded = [complianceScript, ...args, "--target", target];
+  const result = spawnSync("python3", forwarded, { stdio: "inherit" });
+  if (typeof result.status === "number") process.exit(result.status);
+  process.exit(1);
+}
+
+module.exports = { cmdCompliance };

package/lib/commands/doctor.js

@@ -2,6 +2,24 @@
 const shared = require("../shared");
 const { log, T, R, D, fs, path, spawnSync, findRepoScript, SUPPORTED_CLIS, recordExperienceEvent } = shared;
 
+function ghostAuthStatus(home = process.env.HOME || process.env.USERPROFILE || "") {
+  const customApiEnv = home ? path.join(home, ".custom-api", "custom-api.env") : "";
+  const legacyAnthropicEnv = home ? path.join(home, ".claude-api-isolated", "anthropic.env") : "";
+  const present = Boolean(customApiEnv && fs.existsSync(customApiEnv));
+  const legacyPresent = Boolean(legacyAnthropicEnv && fs.existsSync(legacyAnthropicEnv));
+
+  return {
+    name: "ghost-auth",
+    present,
+    sev: present ? "ok" : "warn",
+    hint: present
+      ? "~/.custom-api/custom-api.env present for ghost ensemble"
+      : legacyPresent
+        ? "legacy ~/.claude-api-isolated/anthropic.env exists, but ghost now requires ~/.custom-api/custom-api.env"
+        : "create ~/.custom-api/custom-api.env so ghost ensemble can spawn",
+  };
+}
+
 function cmdDoctor(target, options = {}) {
   const ai = path.join(target, "ai");
   if (!fs.existsSync(ai)) { log("No 0dai config found. Run: 0dai init"); return; }
@@ -61,6 +79,7 @@ function cmdDoctor(target, options = {}) {
       sev: process.env.GITHUB_TOKEN ? "ok" : "info",
       hint: "Optional — for gh CLI, PR creation",
     },
+    ghostAuthStatus(),
   ];
 
   // Stack-specific creds
@@ -237,4 +256,4 @@ function cmdDoctor(target, options = {}) {
   }
 }
 
-module.exports = { cmdDoctor };
+module.exports = { cmdDoctor, ghostAuthStatus };

package/lib/commands/experience.js

@@ -30,6 +30,10 @@ function cmdExperience(target, sub, args) {
     if (periodIdx >= 0 && args[periodIdx + 1]) forwarded.push("--period", args[periodIdx + 1]);
     const byIdx = args.indexOf("--by");
     if (byIdx >= 0 && args[byIdx + 1]) forwarded.push("--by", args[byIdx + 1]);
+  } else if (command === "sync") {
+    if (args.includes("--json")) forwarded.push("--json");
+    const limitIdx = args.indexOf("--limit");
+    if (limitIdx >= 0 && args[limitIdx + 1]) forwarded.push("--limit", args[limitIdx + 1]);
   } else if (command === "warnings") {
     const detectorScript = findRepoScript(target, "anti_pattern_detector.py");
     if (!detectorScript) { log("anti-pattern detector unavailable"); process.exit(1); }
@@ -53,7 +57,7 @@ function cmdExperience(target, sub, args) {
     if (typeof dr.status === "number") process.exit(dr.status);
     process.exit(1);
   } else {
-    console.log("Usage: 0dai experience [list|stats|warnings|dismiss]");
+    console.log("Usage: 0dai experience [list|stats|sync|warnings|dismiss]");
     process.exit(1);
   }
 

package/lib/commands/feedback.js

@@ -1,6 +1,37 @@
 "use strict";
 const shared = require("../shared");
-const { log, T, R, D, fs, path, apiCall } = shared;
+const { log, T, R, D, fs, path, apiCall, CONFIG_DIR } = shared;
+
+function writeFeedbackOutbox(target, report, result) {
+  const outboxDir = path.join(CONFIG_DIR, "feedback-outbox");
+  fs.mkdirSync(outboxDir, { recursive: true, mode: 0o700 });
+  const safeName = path.basename(target).replace(/[^a-zA-Z0-9._-]+/g, "_") || "project";
+  const outboxPath = path.join(outboxDir, `${safeName}-${Date.now()}-${process.pid}.json`);
+  fs.writeFileSync(outboxPath, JSON.stringify({
+    queued_at: new Date().toISOString(),
+    project: path.basename(target),
+    report,
+    error: result && result.error ? result.error : "feedback endpoint did not acknowledge receipt",
+    response: result || null,
+  }, null, 2) + "\n", { mode: 0o600 });
+  return outboxPath;
+}
+
+function listFeedbackOutbox() {
+  const outboxDir = path.join(CONFIG_DIR, "feedback-outbox");
+  try {
+    return fs.readdirSync(outboxDir)
+      .filter((name) => name.endsWith(".json"))
+      .sort()
+      .map((name) => path.join(outboxDir, name));
+  } catch {
+    return [];
+  }
+}
+
+function feedbackAccepted(result) {
+  return Boolean(result && (result.received || result.ok));
+}
 
 async function cmdFeedbackPush(target) {
   const fbDir = path.join(target, "ai", "feedback");
@@ -44,17 +75,70 @@ async function cmdFeedbackPush(target) {
   };
   log(`pushing ${items.length} feedback item(s)...`);
   const result = await apiCall("/v1/feedback", { report });
-  if (result.received) {
+  if (feedbackAccepted(result)) {
     log(`received${result.issue ? `: ${result.issue}` : ""}`);
     if (result.bonus) log(`${T}bonus:${R} ${result.bonus}`);
+    if (result.warning) console.log(`  ${D}${result.warning}${R}`);
+    if (result.issue_error) console.log(`  ${D}issue warning: ${result.issue_error}${R}`);
     // Archive pushed entries
     if (fs.existsSync(jsonlPath)) {
       const archivePath = path.join(fbDir, `pushed-${Date.now()}.jsonl`);
       fs.renameSync(jsonlPath, archivePath);
     }
   } else {
-    log(`error: ${result.error || "unknown"}`);
+    const outboxPath = writeFeedbackOutbox(target, report, result);
+    log(`error: ${(result && result.error) || "unknown"}`);
+    console.log(`  ${D}queued for retry: ${outboxPath}${R}`);
+    console.log(`  ${D}source feedback was left in place${R}`);
+    process.exitCode = 1;
+  }
+}
+
+async function cmdFeedbackRetry(args = []) {
+  const files = listFeedbackOutbox();
+  const json = args.includes("--json");
+  if (!files.length) {
+    if (json) console.log(JSON.stringify({ retried: 0, remaining: 0 }, null, 2));
+    else log("no queued feedback");
+    return;
+  }
+
+  let retried = 0;
+  const failed = [];
+  for (const file of files) {
+    let queued = null;
+    try {
+      queued = JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch (err) {
+      failed.push({ file, error: `invalid outbox file: ${err.message || err}` });
+      continue;
+    }
+
+    const report = queued.report || (queued.payload && queued.payload.report);
+    if (!report) {
+      failed.push({ file, error: "outbox file is missing report" });
+      continue;
+    }
+
+    const result = await apiCall("/v1/feedback", { report });
+    if (feedbackAccepted(result)) {
+      try { fs.unlinkSync(file); } catch {}
+      retried++;
+      if (!json) log(`retried: ${path.basename(file)}${result.issue ? ` -> ${result.issue}` : ""}`);
+    } else {
+      failed.push({ file, error: (result && result.error) || "unknown", response: result || null });
+    }
+  }
+
+  if (json) {
+    console.log(JSON.stringify({ retried, remaining: failed.length, failed }, null, 2));
+  } else {
+    log(`retry complete: ${retried} sent, ${failed.length} remaining`);
+    for (const item of failed.slice(0, 5)) {
+      console.log(`  ${D}${path.basename(item.file)}: ${item.error}${R}`);
+    }
   }
+  if (failed.length) process.exitCode = 1;
 }
 
 async function cmdFeedback(target, sub, args) {
@@ -63,6 +147,9 @@ async function cmdFeedback(target, sub, args) {
   if (sub === "push") {
     return cmdFeedbackPush(target);
   }
+  if (sub === "retry") {
+    return cmdFeedbackRetry(args);
+  }
   if (sub === "log") {
     const type = args.find((_, i) => args[i - 1] === "--type") || "suggestion";
     const detail = args.find((_, i) => args[i - 1] === "--detail") || "";
@@ -86,7 +173,7 @@ async function cmdFeedback(target, sub, args) {
     } catch { log("no feedback directory"); }
     return;
   }
-  console.log("Usage: 0dai feedback [push|log|list] [--type ...] [--detail '...']");
+  console.log("Usage: 0dai feedback [push|retry|log|list] [--type ...] [--detail '...']");
 }
 
-module.exports = { cmdFeedbackPush, cmdFeedback };
+module.exports = { cmdFeedbackPush, cmdFeedbackRetry, cmdFeedback, writeFeedbackOutbox, listFeedbackOutbox, feedbackAccepted };