@niroai/niro 0.3.0

package/src/commands/add-repo.js

@@ -0,0 +1,270 @@
+/**
+ * `niro add repo [path]` — register a local folder or remote URL and start syncing.
+ *
+ * Local folder flow:
+ *   1. Detect .git → offer "local changes" vs "remote commits" sync mode
+ *   2. Submit folder manifest → server returns include/exclude filter
+ *   3. Show filter to user; let them adjust patterns
+ *   4. Register repo on server (allocates workspace dir) → get gitId
+ *   5. Initial sync: walk included files → batch upload → complete
+ *   6. Transition into watch mode (stays in foreground)
+ *
+ * Remote URL flow:
+ *   Delegates to existing POST /api/git/remote-repos (same as UI).
+ */
+const path = require("path");
+const fs = require("fs");
+const api = require("../lib/api");
+const agentApi = require("../lib/agentApi");
+const watchState = require("../lib/watchState");
+const credentials = require("../lib/credentials");
+const prompt = require("../lib/prompt");
+const git = require("../lib/git");
+const folderSync = require("../lib/folderSync");
+const { startWatch } = require("./watch");
+const color = require("../lib/color");
+const watchDaemon = require("../lib/watchDaemon");
+const { login } = require("./login");
+
+async function addRepo(pathArg, opts = {}) {
+  const creds = await ensureLoggedIn(opts);
+  if (!creds) return;
+
+  // Backend the CLI is pointed at — scopes watchState so a cached gitId from
+  // another stack is never reused here.
+  const currentApiUrl = api.currentBaseUrl();
+
+  const targetRaw = pathArg || ".";
+
+  // Remote URL?
+  if (targetRaw.startsWith("http://") || targetRaw.startsWith("https://") || targetRaw.startsWith("git@")) {
+    await addRemoteRepo(targetRaw, opts);
+    return;
+  }
+
+  const targetDir = path.isAbsolute(targetRaw) ? path.resolve(targetRaw) : path.resolve(process.cwd(), targetRaw);
+  if (!fs.existsSync(targetDir) || !fs.statSync(targetDir).isDirectory()) {
+    console.error(color.red(`Not a directory: ${targetDir}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  // --sync-mode local|remote skips the interactive [1]/[2] sync-type choice.
+  // --no-confirm skips any confirmation prompt.
+  const syncMode = parseSyncMode(opts.syncMode);
+  const noConfirm = opts.confirm === false; // commander sets confirm:false for --no-confirm
+
+  // Check for existing registration on THIS backend
+  const existing = watchState.get(targetDir, currentApiUrl);
+  if (existing && existing.gitId) {
+    const reuse = noConfirm
+      ? true
+      : await prompt.confirm(
+          `  This folder is already registered (gitId: ${color.dim(existing.gitId)}). Re-sync without re-registering?`,
+          true
+        );
+    if (reuse) {
+      await startWatch(targetDir, opts);
+      return;
+    }
+  }
+
+  const gitInfo = git.inspect(targetDir);
+  let isLocalSync = true;
+  let branch = opts.branch || null;
+
+  if (gitInfo.repoRoot) {
+    console.log(`\n  Detected a git repository.`);
+    let choice;
+    if (syncMode) {
+      choice = syncMode === "remote" ? "2" : "1";
+    } else if (noConfirm || prompt.isNonInteractive()) {
+      choice = "1"; // default to local sync without prompting
+    } else {
+      choice = await prompt.ask(
+        `  Sync on: [1] local file changes  [2] commits to remote`,
+        "1"
+      );
+    }
+    if (choice.trim() === "2") {
+      // Register as remote repo using the origin URL
+      if (!gitInfo.originUrl) {
+        console.error(color.red("  No remote origin found. Cannot register as remote repo."));
+        process.exitCode = 1;
+        return;
+      }
+      await addRemoteRepo(gitInfo.originUrl, { ...opts, branch: branch || gitInfo.branch });
+      return;
+    }
+    // Local sync: auto-detect branch
+    if (!branch && gitInfo.branch) {
+      const confirmed = (noConfirm || prompt.isNonInteractive())
+        ? true
+        : await prompt.confirm(
+            `  Detected branch: ${color.cyan(gitInfo.branch)}. Use this?`,
+            true
+          );
+      branch = confirmed ? gitInfo.branch : await prompt.ask("  Branch name", "main");
+    }
+  }
+
+  if (!branch) branch = null; // no git, branch not applicable
+
+  const folderName = path.basename(targetDir);
+  const displayName = opts.name
+    || ((noConfirm || prompt.isNonInteractive())
+      ? folderName
+      : await prompt.ask("  Repo display name", folderName));
+
+  // Build manifest
+  process.stdout.write(`\n  Scanning ${color.cyan(targetDir)}...`);
+  const manifest = folderSync.buildManifest(targetDir);
+  process.stdout.write(` ${manifest.length} files found.\n`);
+
+  // Get server filter
+  let gitId;
+  let includePatterns;
+  let excludePatterns;
+
+  // Register first (server allocates workspace dir) so we can call /filter
+  console.log(`  Registering repo with server...`);
+  const cliModuleExcludes = Array.isArray(opts.moduleExclude) ? opts.moduleExclude : [];
+  const cliFileExcludes = Array.isArray(opts.fileExclude) ? opts.fileExclude : [];
+  gitId = await agentApi.registerRepo({
+    displayName,
+    repositoryUrl: gitInfo.originUrl || `local://${displayName}`,
+    branch,
+    moduleExcludePatterns: cliModuleExcludes,
+    fileExcludePatterns: cliFileExcludes,
+  });
+  console.log(`  gitId: ${color.dim(gitId)}`);
+
+  // Offer backend-suggested module exclusions (skipped if --defaults or
+  // --module-exclude already supplied or stdin is non-interactive).
+  const { offerModuleExcludeSuggestions } = require("../lib/moduleExcludeSuggestions");
+  await offerModuleExcludeSuggestions(gitId, opts, cliModuleExcludes);
+
+  // Get filter recommendation
+  console.log(`  Analyzing project structure...`);
+  const filterResult = await agentApi.filterManifest(gitId, manifest);
+  const includedCount = filterResult.included_count || filterResult.includedCount || 0;
+  const excludedCount = filterResult.excluded_count || filterResult.excludedCount || 0;
+
+  console.log(`\n  ${color.green("Will sync:")}  ${includedCount} files`);
+  console.log(`  ${color.yellow("Excluded:")}   ${excludedCount} files`);
+
+  const suggestedIncludes = filterResult.include_patterns || filterResult.includePatterns || [];
+  const suggestedExcludes = filterResult.exclude_patterns || filterResult.excludePatterns || [];
+
+  if (suggestedIncludes.length > 0) {
+    console.log(`  Include patterns: ${color.dim(suggestedIncludes.join(", "))}`);
+  }
+  if (suggestedExcludes.length > 0) {
+    console.log(`  Exclude patterns: ${color.dim(suggestedExcludes.join(", "))}`);
+  }
+
+  const adjust = (noConfirm || prompt.isNonInteractive())
+    ? false
+    : await prompt.confirm("  Adjust patterns?", false);
+  if (adjust) {
+    const addIncludes = await prompt.ask("  Add include patterns (comma-separated, e.g. src/**)", "");
+    const addExcludes = await prompt.ask("  Add exclude patterns (comma-separated, e.g. docs/**)", "");
+    if (addIncludes) suggestedIncludes.push(...addIncludes.split(",").map(s => s.trim()).filter(Boolean));
+    if (addExcludes) suggestedExcludes.push(...addExcludes.split(",").map(s => s.trim()).filter(Boolean));
+  }
+
+  includePatterns = suggestedIncludes;
+  excludePatterns = suggestedExcludes;
+
+  // Determine which files to actually upload
+  const includedPaths = (filterResult.included_paths || filterResult.includedPaths || []);
+
+  // Save state, tagged with the backend that allocated this gitId.
+  watchState.set(targetDir, {
+    gitId,
+    projectId: null,
+    branch,
+    includePatterns,
+    excludePatterns,
+    fileHashes: {},
+    lastSyncedAt: null,
+  }, currentApiUrl);
+
+  // Push include/exclude patterns to the server so the build pipeline respects them.
+  // We use module_path "" (root) since there is no build-file detected module yet.
+  if (includePatterns.length > 0 || excludePatterns.length > 0) {
+    try {
+      await api.put(`/api/git/${encodeURIComponent(gitId)}/module-resolution`, {
+        module_path: "",
+        include_dirs: includePatterns,
+        excluded: excludePatterns,
+      });
+    } catch (err) {
+      console.log(color.yellow(`  ⚠ Could not save patterns to server: ${err.message}`));
+    }
+  }
+
+  // Initial sync (concurrent + resilient uploader lives in folderSync)
+  await folderSync.doInitialSync(gitId, targetDir, includedPaths);
+
+  // Install / restart the watch daemon so this repo is picked up automatically
+  // (shared flow — offers to install PM2 when it's missing, unless --no-confirm
+  // promised not to prompt).
+  await watchDaemon.ensureWatchDaemon({ skipPrompts: noConfirm });
+}
+
+async function addRemoteRepo(url, opts) {
+  const noConfirm = opts.confirm === false;
+  const branch = opts.branch
+    || ((noConfirm || prompt.isNonInteractive()) ? "main" : await prompt.ask("  Branch", "main"));
+  const tokenId = opts.tokenId || null;
+  const cliModuleExcludes = Array.isArray(opts.moduleExclude) ? opts.moduleExclude : [];
+  const cliFileExcludes = Array.isArray(opts.fileExclude) ? opts.fileExclude : [];
+
+  console.log(`  Registering remote repo: ${color.cyan(url)} (branch: ${branch})`);
+  const reqBody = { repository_url: url, branch, token_id: tokenId };
+  if (cliModuleExcludes.length > 0) reqBody.module_exclude_patterns = cliModuleExcludes;
+  if (cliFileExcludes.length > 0) reqBody.file_exclude_patterns = cliFileExcludes;
+  const resp = await api.post("/api/git/remote-repos", [reqBody]);
+  const rec = Array.isArray(resp) ? resp[0] : resp;
+  if (!rec || !rec.gitId) {
+    throw new Error(`Failed to register remote repo: ${(rec && rec.status) || "unknown error"}`);
+  }
+  console.log(`  ${color.green("✓")} Remote repo registered. gitId: ${color.dim(rec.gitId)}`);
+
+  const { offerModuleExcludeSuggestions } = require("../lib/moduleExcludeSuggestions");
+  await offerModuleExcludeSuggestions(rec.gitId, opts, cliModuleExcludes);
+
+  console.log(`  Run ${color.cyan("niro add project")} to attach it to a project.`);
+}
+
+/** Parse --sync-mode local|remote. Returns the mode, or null if unset. Throws on garbage. */
+function parseSyncMode(v) {
+  if (v === undefined || v === null || v === "") return null;
+  const s = String(v).trim().toLowerCase();
+  if (s === "local" || s === "remote") return s;
+  throw new Error(`Invalid --sync-mode value "${v}". Use "local" or "remote".`);
+}
+
+function isTokenExpired(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+    return payload.exp && payload.exp * 1000 < Date.now();
+  } catch {
+    return false;
+  }
+}
+
+async function ensureLoggedIn(opts) {
+  let creds = credentials.load();
+  const expired = creds && creds.token && isTokenExpired(creds.token);
+  if (!creds || !creds.token || expired) {
+    console.log(expired ? "Session expired — re-authenticating." : "Not logged in — starting login flow.");
+    await login({ apiUrl: opts.apiUrl });
+    creds = credentials.load();
+    if (!creds || !creds.token) return null;
+  }
+  return creds;
+}
+
+module.exports = { addRepo, parseSyncMode };

package/src/commands/build.js

@@ -0,0 +1,118 @@
+const api = require("../lib/api");
+const credentials = require("../lib/credentials");
+const spinner = require("../lib/spinner");
+const color = require("../lib/color");
+const { resolveProjectId } = require("./_resolveProject");
+
+const TERMINAL = new Set(["COMPLETED", "FAILED", "CANCELLED"]);
+
+function colorizeStatus(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;
+}
+
+async function build(projectIdArg, opts = {}) {
+  credentials.requireCreds();
+  const projectId = await resolveProjectId(projectIdArg, { apiUrl: opts.apiUrl });
+  const force = opts.fullRebuild !== false;
+  const asJson = opts.json === true;
+  await api.post(`/api/graph/${encodeURIComponent(projectId)}/build`, {}, {
+    query: { force_full_rebuild: force ? "true" : "false" },
+  });
+  if (asJson) {
+    emitJson({ event: "triggered", project_id: projectId, force_full_rebuild: force });
+  } else {
+    console.log(`${color.green("✓")} Build triggered for ${color.bold(projectId)}.`);
+  }
+  if (opts.watch === false) return;
+  await watchStatus(projectId, { json: asJson });
+}
+
+/** Emit one JSON object per line (NDJSON) so a caller can stream-parse it. */
+function emitJson(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+async function watchStatus(projectId, opts = {}) {
+  if (opts.json) return watchStatusJson(projectId);
+  return watchStatusHuman(projectId);
+}
+
+/**
+ * Machine-readable watch: one {status, log_message} line per change, then a
+ * final {event:"final", status, success} summary. No spinner / ANSI.
+ */
+async function watchStatusJson(projectId) {
+  let lastStatus = null;
+  let lastLog = null;
+  while (true) {
+    let data;
+    try {
+      data = await api.get(`/api/graph/${encodeURIComponent(projectId)}/status`);
+    } catch (err) {
+      emitJson({ event: "error", project_id: projectId, message: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    const st = data.status || "UNKNOWN";
+    const logMessage = data.log_message || data.logMessage || null;
+    if (st !== lastStatus || logMessage !== lastLog) {
+      emitJson({ event: "status", project_id: projectId, status: st, log_message: logMessage });
+      lastStatus = st;
+      lastLog = logMessage;
+    }
+    if (TERMINAL.has(st)) {
+      const success = st === "COMPLETED";
+      emitJson({ event: "final", project_id: projectId, status: st, success });
+      if (!success) process.exitCode = 1;
+      return;
+    }
+    await sleep(5000);
+  }
+}
+
+async function watchStatusHuman(projectId) {
+  const sp = spinner.start(`Waiting for build to start... [${projectId}]`);
+  let lastStatus = null;
+  let lastLog = null;
+  try {
+    while (true) {
+      let data;
+      try {
+        data = await api.get(`/api/graph/${encodeURIComponent(projectId)}/status`);
+      } catch (err) {
+        sp.stop(`Failed to fetch status: ${err.message}`);
+        process.exitCode = 1;
+        return;
+      }
+      const st = data.status || "UNKNOWN";
+      const logMessage = data.log_message || data.logMessage;
+      if (st !== lastStatus || logMessage !== lastLog) {
+        const coloredSt = colorizeStatus(st);
+        const label = logMessage ? `${coloredSt} — ${logMessage}` : coloredSt;
+        sp.update(label);
+        lastStatus = st;
+        lastLog = logMessage;
+      }
+      if (TERMINAL.has(st)) {
+        const mark = st === "COMPLETED" ? color.green("✓") : color.red("✗");
+        const tint = st === "COMPLETED" ? color.green : st === "FAILED" || st === "CANCELLED" ? color.red : (s) => s;
+        sp.stop(`${mark} Build ${tint(st.toLowerCase())}.`);
+        if (st !== "COMPLETED") process.exitCode = 1;
+        return;
+      }
+      await sleep(5000);
+    }
+  } finally {
+    sp.stop();
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = { build, watchStatus };

package/src/commands/delete.js

@@ -0,0 +1,66 @@
+/**
+ * `niro delete [project_id]` — remove a project from the server and (by
+ * default) clean up the local `.niro-project` pin so the MCP bridge no longer
+ * resolves to a project that is gone.
+ *
+ * Resolves the target project the same way `status` / `build` do: explicit
+ * arg > .niro-project walk-up from cwd. Always prompts for confirmation
+ * unless --yes is passed — DELETE is destructive and irreversible, and
+ * typing the project name is a cheap guardrail against a wrong tab.
+ */
+const fs = require("fs");
+const path = require("path");
+const api = require("../lib/api");
+const credentials = require("../lib/credentials");
+const prompt = require("../lib/prompt");
+const color = require("../lib/color");
+const { resolveProjectId, readNiroProjectFile } = require("./_resolveProject");
+
+async function deleteProject(projectIdArg, opts = {}) {
+  credentials.requireCreds();
+  const projectId = await resolveProjectId(projectIdArg, { apiUrl: opts.apiUrl });
+
+  if (!opts.yes) {
+    console.log(`${color.yellow("⚠")}  About to delete project ${color.bold(projectId)}.`);
+    console.log(color.dim("   This removes the project and its graph from the server. Registered repos stay."));
+    const typed = await prompt.ask(`Type the project name to confirm`, "");
+    if (typed !== projectId) {
+      console.log(`${color.red("✗")} Project name did not match — aborted.`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    const msg = await api.del(`/api/projects/${encodeURIComponent(projectId)}`);
+    console.log(`${color.green("✓")} ${typeof msg === "string" ? msg : `Deleted project ${projectId}.`}`);
+  } catch (err) {
+    console.error(`${color.red("✗")} Failed to delete: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  unpinIfMatches(projectId);
+}
+
+function unpinIfMatches(projectId) {
+  const pinned = readNiroProjectFile(process.cwd());
+  if (pinned !== projectId) return;
+  let dir = path.resolve(process.cwd());
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const p = path.join(dir, ".niro-project");
+    if (fs.existsSync(p)) {
+      try {
+        fs.unlinkSync(p);
+        console.log(`  Removed local pin at ${color.dim(p)}`);
+      } catch (err) {
+        console.log(color.yellow(`  Could not remove ${p}: ${err.message}`));
+      }
+      return;
+    }
+    dir = path.dirname(dir);
+  }
+}
+
+module.exports = { deleteProject, unpinIfMatches };