@niroai/niro 0.17.0 → 1.0.0

package/src/lib/planUsage.js

@@ -0,0 +1,165 @@
+/**
+ * The plan and its line usage, in one line, for `niro start` and `niro plan`.
+ *
+ * Usage is the engine's own total, `lines_counted` in `niro-local projects --json`: the number its
+ * line limit compares, counted by its own rule (each repository once, by its largest checkout,
+ * whichever projects hold it; a folder inside another indexed folder is not counted again). Nothing
+ * is added up here (Niraj, 2026-11-06, Q2: "niro-cli no longer adds lines up per project"). Each
+ * folder's own `lines` is what that folder's build read, for the list, never for a sum. The limit is
+ * the lease's `max_lines`; absent means none. Free has no limit while the account shares redacted
+ * code, so that case says why.
+ */
+const localEngine = require("./localEngine");
+
+/** Lines this machine holds, as the engine's limit counts them; null when the engine cannot say. */
+async function linesUsed({ run = localEngine.run } = {}) {
+  try {
+    const total = JSON.parse(await run(["projects", "--json"])).lines_counted;
+    return Number.isInteger(total) && total >= 0 ? total : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Is this folder already counted against the limit, so the engine builds it even at or over the limit?
+ * The engine decides (`niro-local projects --json --path`, `already_counted`): a folder indexed before,
+ * a temporary copy of an indexed repository, a service inside an indexed monorepo. Only a folder that
+ * adds new lines is refused (Niraj, 2026-11-06). False when the engine cannot say, which refuses as
+ * before rather than letting a new repository past.
+ */
+async function alreadyCounted(dir, { run = localEngine.run } = {}) {
+  try {
+    return JSON.parse(await run(["projects", "--json", "--path", dir])).already_counted === true;
+  } catch {
+    return false;
+  }
+}
+
+/** Every indexed folder with its line count, largest first, as the engine reports them; [] when it cannot say. */
+async function folders({ run = localEngine.run } = {}) {
+  try {
+    const { projects = [] } = JSON.parse(await run(["projects", "--json"]));
+    return projects
+      .flatMap((p) => (p.worktrees || []).map((w) => ({ path: w.path, project: p.name, lines: Number(w.lines) || 0 })))
+      .sort((a, b) => b.lines - a.lines);
+  } catch {
+    return [];
+  }
+}
+
+const n = (x) => x.toLocaleString("en-US");
+
+/** "Free, 212,400 of 500,000 lines used", or null with no claims to read. */
+function describe(claims, used) {
+  if (!claims) return null;
+  const name = claims.plan_name || "Your plan";
+  if (claims.max_lines === undefined || claims.max_lines === null) {
+    return claims.share_code && claims.plan_id === "plan-free" ? `${name}, Unlimited Lines of Code while you share` : `${name}, Unlimited Lines of Code`;
+  }
+  if (used === null) return `${name}, up to ${n(claims.max_lines)} lines`;
+  // The build that takes a machine over is allowed to finish, so "6,153 of 5,000 used" is a
+  // real state; said as "over" rather than as a fraction above one.
+  if (used > claims.max_lines) return `${name}, ${n(used)} lines indexed, ${n(used - claims.max_lines)} over the ${n(claims.max_lines)} limit`;
+  return `${name}, ${n(used)} of ${n(claims.max_lines)} lines used`;
+}
+
+/**
+ * What the next build will do, when it will not run: at or over the limit the engine starts no build
+ * of a folder that adds new lines (niro_local/licence/limit.py `room` and `already_counted`), while
+ * folders already indexed still rebuild. Null under the limit.
+ */
+function noRoomNote(claims, used) {
+  if (!claims || claims.max_lines === undefined || claims.max_lines === null || used === null) return null;
+  if (used < claims.max_lines) return null;
+  return "No room left under the limit, so a new folder will not be indexed. Folders already indexed still rebuild.";
+}
+
+/**
+ * Would the engine refuse to build this folder for the line limit? Only at or over the limit
+ * (`noRoomNote`), and only for a folder the engine does not already count (`alreadyCounted`), which
+ * is asked only then. The same rule as the engine's `_no_room`, so niro-cli refuses exactly what the
+ * engine would.
+ */
+async function refusesBuild(claims, used, dir, { counted = (d) => module.exports.alreadyCounted(d) } = {}) {
+  if (!module.exports.noRoomNote(claims, used)) return false;
+  return !(await counted(dir));
+}
+
+/** The console this machine signed in through (saved by `niro login`), else production. */
+function consoleUrl({ load = require("./config").load } = {}) {
+  try { return (load().appUrl || "https://console.niroai.dev").replace(/\/+$/, ""); } catch { return "https://console.niroai.dev"; }
+}
+
+/** The console's /limit page for these numbers. */
+function limitUrl(used, max, opts) {
+  return `${consoleUrl(opts)}/limit?used=${used}&limit=${max}`;
+}
+
+/**
+ * What leaves this machine on every plan, whatever the sharing switch says: for each line the coverage
+ * audit flags, the method that holds it and one line for each name it uses, with secrets masked
+ * (auditUpload.js; niro-local `audit/snippet.py`, since 2026-11-09, when the clause changed from "files the
+ * audit flags" as the audit snippet plan asked), and the record of which Niro tools the
+ * assistant used (journalUpload.js), which carries tool names, timings, a short task summary and
+ * the names, paths and search text asked about. Niraj approved this wording on 2026-11-06 ("yes
+ * your wording suggestion is good"). README.md, the niro-local skill (src/mcp/localSkill.js) and
+ * docs/uninstall.md repeat it word for word, and test/planUsage.test.js fails when they drift.
+ *
+ * The last sentence (Niraj, 2026-11-06: "important to say also that niro tools don't share any
+ * code") holds for this release: every tool call is answered by the engine on this machine
+ * (src/mcp/server.js main, `!release.cloud`), the engine makes no network calls, LLM documentation
+ * is off (release.js `llmDocs: false`), and the tool record carries names, paths and search text
+ * but no file contents. It says "the contents of your files", not "code", because a search pattern
+ * in the tool record can be a short piece of code the assistant typed. Turning `cloud` or
+ * `llmDocs` on makes it false: revisit it then.
+ */
+const AUDIT_CLAUSE = "Your code stays on this machine, except, for each line the audit flags, the whole method that holds it and one line for each name it uses, sent with secrets masked and author and company names removed";
+const JOURNAL_SENTENCE = "A record of which Niro tools your assistant used is also sent, to improve Niro and to show you its value.";
+const TOOLS_SENTENCE = "Niro's tools answer your assistant from the graph on this machine and never send the contents of your files.";
+const WHAT_LEAVES = `${AUDIT_CLAUSE}. ${JOURNAL_SENTENCE} ${TOOLS_SENTENCE}`;
+// What "Help improve Niro" on adds, in the console's words (spec-builder-react shared/constants/codeSharing.ts).
+const SHARING_ON_SENTENCE = "Niro also receives your code, redacted on this machine (secrets, author and company names removed), to improve graph accuracy. It is deleted right after processing and never used to train generative AI.";
+
+/**
+ * The "Sharing" line of `niro status` and `niro plan`: the switch, then the same sentence either
+ * way. Since 2026-11-11, sharing on means the watcher sends, by itself, the files Niro indexes in
+ * every folder not excluded with `niro share exclude`: the whole set the first time, then changed
+ * files, redacted on this machine (shareCode.js; Niraj: "we need the pm2 to share the code as
+ * well"). That is what "Niro also receives your code" says. `niro audit-push-repo` sends the same
+ * files of one folder when typed, with sharing on or off, and asks before sending an excluded folder
+ * (repoPush.js).
+ *
+ * `null` is a licence that could not be read: the audit and `niro audit-push-repo` send nothing
+ * without one, but the journal needs only the login token and still goes, and a search pattern in
+ * it can be a short piece of code; so "no source files", not "nothing" or "no code".
+ */
+function sharingText(shareCode) {
+  if (shareCode === null || shareCode === undefined) return "unknown, so no source files are sent";
+  if (!shareCode) return `off. ${WHAT_LEAVES}`;
+  return `on. ${SHARING_ON_SENTENCE} Apart from that, ${WHAT_LEAVES.charAt(0).toLowerCase()}${WHAT_LEAVES.slice(1)}`;
+}
+
+/**
+ * The "Help improve Niro" block of `niro plan`: "on" or "off", then three lines, each ✓ (happens)
+ * or ✗ (does not). The first two hold either way: the audit's flagged methods and the tool record
+ * are sent on every plan (auditUpload.js, journalUpload.js). The third is the background code
+ * sharing, which runs only while sharing is on (shareCode.js). Wording Niraj's, 2026-11-11. The
+ * same facts as WHAT_LEAVES, which the README, the skill and the uninstall guide keep as one
+ * sentence. `pad` indents the three lines under the value column.
+ */
+function sharingBlock(shareCode, pad) {
+  const color = require("./color");
+  if (shareCode === null || shareCode === undefined) return [color.dim(sharingText(null))];
+  const row = (yes, text) => `${" ".repeat(pad)}${yes ? color.green("✓") : color.red("✗")} ${text}`;
+  return [
+    shareCode ? "on" : "off",
+    row(true, "Your code is indexed and answered on this machine"),
+    row(true, "Sent in the background: a record of which Niro tools ran, and the methods the audit flags with the lines they reference (secrets, author and company names removed)"),
+    shareCode
+      ? row(true, "Code shared in the background: the files Niro indexes, redacted here, deleted after processing, never used to train AI")
+      : row(false, "Code sharing is off"),
+  ];
+}
+
+module.exports = { linesUsed, alreadyCounted, folders, describe, noRoomNote, refusesBuild, consoleUrl, limitUrl, sharingText, sharingBlock, WHAT_LEAVES };

package/src/lib/progressBar.js

@@ -0,0 +1,46 @@
+/**
+ * The build bar in `niro start` step 4:
+ *   ████████████░░░░░░░░  62%   790 of 1,284 files   about 6 s left
+ *
+ * `render` is pure. `create` draws it in place on a terminal and, where nothing can be
+ * redrawn (piped output), prints it only at each quarter so a log is not flooded.
+ */
+const WIDTH = 20;
+
+function render(done, total, elapsedMs) {
+  const fraction = total > 0 ? Math.min(1, done / total) : 0;
+  const filled = Math.floor(fraction * WIDTH);
+  // Rounded, but never 100% until the last file is in.
+  const pct = done < total ? Math.min(99, Math.round(fraction * 100)) : 100;
+  let text = `${"█".repeat(filled)}${"░".repeat(WIDTH - filled)}  ${pct}%   ` +
+    `${done.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} files`;
+  if (done > 0 && done < total && elapsedMs > 0) {
+    const left = Math.round(((total - done) * elapsedMs) / done / 1000);
+    text += `   about ${left} s left`;
+  }
+  return text;
+}
+
+function create({ stream = process.stdout, prefix = "" } = {}) {
+  const startedAt = Date.now();
+  const tty = Boolean(stream.isTTY) && process.env.TERM !== "dumb";
+  let lastQuarter = -1;
+  return {
+    update(done, total) {
+      const line = prefix + render(done, total, Date.now() - startedAt);
+      if (tty) {
+        stream.write(`\r\x1b[2K${line}`);
+        return;
+      }
+      const quarter = total > 0 ? Math.floor((done / total) * 4) : 0;
+      if (quarter === lastQuarter) return;
+      lastQuarter = quarter;
+      stream.write(`${line}\n`);
+    },
+    stop() {
+      if (tty) stream.write("\r\x1b[2K");
+    },
+  };
+}
+
+module.exports = { render, create };

package/src/lib/prompt.js

@@ -20,7 +20,7 @@ function rl() {
 function formatPrompt(question, defaultValue) {
   // Questions asked from inside a nested step sit at that step's depth. readline writes
   // straight to stdout, so withIndent's console wrappers never see them.
-  question = " ".repeat(require("./nestedOutput").currentIndent()) + question;
+  question = require("./nestedOutput").currentPad() + question;
   return defaultValue != null && defaultValue !== ""
     ? `${question} ${color.dim(`(default: ${defaultValue})`)}: `
     : `${question}: `;

package/src/lib/redact.js

@@ -0,0 +1,155 @@
+/**
+ * What is removed from a flagged file before it leaves the machine (design §6.6, contract C4):
+ * the names of people and companies. Secrets are not handled here any more.
+ *
+ *   authors    → <author>   @author, Author:/Authors:, Created by, email addresses
+ *   companies  → <company>  copyright holders, the org in the user's own email domain, the
+ *                           git remote owner, and every later mention of any of them
+ *
+ * **Secrets are masked by the engine, not here (decision D4, Niraj, 2026-11-06).** The engine
+ * masks every upload with llm-gateway's own rules before niro-cli sees it
+ * (niro-local `docs/usecases/on-machine-redaction.md`), and every line it hands over carries
+ * `redacted`; auditUpload.js sends no line without it. This file used to mask secrets as `****`,
+ * and its whole-line rule rewrote ordinary code (`self.password = password` became
+ * `self.password = ****`), so that half was removed rather than kept beside the engine's.
+ *
+ * Authors and companies stay here because they need what only the CLI knows: the signed-in email
+ * and the git remote owner. Marked names only: a person's name in a plain comment has nothing to
+ * find it by, and the plan screen promises exactly the kinds above.
+ */
+const zlib = require("zlib");
+
+const AUTHOR = "<author>";
+const COMPANY = "<company>";
+
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}/g;
+const AT_AUTHOR = /(@author\s+)[^\n*]+/g;
+const AUTHOR_LINE = /\b((?:Authors?|AUTHORS?)\s*:\s*)[^\n]+/g;
+const CREATED_BY = /(Created by\s+)(.+?)(?=\s+on\s|\s*$)/gm;
+// Only at the start of a line or a comment, so `"Copyright " + name` in code is not harvested.
+// The end of the match never takes a line break: until 2026-11-09 it ended `(\s*(?:\*\/)?)\s*$`, and that
+// last `\s*` ate the line break after a ` */` (or after the holder) that the replacement never put back, so
+// `/*\n * Copyright (c) 2019 Foo Corp.\n */\n\npackage x;` lost a line and every flag below it pointed one
+// line too low on the server. Only spaces and tabs now.
+const COPYRIGHT = /^([ \t]*(?:\/\/+|\/\*+|\*|#+|--|;+|<!--)?[ \t]*(?:Copyright|SPDX-FileCopyrightText:)\s*(?:\([cC]\)|©)?\s*(?:\d{4}(?:\s*[-,]\s*\d{4})*,?\s+)?)([^\n*]+?)([ \t]*(?:\*\/)?)[ \t]*$/gm;
+
+const PUBLIC_MAIL = new Set([
+  "gmail", "googlemail", "outlook", "hotmail", "live", "msn", "yahoo", "icloud", "me", "mac",
+  "proton", "protonmail", "pm", "aol", "gmx", "mail", "yandex", "zoho", "fastmail", "users",
+]);
+
+function escape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** The org names the context gives: the email domain's first label, and the remote owner. */
+function contextCompanies({ email, remoteOwner } = {}) {
+  const names = [];
+  const domain = email && String(email).split("@")[1];
+  const org = domain && domain.split(".")[0].toLowerCase();
+  if (org && !PUBLIC_MAIL.has(org)) names.push(org);
+  if (remoteOwner) names.push(String(remoteOwner));
+  return names;
+}
+
+function redactSource(text, ctx = {}) {
+  if (typeof text !== "string" || !text) return text;
+  let out = text;
+
+  // Authors.
+  out = out.replace(EMAIL, AUTHOR);
+  out = out.replace(AT_AUTHOR, `$1${AUTHOR}`);
+  out = out.replace(AUTHOR_LINE, `$1${AUTHOR}`);
+  out = out.replace(CREATED_BY, `$1${AUTHOR}`);
+
+  // Companies: copyright holders first, then every mention of them and of the context's orgs.
+  const holders = [];
+  out = out.replace(COPYRIGHT, (whole, lead, holder, tail) => {
+    const name = holder.replace(/[.,]?\s*All rights reserved\.?$/i, "").replace(/[.,;]+$/, "").trim();
+    if (!name || name.startsWith("<")) return whole;
+    holders.push(name);
+    return `${lead}${COMPANY}${tail}`;
+  });
+  const names = [...new Set([...holders, ...contextCompanies(ctx)])]
+    .filter((n) => n.length >= 3)
+    .sort((a, b) => b.length - a.length); // "acme-labs" before "acme"
+  for (const name of names) {
+    out = out.replace(new RegExp(`(?<![\\w-])${escape(name)}(?![\\w-])`, "gi"), COMPANY);
+  }
+  return out;
+}
+
+/** The text's lines, split on "\n" only; a final "\n" ends the last line (as the engine and niro-audit count). */
+function linesOf(text) {
+  if (!text) return [];
+  return (text.endsWith("\n") ? text.slice(0, -1) : text).split("\n");
+}
+
+/**
+ * Why a snippet's text must not be sent, or null. Since 2026-11-09 the engine sends a snippet, not the
+ * whole flagged file (`source_form: "snippet"`, niro-local `audit/snippet.py`): the file with every line
+ * outside `snippet_lines` empty. Here, before it leaves: it has `source_line_count` lines, and every line
+ * outside the ranges is empty. niro-audit refuses such an item too (`SnippetCheck`).
+ */
+function snippetProblem(text, payload) {
+  const lines = linesOf(text);
+  if (lines.length !== payload.source_line_count) {
+    return `the snippet has ${lines.length} lines where the file has ${payload.source_line_count}`;
+  }
+  const ranges = Array.isArray(payload.snippet_lines) ? payload.snippet_lines : [];
+  const kept = (n) => ranges.some((r) => Array.isArray(r) && r[0] <= n && n <= r[1]);
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== "" && !kept(i + 1)) return `line ${i + 1} is outside the snippet and not empty`;
+  }
+  return null;
+}
+
+/**
+ * A queued audit payload with author and company names removed from its source, explanation and
+ * every flag's matched_text. Its secrets were masked by the engine.
+ * `sha` stays the original file's hash: it is the server's dedup key. A payload with nothing
+ * to remove comes back byte for byte. Source that cannot be read throws, so the caller keeps
+ * the item queued instead of sending it unredacted.
+ *
+ * Throws too, keeping the item queued, when redaction would change the number of lines (every flag's
+ * line number would then point at the wrong text on the server), or when a snippet holds any line
+ * outside its ranges, before redaction or after.
+ */
+function redactItem(payload, ctx = {}) {
+  if (!payload || typeof payload !== "object") return payload;
+  const out = { ...payload };
+  const snippet = payload.source_form === "snippet";
+  if (typeof payload.compressed_source === "string") {
+    let original;
+    try {
+      original = zlib.gunzipSync(Buffer.from(payload.compressed_source, "base64")).toString("utf8");
+    } catch {
+      throw new Error("the flagged file's source could not be read, so it was not sent");
+    }
+    if (snippet && snippetProblem(original, payload)) {
+      throw new Error(`the snippet was not sent: ${snippetProblem(original, payload)}`);
+    }
+    const cleaned = redactSource(original, ctx);
+    if (linesOf(cleaned).length !== linesOf(original).length) {
+      throw new Error("removing names would have moved the source's lines, so it was not sent");
+    }
+    if (snippet && snippetProblem(cleaned, payload)) {
+      throw new Error(`the snippet was not sent: ${snippetProblem(cleaned, payload)}`);
+    }
+    if (cleaned !== original) {
+      out.compressed_source = zlib.gzipSync(Buffer.from(cleaned, "utf8")).toString("base64");
+    }
+  }
+  if (typeof payload.explanation === "string") out.explanation = redactSource(payload.explanation, ctx);
+  for (const [key, value] of Object.entries(payload)) {
+    if (!key.endsWith("_flags") || !Array.isArray(value)) continue;
+    out[key] = value.map((flag) =>
+      flag && typeof flag.matched_text === "string"
+        ? { ...flag, matched_text: redactSource(flag.matched_text, ctx) }
+        : flag
+    );
+  }
+  return out;
+}
+
+module.exports = { redactSource, redactItem, contextCompanies, linesOf, snippetProblem };

package/src/lib/release.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * What this release ships.
+ *
+ * `cloud` is the hosted product: the hosted MCP server (aiassistant.niroai.dev) behind
+ * `niro mcp serve`, and the cloud project commands (init, add, build, projects, ...). Off in the
+ * local-engine release (Divya, 2026-11-05: "mcp and cloud commands both should be a switch off in
+ * this release"): the bridge answers everything from the engine on this machine and the cloud
+ * commands are not registered. Sign-in, the plan's licence and code sharing still use Niro's
+ * services; they are the account, not the hosted graph.
+ *
+ * A constant, not an environment variable, so a published package cannot be switched back on by
+ * whoever runs it. Turning the cloud back on is an edit here and a release.
+ */
+/**
+ * `llmDocs` is LLM documentation: `niro docs-send`, the watcher's documentation round, the
+ * embedding model download, and every text telling a person or an assistant about
+ * `niro-local build --llm`, find_reusable_code or find_known_issues. Off in this release
+ * (Niraj, 2026-11-06: "turn off llm flag for now (do not expose it), we will add this flag and
+ * that's when we will handle it"); the engine has the same switch (niro-local
+ * `reuse.IN_THIS_RELEASE`). The code is kept: setting this to true brings it all back.
+ */
+/**
+ * How a person or an assistant is told to rebuild a folder by hand. Without the cloud, the engine is the released one,
+ * which builds only with the licence niro-cli passes it, so a typed `niro-local build` is refused and `niro build`
+ * (niro-cli) is the command that works. A function, so it reads `cloud` when it is said.
+ */
+function rebuildCommand() {
+  return module.exports.cloud ? "niro-local build" : "niro build";
+}
+
+module.exports = { cloud: false, llmDocs: false, rebuildCommand };