@niroai/niro 0.16.0 → 0.18.0

package/src/commands/plan.js

@@ -0,0 +1,99 @@
+/**
+ * `niro plan` — the plan, its line usage on this machine, and what to do near the limit.
+ *
+ * The plan comes from a fresh lease (the same claims the engine enforces) and usage from the
+ * engine's own count, so this says exactly what the next build will be held to.
+ */
+const color = require("../lib/color");
+const credentials = require("../lib/credentials");
+const lease = require("../lib/lease");
+const planUsage = require("../lib/planUsage");
+const shareExclusions = require("../lib/shareExclusions");
+const localEngine = require("../lib/localEngine");
+const path = require("path");
+
+async function plan({ currentClaims = lease.currentClaims, linesUsed = planUsage.linesUsed, folders = planUsage.folders, excluded = shareExclusions.list, json = false } = {}) {
+  credentials.requireCreds();
+  const claims = await currentClaims().catch(() => null);
+  if (json) {
+    // For the niro-local skill: the same facts as the text below, in fields.
+    if (!claims) {
+      console.log(JSON.stringify({ ok: false, reason: "plan_unreachable" }));
+      process.exitCode = 1;
+      return;
+    }
+    const used = await linesUsed();
+    const limit = claims.max_lines === undefined ? null : claims.max_lines;
+    console.log(JSON.stringify({
+      ok: true,
+      plan: claims.plan_name || null,
+      plan_id: claims.plan_id || null,
+      share_code: !!claims.share_code,
+      max_lines: limit,
+      lines_used: used,
+      over_by: limit !== null && used !== null ? Math.max(0, used - limit) : 0,
+      no_room: !!planUsage.noRoomNote(claims, used),
+      limit_url: limit !== null && used !== null ? planUsage.limitUrl(used, limit) : null,
+      folders: await folders(),
+      share_excluded: excluded(),
+    }));
+    return;
+  }
+  if (!claims) {
+    console.error(color.red("Could not read your plan from Niro.") + ` Check your connection, then run ${color.cyan("niro plan")} again.`);
+    process.exitCode = 1;
+    return;
+  }
+  const used = await linesUsed();
+  const LABEL = 19;
+  const label = (s) => color.dim(s.padEnd(LABEL));
+  console.log(`${label("Plan")}${color.bold(planUsage.describe(claims, used))}`);
+  const [first, ...rows] = planUsage.sharingBlock(!!claims.share_code, LABEL);
+  console.log(`${label("Help improve Niro")}${first}`);
+  for (const row of rows) console.log(row);
+  const notShared = excluded();
+  if (notShared.length) {
+    console.log(`  Not shared (${color.cyan("niro share include <folder>")} to share again):`);
+    for (const folder of notShared) console.log(`    ${folder}`);
+  }
+
+  const limited = claims.max_lines !== undefined && claims.max_lines !== null;
+  if (!limited) return;
+  const noRoom = planUsage.noRoomNote(claims, used);
+  if (noRoom) {
+    console.log(color.yellow(`\n${noRoom}`));
+    console.log(`Choose how to continue: ${color.cyan(planUsage.limitUrl(used, claims.max_lines))}`);
+  }
+  const list = await planUsage.folders();
+  if (list.length) {
+    console.log(`\n${color.bold("Indexed on this machine")}, largest first`);
+    for (const f of list) console.log(`  ${f.lines.toLocaleString("en-US").padStart(9)}  ${f.path}`);
+    console.log(color.dim("  Each repository counts once, by its largest checkout; a folder inside another indexed folder is not counted again."));
+  }
+  console.log(`\n${color.bold("Options")}`);
+  if (claims.plan_id === "plan-free") {
+    console.log(`  No line limit     turn on "Share redacted code" at ${color.cyan(`${planUsage.consoleUrl()}/settings?tab=privacy`)}`);
+  }
+  console.log(`  Pro free trial    request it at ${color.cyan(`${planUsage.consoleUrl()}/request?plan=pro`)}`);
+  console.log(`  Stay under it     stop indexing a folder:  ${color.cyan("niro plan remove <folder>")} (the same as ${color.cyan("niro remove --path <folder>")})`);
+}
+
+/**
+ * `niro plan remove <folder>`: stop indexing a folder, which frees its lines. The folder and its
+ * code are untouched; only what was indexed goes (the engine's own `remove`).
+ */
+async function remove(folder, { run = localEngine.run } = {}) {
+  if (!folder) throw new Error("Name the folder to stop indexing: niro plan remove <folder>");
+  const abs = path.resolve(folder);
+  let out;
+  try {
+    out = await run(["remove", "--path", abs]);
+  } catch (err) {
+    // The engine says why on its own output ("... is not indexed"); show that, not our wrapper.
+    throw new Error((err && (err.stdout || err.stderr)) || `Could not stop indexing ${abs}.`);
+  }
+  if (out && out.trim()) console.log(out.trim());
+  console.log(`Stopped indexing ${abs}. Run ${color.cyan("niro plan")} to see your lines, or ${color.cyan("niro start")} to build.`);
+}
+
+module.exports = { plan, remove };

package/src/commands/repoPush.js

@@ -0,0 +1,33 @@
+/**
+ * `niro audit-push-repo` — send this folder's whole source to Niro, when the plan includes it.
+ *
+ * Explicit on purpose: nothing calls this as a side effect, no watcher runs it, and it is not
+ * part of `audit-send`, which sends only the files the audit flagged. The reasoning and every
+ * refusal live in `src/lib/repoPush.js`.
+ */
+const color = require("../lib/color");
+const repoPush = require("../lib/repoPush");
+
+async function pushRepo(pathArg, opts = {}) {
+  const folder = pathArg || process.cwd();
+  const result = await repoPush.pushFolder(folder, {
+    force: opts.force === true,
+    yes: opts.yes === true,
+  });
+  if (result.sent) {
+    console.log(`    ${color.green("✓")} Sent ${result.files} files to Niro.`);
+    return;
+  }
+  if (result.alreadySent) {
+    console.log(`    Nothing sent: ${result.reason}`);
+    return;
+  }
+  console.error(color.red(`    Nothing was sent: ${result.reason}`));
+  if (result.gateRefused) {
+    console.error("    `--force` on this command means \"send it again\", not \"ignore that\":");
+    console.error("    run it inside the one repository you meant instead.");
+  }
+  process.exitCode = 1;
+}
+
+module.exports = { pushRepo };

package/src/commands/requestIntegration.js

@@ -0,0 +1,38 @@
+/**
+ * `niro request-integration <name>`: ask Niro's team to support a language, framework or tool. Asks
+ * first (unless --yes), then sends it with the signed-in account; the orchestrator stores it. The same
+ * request an assistant makes through the request_integration tool (src/lib/integrationRequest.js).
+ */
+const color = require("../lib/color");
+const prompt = require("../lib/prompt");
+const integration = require("../lib/integrationRequest");
+
+async function requestIntegration(name, opts = {}, { send = integration.post, confirm = prompt.confirm } = {}) {
+  const { request, problem } = integration.check({ kind: opts.kind || "language", name, reason: opts.reason });
+  if (problem) {
+    console.error(color.red(`Not sent: ${problem}.`));
+    process.exitCode = 1;
+    return;
+  }
+  const who = integration.account();
+  if (!who) {
+    console.error(color.red("Not signed in.") + ` Run ${color.cyan("niro start")} first.`);
+    process.exitCode = 1;
+    return;
+  }
+  const what = `${request.name} (${request.kind})`;
+  if (!opts.yes && !(await confirm(`Send a request for ${what} support to Niro, as ${who}?`, true))) {
+    console.log("Not sent.");
+    return;
+  }
+  try {
+    await send({ ...request, source: "cli" });
+  } catch (err) {
+    console.error(color.red(`Could not send the request: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`${color.green("✓")} Sent. Niro's team will see your request for ${what}.`);
+}
+
+module.exports = { requestIntegration };

package/src/commands/share.js

@@ -0,0 +1,56 @@
+/**
+ * `niro share` — which folders are kept out of code sharing.
+ *
+ *   niro share                    list the folders not shared
+ *   niro share exclude <folder>   never share this folder (and every folder inside it)
+ *   niro share include <folder>   share it again
+ *
+ * Only matters while "Help improve Niro" is on: then the watcher shares every indexed folder that
+ * is not excluded (src/lib/shareCode.js), and `niro audit-push-repo` asks before sending an excluded one.
+ * Niraj, 2026-11-11: a user may exclude a folder while sharing stays on.
+ */
+const fs = require("fs");
+const path = require("path");
+
+const color = require("../lib/color");
+const shareExclusions = require("../lib/shareExclusions");
+
+function show({ log = console.log } = {}) {
+  const folders = shareExclusions.read();
+  if (folders === null) {
+    log(color.yellow(`The list of folders not shared (${shareExclusions.file()}) cannot be read, so no folder is shared until it is fixed or deleted.`));
+    return;
+  }
+  if (folders.length === 0) {
+    log(`No folder is excluded from code sharing. To keep one out: ${color.cyan("niro share exclude <folder>")}`);
+    return;
+  }
+  log(color.bold("Not shared") + " (each folder and every folder inside it)");
+  for (const folder of folders) log(`  ${folder}`);
+  log(color.dim(`Share one again with ${"niro share include <folder>"}.`));
+}
+
+function exclude(folder, { log = console.log } = {}) {
+  if (!folder) throw new Error("Name the folder to keep out of code sharing: niro share exclude <folder>");
+  const resolved = path.resolve(folder);
+  // A typo must not leave the folder the person meant being shared, so only a real folder is taken.
+  if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+    throw new Error(`Not a folder: ${resolved}`);
+  }
+  const added = shareExclusions.exclude(resolved);
+  const name = shareExclusions.canonical(resolved);
+  log(added ? `${name} is not shared from now on, nor any folder inside it.` : `${name} was already excluded.`);
+  log(color.dim("Code already sent stays until it is processed and deleted. Another checkout of the same repository elsewhere is not excluded by this."));
+}
+
+function include(folder, { log = console.log } = {}) {
+  if (!folder) throw new Error("Name the folder to share again: niro share include <folder>");
+  const name = shareExclusions.canonical(folder);
+  if (shareExclusions.include(folder)) {
+    log(`${name} is shared again while Help improve Niro is on.`);
+  } else {
+    log(`${name} was not excluded by that name. Run ${color.cyan("niro share")} to see the list.`);
+  }
+}
+
+module.exports = { show, exclude, include };