@niroai/niro 0.3.0

package/src/commands/info.js

@@ -0,0 +1,172 @@
+/**
+ * `niro info [path] [--json]` — report what Niro knows about the current
+ * working directory: is it a git repo, does it have an origin, and which Niro
+ * project(s) (if any) map to it, plus each project's build/doc status.
+ *
+ * Designed to be agent-friendly:
+ *   - Not logged in -> {authed:false} (JSON) / human "not logged in", exit 0
+ *     (mirrors `whoami --json` so an agent can branch instead of crash).
+ *   - Not a git repo / no origin -> graceful {indexed:false, reason:...}, no throw.
+ *   - resolveContext degrades gracefully (state "error") rather than throwing,
+ *     so resolution failures don't crash the command.
+ *
+ * NEVER prints secrets: it only emits project ids, aliases and status fields —
+ * no env-var values, tokens or credentials are touched here.
+ */
+const api = require("../lib/api");
+const credentials = require("../lib/credentials");
+const color = require("../lib/color");
+const { resolveContext } = require("../lib/resolveContext");
+
+async function info(pathArg, opts = {}) {
+  const startPath = pathArg || process.cwd();
+
+  // Auth gate — mirror whoami: emit a branchable result and exit 0 when not
+  // logged in, instead of throwing ENOAUTH.
+  const creds = credentials.load();
+  const durable = creds && (creds.cliToken || creds.niroApiKey);
+  if (!creds || (!creds.token && !durable)) {
+    if (opts.json) {
+      console.log(JSON.stringify({ authed: false }));
+    } else {
+      console.log("Not logged in. Run `niro login` first.");
+    }
+    return;
+  }
+
+  const ctx = await resolveContext(startPath, { apiUrl: opts.apiUrl });
+
+  // Not a git repo / no origin: short, branchable result. No server projects.
+  if (ctx.state === "not_a_git_repo") {
+    return emit(opts, {
+      git_root: null,
+      repo_url: null,
+      branch: null,
+      indexed: false,
+      ambiguous: false,
+      reason: "not_a_git_repo",
+      projects: [],
+    });
+  }
+  if (ctx.state === "no_origin") {
+    return emit(opts, {
+      git_root: ctx.gitRoot,
+      repo_url: null,
+      branch: ctx.branch,
+      indexed: false,
+      ambiguous: false,
+      reason: "no_origin",
+      projects: [],
+    });
+  }
+
+  // Resolution failed (server/network) — report gracefully, don't throw.
+  if (ctx.state === "error") {
+    return emit(opts, {
+      git_root: ctx.gitRoot,
+      repo_url: ctx.repoUrl,
+      branch: ctx.branch,
+      indexed: false,
+      ambiguous: false,
+      reason: "resolve_error",
+      error: ctx.error || null,
+      projects: [],
+    });
+  }
+
+  // Resolved or unresolved: fetch status for each matched project.
+  const projects = [];
+  for (const p of ctx.projects) {
+    let status = null;
+    let docGenStatus = null;
+    let updatedAt = null;
+    try {
+      const data = await api.get(`/api/graph/${encodeURIComponent(p.project_id)}/status`, {
+        apiUrl: opts.apiUrl,
+      });
+      status = data.status || null;
+      docGenStatus = data.doc_gen_status || data.docGenStatus || null;
+      updatedAt = data.updated_at || data.updatedAt || null;
+    } catch (err) {
+      // A status fetch failure for one project must not abort the whole command.
+      status = null;
+    }
+    projects.push({
+      project_id: p.project_id,
+      alias: p.alias || null,
+      // Matched repo's registration kind (REMOTE_GIT / LOCAL_PATH / AGENT_UPLOAD),
+      // or null. Lets agents warn on remote-git projects (auto-build only on commits).
+      source_type: p.source_type || null,
+      status,
+      doc_gen_status: docGenStatus,
+      updated_at: updatedAt,
+    });
+  }
+
+  const indexed = projects.length > 0;
+  const ambiguous = projects.length > 1;
+
+  return emit(opts, {
+    git_root: ctx.gitRoot,
+    repo_url: ctx.repoUrl,
+    branch: ctx.branch, // null === detached HEAD
+    indexed,
+    ambiguous,
+    projects,
+  });
+}
+
+/** Emit either JSON (exact shape) or a plain-English human summary. */
+function emit(opts, payload) {
+  if (opts.json) {
+    console.log(JSON.stringify(payload));
+    return;
+  }
+  printHuman(payload);
+}
+
+function printHuman(p) {
+  const label = (s) => color.dim(s.padEnd(11));
+
+  if (p.reason === "not_a_git_repo") {
+    console.log("This folder is not a git repository, so Niro can't index it.");
+    return;
+  }
+  if (p.reason === "no_origin") {
+    console.log(`${label("Git root:")} ${p.git_root}`);
+    console.log("No git remote (origin) is set, so Niro can't match this repo to a project.");
+    return;
+  }
+  if (p.reason === "resolve_error") {
+    console.log(`${label("Git root:")} ${p.git_root}`);
+    console.log(`${label("Repo URL:")} ${color.cyan(p.repo_url)}`);
+    console.log(color.yellow("Could not reach the server to check indexing status.") +
+      (p.error ? ` (${p.error})` : ""));
+    return;
+  }
+
+  console.log(`${label("Git root:")} ${p.git_root}`);
+  console.log(`${label("Repo URL:")} ${color.cyan(p.repo_url)}`);
+  console.log(`${label("Branch:")} ${p.branch || color.dim("(detached HEAD)")}`);
+
+  if (!p.indexed) {
+    console.log("This repo is " + color.yellow("not indexed") + " by Niro yet. Run `niro init` to onboard it.");
+    return;
+  }
+
+  if (p.ambiguous) {
+    console.log(color.yellow(`This repo maps to ${p.projects.length} Niro projects:`));
+  } else {
+    console.log(color.green("This repo is indexed by Niro."));
+  }
+  for (const proj of p.projects) {
+    const name = proj.alias ? `${color.bold(proj.alias)} (${color.dim(proj.project_id)})` : color.bold(proj.project_id);
+    const bits = [];
+    if (proj.status) bits.push(`status: ${proj.status}`);
+    if (proj.doc_gen_status) bits.push(`docs: ${proj.doc_gen_status}`);
+    if (proj.updated_at) bits.push(`updated: ${proj.updated_at}`);
+    console.log(`  - ${name}${bits.length ? "  — " + color.dim(bits.join(", ")) : ""}`);
+  }
+}
+
+module.exports = { info };