@niroai/niro 0.3.0

package/src/commands/status.js

@@ -0,0 +1,75 @@
+const api = require("../lib/api");
+const credentials = require("../lib/credentials");
+const color = require("../lib/color");
+const watchState = require("../lib/watchState");
+const watchDaemon = require("../lib/watchDaemon");
+const resolveProject = require("./_resolveProject");
+
+function tintStatus(st) {
+  if (st === "COMPLETED") return color.green(st);
+  if (st === "FAILED" || st === "CANCELLED") return color.red(st);
+  if (st === "PROCESSING" || st === "RUNNING") return color.yellow(st);
+  if (st === "PENDING") return color.gray(st);
+  return st;
+}
+
+/**
+ * Daemon state for the status output, or null when this machine has no
+ * locally-synced folders on the current backend (then the daemon is
+ * irrelevant and a "not installed" line would be a false alarm — e.g. a
+ * user who only indexes remote repos).
+ *
+ * Probing the daemon spawns pm2; only worth it when there's something to sync.
+ */
+function autoSyncState() {
+  if (watchState.allLocal(api.currentBaseUrl()).length === 0) return null;
+  return watchDaemon.watchDaemonState();
+}
+
+// Human-readable rendering per watchDaemonState() value. Every non-running
+// state names the exact command that fixes it — this line exists so a broken
+// auto-sync is visible in the command we tell users to run after init.
+const AUTO_SYNC_LINES = {
+  running: color.green("running") + color.dim(" — synced folders stay up to date automatically"),
+  stopped: color.yellow("stopped — run `niro service install` to restart it"),
+  not_installed: color.yellow("not installed — run `niro service install`"),
+  pm2_missing: color.yellow("OFF — PM2 is missing. Run `npm install -g pm2`, then `niro service install`"),
+};
+
+async function status(projectIdArg, opts = {}) {
+  credentials.requireCreds();
+  const projectId = await resolveProject.resolveProjectId(projectIdArg, { apiUrl: opts.apiUrl });
+  const data = await api.get(`/api/graph/${encodeURIComponent(projectId)}/status`);
+  const logMessage = data.log_message || data.logMessage;
+  const docGenStatus = data.doc_gen_status || data.docGenStatus;
+  const docGenMessage = data.doc_gen_message || data.docGenMessage;
+  const updatedAt = data.updated_at || data.updatedAt;
+  const autoSync = autoSyncState();
+
+  if (opts.json) {
+    console.log(
+      JSON.stringify({
+        project_id: projectId,
+        status: data.status || null,
+        log_message: logMessage || null,
+        doc_gen_status: docGenStatus || null,
+        doc_gen_message: docGenMessage || null,
+        updated_at: updatedAt || null,
+        auto_sync: autoSync,
+      })
+    );
+    return;
+  }
+
+  const label = (s) => color.dim(s.padEnd(13));
+  console.log(`${label("Project:")} ${color.bold(projectId)}`);
+  console.log(`${label("Status:")} ${tintStatus(data.status || "(unknown)")}`);
+  if (logMessage) console.log(`${label("Last message:")} ${logMessage}`);
+  if (docGenStatus) {
+    console.log(`${label("Docs:")} ${tintStatus(docGenStatus)}${docGenMessage ? " — " + docGenMessage : ""}`);
+  }
+  if (updatedAt) console.log(`${label("Updated:")} ${color.dim(updatedAt)}`);
+  if (autoSync) console.log(`${label("Auto-sync:")} ${AUTO_SYNC_LINES[autoSync] || autoSync}`);
+}
+
+module.exports = { status };

package/src/commands/takeover.js

@@ -0,0 +1,204 @@
+/**
+ * `niro new-temp-project [path]` — create a private temporary project for the current folder's project
+ * (ADR-013, routing per ADR-018).
+ *
+ * The folder's git remote is matched to a Niro project P; the server clones P into a new working-copy
+ * project P' (graph + analysis state copied, no re-parse/LLM), converting THIS folder's repo to
+ * AGENT_UPLOAD. The working tree (including uncommitted edits and any local branch) is then uploaded and
+ * the watch daemon streams every subsequent save into P'.
+ *
+ * ADR-018: the `.niro-project` pin is NEVER touched — it stays on the shared source project. The SERVER
+ * routes each MCP call to P' from (git url, current branch, you), so switching branches re-routes by
+ * itself and there is no pin to go stale, leak into a commit, or restore later.
+ *
+ * Undo with `niro discard-temp-project` (deletes P'; routing falls back to P automatically).
+ */
+const api = require("../lib/api");
+const color = require("../lib/color");
+const folderSync = require("../lib/folderSync");
+const agentApi = require("../lib/agentApi");
+const git = require("../lib/git");
+const prompt = require("../lib/prompt");
+const watchState = require("../lib/watchState");
+const resolveCtxLib = require("../lib/resolveContext");
+
+const ok = (s) => color.green(s);
+const warn = (s) => color.yellow(s);
+const step = (s) => color.cyan(s);
+
+async function takeover(pathArg, opts = {}) {
+  // --api-url is threaded only into project resolution, not the clone/build POSTs or the agentApi upload
+  // chain — so a global `--api-url X` would resolve against X but clone/upload/watch-tag against the DEFAULT
+  // backend, mixing two stacks in one flow. Fail fast BEFORE any server mutation rather than corrupt state
+  // across backends. (Full per-backend threading is future work; set the default backend via login/config.)
+  if (opts.apiUrl) {
+    throw new Error("`--api-url` is not supported for `niro new-temp-project` yet (it would mix backends). "
+        + "Select the backend with `niro login` / your config first, then run this without --api-url.");
+  }
+  const targetDir = require("path").resolve(pathArg || process.cwd());
+  const { repoRoot, branch } = git.inspect(targetDir);
+  if (!repoRoot) {
+    throw new Error("Not a git repository — run takeover inside the repo you want to work on.");
+  }
+
+  // 1. Match this folder to a source project (working copies are excluded server-side).
+  const ctx = await resolveCtxLib.resolveContext(targetDir, { apiUrl: opts.apiUrl });
+  if (ctx.state === "error") throw new Error(`Could not resolve project: ${ctx.error}`);
+  if (!ctx.projects.length) {
+    throw new Error("This folder's git remote doesn't match any Niro project. Run `niro init` first.");
+  }
+  let source = ctx.projects[0];
+  if (opts.project) {
+    source = ctx.projects.find((p) => p.project_id === opts.project || p.alias === opts.project);
+    if (!source) {
+      throw new Error(`--project "${opts.project}" does not match any project mapped to this repo.`);
+    }
+  } else if (ctx.projects.length > 1) {
+    if (prompt.isNonInteractive()) {
+      const list = ctx.projects.map((p) => `  ${p.project_id} (${p.alias})`).join("\n");
+      throw new Error(`Multiple projects match this repo — pass --project:\n${list}`);
+    }
+    console.log("\n  Multiple projects match this repo:");
+    ctx.projects.forEach((p, i) => console.log(`    ${i + 1}. ${p.alias || "(no alias)"} ${color.dim(p.project_id)}`));
+    const answer = await prompt.ask(`  Take over which one? [1-${ctx.projects.length}]`, "1");
+    const idx = parseInt(answer, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= ctx.projects.length) {
+      throw new Error(`Invalid choice: ${answer}`);
+    }
+    source = ctx.projects[idx];
+  }
+  if (!source.git_id) {
+    throw new Error("Server did not report which repo of the project matches this folder (git_id missing).");
+  }
+
+  console.log(`\n  Creating a temporary private project of ${color.bold(source.alias || source.project_id)}...`);
+  console.log(color.dim("  Your teammates' view of the project is not affected."));
+
+  // 2. Create-or-extend server-side (ADR-016). If you already have a temporary project of this project,
+  // the backend EXTENDS it — adds this repo to the same copy — instead of minting a second one, so
+  // cross-repo answers stay coherent. Either way this folder's repo becomes AGENT_UPLOAD.
+  const outcome = await api.post(
+    `/api/projects/${encodeURIComponent(source.project_id)}/clone`,
+    { local_git_ids: [source.git_id], branch });
+  const newProjectId = outcome.new_project_id || outcome.newProjectId;
+  const gitIdMap = outcome.git_id_map || outcome.gitIdMap || {};
+  const newGitId = gitIdMap[source.git_id];
+  if (!newProjectId || !newGitId) {
+    throw new Error("Clone succeeded but the response is missing new_project_id/git_id_map.");
+  }
+  // Whether this call extended an existing temporary project or created one — drives messaging AND rollback:
+  // an extend must NEVER be rolled back by deleting the copy (it holds your other repos' work).
+  const wasExtended = outcome.extended === true;
+  // ADR-018 version guard (review BLOCKER): this CLI never re-pins — it relies on the SERVER routing
+  // calls to the temp project. A pre-ADR-018 backend clones happily but has no routing, so every answer
+  // would silently keep coming from the stale source. The backend echoes routing_supported when it can
+  // route; its absence means a version mismatch the user must hear about NOW, not discover via wrong answers.
+  const serverRoutes = outcome.routing_supported === true || outcome.routingSupported === true;
+  if (!serverRoutes) {
+    console.log(warn("\n  ⚠ Your backend did NOT confirm automatic routing (pre-ADR-018 server?)."));
+    console.log(warn("    This CLI no longer re-pins .niro-project, so against this backend Niro's answers"));
+    console.log(warn("    will KEEP coming from the original project — NOT this temporary project."));
+    console.log(warn("    Fix: upgrade the backend (ai-assistant + ai-orchestrator), or use the previous CLI."));
+  }
+  if (wasExtended) {
+    console.log(`  ${step("●")}  Added this repo to your temporary project: ${color.bold(outcome.alias || newProjectId)} ` +
+        color.dim("(existing copy extended — your other repos are untouched)"));
+  } else {
+    console.log(`  ${step("●")}  Temporary project created: ${color.bold(outcome.alias || newProjectId)} ` +
+        color.dim(`(${outcome.nodes_copied ?? "?"} nodes copied, no re-index needed)`));
+  }
+
+  // From here on the temporary project EXISTS server-side: any failure below must roll it back, or the
+  // user is left with an orphan project they can't `niro discard-temp-project` (the pin was never written).
+  try {
+    // 3. Upload the working tree (uncommitted edits and local branch included). Operate on the git
+    // ROOT, not targetDir: the temp project is the whole repo, so running from a SUBDIR must still upload,
+    // pin, and watch the entire repo (targetDir is only used above to locate the repo + resolve the project).
+    const manifest = folderSync.buildManifest(repoRoot);
+    const filterResult = await agentApi.filterManifest(newGitId, manifest);
+    const includedPaths = filterResult.included_paths || filterResult.includedPaths || [];
+    const sizes = {};
+    for (const m of manifest) sizes[m.path] = m.size_bytes;
+    console.log(`  ${step("●")}  Uploading working tree: ${includedPaths.length} files ` +
+        `(branch ${color.cyan(branch || "detached HEAD")})...`);
+    // Capture the uploaded hashes: takeover registers its watchState entry AFTER this upload (below), so
+    // doInitialSync's own watchState.update no-ops (no entry yet). Seeding these into the final set means
+    // the watch daemon delta-syncs from HERE instead of re-uploading the entire tree on its first pass.
+    const uploadedHashes = await folderSync.doInitialSync(newGitId, repoRoot, includedPaths, { sizes }) || {};
+
+    // 3b. Trigger an incremental build so the uploaded tree gets indexed even when the project's
+    // auto-sync is disabled (staleness alone does not schedule a build in that case).
+    try {
+      await api.post(`/api/graph/${encodeURIComponent(newProjectId)}/build`, {}, {
+        query: { force_full_rebuild: "false" },
+      });
+      console.log(`  ${step("●")}  Incremental index of your working tree triggered.`);
+    } catch (buildErr) {
+      console.log(warn(`  ⚠ Could not trigger the index build automatically (${buildErr.message}). ` +
+          "Run `niro build` to index your uploaded tree."));
+    }
+
+    // 4. Register the folder for the watch daemon and record the undo state. ADR-018: the
+    // `.niro-project` pin is NEVER touched — it stays on the shared source project, and the
+    // SERVER routes each call to your temp project from (git url, branch, you). No pin swap
+    // means no stale pin, no accidental commit of a private id, and nothing to restore later.
+    // (Requires an ADR-018 backend; against an older server keep the older CLI.)
+    const existing = watchState.get(repoRoot, api.currentBaseUrl());
+    // Preserve the ORIGINAL pre-takeover backup across re-runs: if this folder was ALREADY taken over,
+    // `existing.gitId` is the CLONE's id, not the source's — capturing it would make a later
+    // `niro discard-temp-project` restore point at the clone instead of the real source project.
+    const priorBackup = existing && existing.takeover ? existing.takeover : null;
+    watchState.set(repoRoot, {
+      ...(existing || { includePatterns: [], excludePatterns: [], lastSyncedAt: null }),
+      // Seed the just-uploaded hashes so the daemon delta-syncs from here (not a full re-upload).
+      fileHashes: uploadedHashes,
+      lastSyncedAt: new Date().toISOString(),
+      gitId: newGitId,
+      projectId: newProjectId,
+      branch: branch || null,
+      takeover: {
+        sourceProjectId: source.project_id,
+        sourceGitId: source.git_id,
+        // The SOURCE branch (what the project indexes) — the discard guard compares each folder's
+        // CURRENT branch against this to warn before deleting a temp project that still covers
+        // in-flight work on a sibling repo. NOTE: resolveContext's normalizeProjects renames the
+        // server's `branch` to `indexed_branch` — reading `.branch` here was ALWAYS undefined and
+        // silently killed the guard (review BLOCKER, masked by a mock with an impossible shape).
+        sourceBranch: source.indexed_branch || source.branch
+            || (priorBackup ? priorBackup.sourceBranch : null) || null,
+        // Legacy pin backup: only carried forward from a PRE-ADR-018 takeover of this folder
+        // (whose pin was swapped and still needs healing on discard). New takeovers never touch
+        // the pin, so there is nothing to back up.
+        previousPin: priorBackup ? priorBackup.previousPin : undefined,
+        previousGitId: priorBackup ? priorBackup.previousGitId : (existing ? existing.gitId : null),
+      },
+    }, api.currentBaseUrl());
+  } catch (err) {
+    if (wasExtended) {
+      // We EXTENDED an existing temporary project that already holds your OTHER repos' taken-over work.
+      // Deleting it would destroy that — so never roll back by release here. The extend is idempotent
+      // (the repo is already AGENT_UPLOAD server-side), so re-running just retries the upload.
+      throw new Error(`Adding this repo to your temporary project failed after it was taken over (${err.message}). ` +
+          "Your temporary project was NOT deleted (it holds your other repos). Re-run `niro new-temp-project` here to retry.");
+    }
+    // Created a fresh temporary project — roll it back so no orphan project is left behind.
+    try {
+      await api.post(`/api/projects/${encodeURIComponent(newProjectId)}/clone/release`, {});
+      throw new Error(`Temporary project creation failed after the temporary project was created (${err.message}). ` +
+          "The temporary project was rolled back — fix the problem and re-run `niro new-temp-project`.");
+    } catch (rollbackErr) {
+      if (rollbackErr.message && rollbackErr.message.includes("rolled back")) throw rollbackErr;
+      throw new Error(`Temporary project creation failed (${err.message}) AND rollback of the temporary project failed ` +
+          `(${rollbackErr.message}). Delete it manually: ` +
+          `POST /api/projects/${newProjectId}/clone/release (or from the Niro UI).`);
+    }
+  }
+
+  console.log(`\n  ${ok("✓")} Niro now answers from your temporary project whenever you are on this branch`);
+  console.log(color.dim("    (routing is automatic per branch — your .niro-project file was NOT changed)."));
+  console.log(`  ${ok("✓")} Local edits stream in live while ${color.bold("niro watch")} is running.`);
+  console.log(color.dim("\n  When your branch is merged: `niro discard-temp-project` deletes the temporary project;"));
+  console.log(color.dim("  routing falls back to the original project by itself."));
+}
+
+module.exports = { takeover };