@nolto/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import path3 from "path";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path5 from "path";
 import { CommanderError } from "commander";
 
 // src/config.ts
@@ -77,6 +77,7 @@ var DOCUMENT_MAX_BYTES = 2 * 1024 * 1024;
 var DOCUMENT_FILENAME_MAX = 255;
 var DEFAULT_BASE_URL = "https://nolto.app";
 var CLI_USER_AGENT_NAME = "nolto-cli";
+var QUEUE_MAX_ENTRIES = 200;
 
 // src/config.ts
 var configSchema = z.object({
@@ -270,6 +271,30 @@ import { Command } from "commander";
 
 // src/commands/init.ts
 import readline from "readline/promises";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import path2 from "path";
+import fs from "fs";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var _require = createRequire(import.meta.url);
+function getCliVersion() {
+  const candidates = [
+    path2.resolve(__dirname, "../package.json"),
+    // bundled: dist/../package.json
+    path2.resolve(__dirname, "../../package.json")
+    // source:  src/commands/../../package.json
+  ];
+  for (const pkgPath of candidates) {
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = _require(pkgPath);
+        return pkg.version ?? "0.0.0";
+      } catch {
+      }
+    }
+  }
+  return "0.0.0";
+}
 function register(program, _deps) {
   program.command("init").description("Interactive setup: configure token, base URL, and default project.").option("--force", "Overwrite existing config without prompting").action(async (opts) => {
     const configPath = getConfigPath(process.env);
@@ -301,7 +326,7 @@ function register(program, _deps) {
       if (token.length === 0) {
         throw new CliError("Token is required.", 2);
       }
-      const caller = createMcpCaller({ baseUrl, token, version: "0.1.0" });
+      const caller = createMcpCaller({ baseUrl, token, version: getCliVersion() });
       let projects = [];
       try {
         const result = await caller.call("list_projects", {});
@@ -552,9 +577,9 @@ import { z as z2 } from "zod";
 
 // src/fsx.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 async function readPlanFile(filePath) {
-  const absPath = path2.resolve(filePath);
+  const absPath = path3.resolve(filePath);
   let content;
   try {
     content = await readFile2(absPath, "utf8");
@@ -575,11 +600,11 @@ async function readPlanFile(filePath) {
       2
     );
   }
-  const stem = path2.basename(absPath, path2.extname(absPath));
+  const stem = path3.basename(absPath, path3.extname(absPath));
   return { content: trimmed, sourcePath: absPath, titleFallback: stem };
 }
 async function readDocFile(filePath) {
-  const absPath = path2.resolve(filePath);
+  const absPath = path3.resolve(filePath);
   let fileSize;
   try {
     const info = await stat2(absPath);
@@ -601,7 +626,7 @@ async function readDocFile(filePath) {
     throw new CliError(`Cannot read file: ${absPath}: ${String(err)}`, 2);
   }
   const isBinary = buf.includes(0) || !isUtf8RoundTrip(buf);
-  const rawFilename = path2.basename(absPath);
+  const rawFilename = path3.basename(absPath);
   const filename = rawFilename.slice(0, DOCUMENT_FILENAME_MAX);
   if (isBinary) {
     return { content: buf.toString("base64"), encoding: "base64", filename };
@@ -732,8 +757,13 @@ function registerPlanRegisterSubcommand(plan, deps) {
       }
       const phaseResult = phaseArraySchema.safeParse(parsedPhases);
       if (!phaseResult.success) {
-        const field = phaseResult.error.issues[0]?.path.join(".") ?? "unknown";
-        throw new CliError(`Invalid --phases JSON: field "${field}"`, 2);
+        const issue = phaseResult.error.issues[0];
+        if (issue?.code === "too_big" && issue.path.length === 0) {
+          throw new CliError(`Too many phases (max ${PHASES_MAX}).`, 2);
+        }
+        const fieldPath = issue?.path.join(".") ?? "";
+        const fieldDesc = fieldPath.length > 0 ? `field "${fieldPath}"` : "unknown field";
+        throw new CliError(`Invalid --phases JSON: ${fieldDesc}`, 2);
       }
       parsedPhases = phaseResult.data;
     }
@@ -925,7 +955,7 @@ function register5(program, deps) {
     }
     let round;
     if (opts.round != null) {
-      if (!/^\d+$/.test(opts.round)) {
+      if (!/^[1-9]\d*$/.test(opts.round)) {
         throw new CliError(`--round must be a positive integer, got "${opts.round}"`, 2);
       }
       const parsed = Number(opts.round);
@@ -994,27 +1024,440 @@ function register6(program, deps) {
   });
 }
 
+// src/queue-file.ts
+import { openSync, closeSync, writeFileSync, unlinkSync, renameSync, statSync } from "fs";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, unlink, appendFile } from "fs/promises";
+import path4 from "path";
+import crypto from "crypto";
+function queueFilePath(projectDir) {
+  return path4.join(projectDir, ".nolto", "pending.jsonl");
+}
+function lockFilePath(projectDir) {
+  return path4.join(projectDir, ".nolto", "flush.lock");
+}
+function logFilePath(projectDir) {
+  return path4.join(projectDir, ".nolto", "flush.log");
+}
+function resolveQueueDir(inputs) {
+  if (inputs.flagDir != null) return inputs.flagDir;
+  if (inputs.env["NOLTO_QUEUE_DIR"]) return inputs.env["NOLTO_QUEUE_DIR"];
+  if (inputs.env["CLAUDE_PROJECT_DIR"]) return inputs.env["CLAUDE_PROJECT_DIR"];
+  return findAncestorWithMarker(inputs.cwd);
+}
+function findAncestorWithMarker(startDir) {
+  let current = startDir;
+  while (true) {
+    if (hasMarkerSync(current, ".git") || hasMarkerSync(current, ".nolto")) {
+      return current;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return startDir;
+}
+function hasMarkerSync(dir, marker) {
+  try {
+    statSync(path4.join(dir, marker));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readQueue(projectDir) {
+  const filePath = queueFilePath(projectDir);
+  let raw;
+  try {
+    raw = await readFile3(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      entries.push(obj);
+    } catch {
+      await appendLog(projectDir, "warn", `malformed queue line skipped: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return entries;
+}
+async function appendEntry(projectDir, entry) {
+  const noltoDir = path4.join(projectDir, ".nolto");
+  await mkdir2(noltoDir, { recursive: true, mode: 448 });
+  const existing = await readQueue(projectDir);
+  if (existing.length >= QUEUE_MAX_ENTRIES) {
+    throw new CliError(
+      `Queue is full (${QUEUE_MAX_ENTRIES} entries). Flush before adding more.`,
+      2
+    );
+  }
+  const newEntry = {
+    id: crypto.randomUUID(),
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: entry.tool,
+    args: { ...entry.args }
+  };
+  const line = JSON.stringify(newEntry) + "\n";
+  try {
+    await appendFile(queueFilePath(projectDir), line, "utf8");
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    throw new CliError(
+      `Failed to write queue entry: ${err.message ?? String(err)}`,
+      2
+    );
+  }
+  return newEntry;
+}
+async function atomicRewriteQueue(projectDir, entries) {
+  const filePath = queueFilePath(projectDir);
+  if (entries.length === 0) {
+    try {
+      await unlink(filePath);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") throw err;
+    }
+    return;
+  }
+  const noltoDir = path4.join(projectDir, ".nolto");
+  await mkdir2(noltoDir, { recursive: true });
+  const tmpPath = filePath + ".tmp";
+  const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  await writeFile2(tmpPath, content, "utf8");
+  renameSync(tmpPath, filePath);
+}
+async function acquireLock(projectDir) {
+  const noltoDir = path4.join(projectDir, ".nolto");
+  await mkdir2(noltoDir, { recursive: true });
+  const lockPath = lockFilePath(projectDir);
+  return tryAcquire(lockPath);
+}
+async function tryAcquire(lockPath) {
+  try {
+    const fd = openSync(lockPath, "wx");
+    writeFileSync(fd, String(process.pid));
+    closeSync(fd);
+    return makeLockHandle(lockPath);
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  let pidStr;
+  try {
+    pidStr = await readFile3(lockPath, "utf8");
+  } catch {
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+    return tryAcquire(lockPath);
+  }
+  const pid = parseInt(pidStr, 10);
+  if (isNaN(pid)) {
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+    return tryAcquire(lockPath);
+  }
+  try {
+    process.kill(pid, 0);
+    return null;
+  } catch (sigErr) {
+    if (sigErr.code === "ESRCH") {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+      return tryAcquire(lockPath);
+    }
+    return null;
+  }
+}
+function makeLockHandle(lockPath) {
+  let released = false;
+  return {
+    async release() {
+      if (released) return;
+      released = true;
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  };
+}
+async function appendLog(projectDir, level, message) {
+  try {
+    const noltoDir = path4.join(projectDir, ".nolto");
+    await mkdir2(noltoDir, { recursive: true });
+    const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${message}
+`;
+    await appendFile(logFilePath(projectDir), line, "utf8");
+  } catch {
+  }
+}
+
+// src/commands/queue.ts
+function withQueueDir(cmd) {
+  return cmd.option("--queue-dir <path>", "Override project directory for queue files");
+}
+function registerQueue(program, deps) {
+  const queue = program.command("queue").description("Queue a progress report for later flush.");
+  withQueueDir(
+    queue.command("phase-status <planId> <phaseId> <status>").description("Queue a phase status update (offline, no token required).").option("--message <text>", "Optional message")
+  ).action(
+    async (planId, phaseId, status, opts) => {
+      if (!PLAN_STATUSES.includes(status)) {
+        throw new CliError(
+          `Invalid status "${status}". Valid values: ${PLAN_STATUSES.join(", ")}`,
+          2
+        );
+      }
+      const projectDir = resolveQueueDir({
+        flagDir: opts.queueDir,
+        env: process.env,
+        cwd: process.cwd()
+      });
+      const args = {
+        planId,
+        phaseId,
+        status
+      };
+      if (deps.settings.defaultProjectId != null) args["projectId"] = deps.settings.defaultProjectId;
+      if (opts.message != null) args["message"] = opts.message;
+      const entry = await appendEntry(projectDir, { tool: "update_phase_status", args });
+      if (deps.output.mode === "json") {
+        printResult({ queued: true, id: entry.id }, "json");
+        return;
+      }
+      process.stdout.write(`Queued update_phase_status.
+`);
+    }
+  );
+  withQueueDir(
+    queue.command("phase-test <planId> <phaseId> <verdict>").description("Queue a phase test result (offline, no token required).").option("--round <n>", "Test round number (positive integer)").option("--summary <text>", "Test summary")
+  ).action(
+    async (planId, phaseId, verdict, opts) => {
+      if (!TEST_VERDICTS.includes(verdict)) {
+        throw new CliError(
+          `Invalid verdict "${verdict}". Valid values: ${TEST_VERDICTS.join(", ")}`,
+          2
+        );
+      }
+      let round;
+      if (opts.round != null) {
+        if (!/^[1-9]\d*$/.test(opts.round)) {
+          throw new CliError(`--round must be a positive integer, got "${opts.round}"`, 2);
+        }
+        const parsed = Number(opts.round);
+        if (!Number.isInteger(parsed) || parsed < 1) {
+          throw new CliError(`--round must be a positive integer, got "${opts.round}"`, 2);
+        }
+        round = parsed;
+      }
+      const projectDir = resolveQueueDir({
+        flagDir: opts.queueDir,
+        env: process.env,
+        cwd: process.cwd()
+      });
+      const args = {
+        planId,
+        phaseId,
+        verdict
+      };
+      if (deps.settings.defaultProjectId != null) args["projectId"] = deps.settings.defaultProjectId;
+      if (round != null) args["round"] = round;
+      if (opts.summary != null) args["summary"] = opts.summary;
+      const entry = await appendEntry(projectDir, { tool: "record_phase_test_result", args });
+      if (deps.output.mode === "json") {
+        printResult({ queued: true, id: entry.id }, "json");
+        return;
+      }
+      process.stdout.write(`Queued record_phase_test_result.
+`);
+    }
+  );
+  withQueueDir(
+    queue.command("plan-status <planId> <status>").description("Queue a plan status update (offline, no token required).").option("--message <text>", "Optional message")
+  ).action(
+    async (planId, status, opts) => {
+      if (!PLAN_STATUSES.includes(status)) {
+        throw new CliError(
+          `Invalid status "${status}". Valid values: ${PLAN_STATUSES.join(", ")}`,
+          2
+        );
+      }
+      const projectDir = resolveQueueDir({
+        flagDir: opts.queueDir,
+        env: process.env,
+        cwd: process.cwd()
+      });
+      const args = {
+        planId,
+        status
+      };
+      if (deps.settings.defaultProjectId != null) args["projectId"] = deps.settings.defaultProjectId;
+      if (opts.message != null) args["message"] = opts.message;
+      const entry = await appendEntry(projectDir, { tool: "update_plan_status", args });
+      if (deps.output.mode === "json") {
+        printResult({ queued: true, id: entry.id }, "json");
+        return;
+      }
+      process.stdout.write(`Queued update_plan_status.
+`);
+    }
+  );
+  withQueueDir(
+    queue.command("plan-review <planId> <verdict>").description("Queue a plan review (offline, no token required).").option("--summary <text>", "Review summary")
+  ).action(
+    async (planId, verdict, opts) => {
+      if (!REVIEW_VERDICTS.includes(verdict)) {
+        throw new CliError(
+          `Invalid verdict "${verdict}". Valid values: ${REVIEW_VERDICTS.join(", ")}`,
+          2
+        );
+      }
+      const projectDir = resolveQueueDir({
+        flagDir: opts.queueDir,
+        env: process.env,
+        cwd: process.cwd()
+      });
+      const args = {
+        planId,
+        verdict
+      };
+      if (deps.settings.defaultProjectId != null) args["projectId"] = deps.settings.defaultProjectId;
+      if (opts.summary != null) args["summary"] = opts.summary;
+      const entry = await appendEntry(projectDir, { tool: "record_plan_review", args });
+      if (deps.output.mode === "json") {
+        printResult({ queued: true, id: entry.id }, "json");
+        return;
+      }
+      process.stdout.write(`Queued record_plan_review.
+`);
+    }
+  );
+}
+
+// src/detach.ts
+import { spawn } from "child_process";
+function spawnDetachedFlush(scriptPath, queueDir) {
+  const extraArgs = queueDir != null ? ["--queue-dir", queueDir] : [];
+  const child = spawn(
+    process.execPath,
+    [scriptPath, "flush", ...extraArgs],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
+  child.unref();
+  return child.pid;
+}
+
+// src/commands/flush.ts
+async function runFlushWorker(deps, projectDir) {
+  const lock = await acquireLock(projectDir);
+  if (lock === null) {
+    process.stdout.write("Another flush is running.\n");
+    return { flushed: 0, remaining: 0, failed: 0 };
+  }
+  try {
+    const entries = await readQueue(projectDir);
+    if (entries.length === 0) {
+      process.stdout.write("Nothing to flush.\n");
+      return { flushed: 0, remaining: 0, failed: 0 };
+    }
+    if (deps.settings.token == null) {
+      await appendLog(projectDir, "warn", "flush skipped: no token configured");
+      return { flushed: 0, remaining: entries.length, failed: 0 };
+    }
+    let flushed = 0;
+    let remaining = entries.slice();
+    for (const entry of entries) {
+      try {
+        await deps.caller.call(entry.tool, entry.args);
+      } catch (err) {
+        const cliErr = err instanceof CliError ? err : new CliError(String(err), 5);
+        await appendLog(
+          projectDir,
+          "error",
+          `${entry.tool} id=${entry.id} exit=${cliErr.exitCode} ${cliErr.message}`
+        );
+        return { flushed, remaining: remaining.length, failed: 1 };
+      }
+      flushed++;
+      remaining = remaining.slice(1);
+      await atomicRewriteQueue(projectDir, remaining);
+    }
+    return { flushed, remaining: 0, failed: 0 };
+  } finally {
+    await lock.release();
+  }
+}
+function register7(program, deps) {
+  program.command("flush").description("Flush the pending queue, sending each entry to the Nolto MCP server.").option("--detach", "Spawn a detached background worker and exit immediately.").option("--queue-dir <path>", "Override project directory for queue files").action(async (opts) => {
+    const projectDir = resolveQueueDir({
+      flagDir: opts.queueDir,
+      env: process.env,
+      cwd: process.cwd()
+    });
+    if (opts.detach) {
+      spawnDetachedFlush(process.argv[1], opts.queueDir);
+      return;
+    }
+    try {
+      const summary = await runFlushWorker(deps, projectDir);
+      if (deps.output.mode === "json") {
+        process.stdout.write(JSON.stringify(summary) + "\n");
+      } else {
+        if (summary.flushed > 0 || summary.failed > 0) {
+          process.stdout.write(
+            `Flushed ${summary.flushed}, remaining ${summary.remaining}, failed ${summary.failed}.
+`
+          );
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await appendLog(projectDir, "error", `unexpected flush error: ${msg}`);
+      process.stderr.write(`Flush error (logged to .nolto/flush.log): ${msg}
+`);
+    }
+  });
+}
+
 // src/program.ts
+function stripCommanderErrorPrefix(msg) {
+  return msg.startsWith("error: ") ? msg.slice("error: ".length) : msg;
+}
 function buildProgram(deps) {
-  const isJson = deps.output.mode === "json";
-  const writeErr = isJson ? (_msg) => {
-  } : void 0;
-  const program = new Command("nolto").version(deps.version, "-V, --version", "Print version number").exitOverride().configureOutput(writeErr != null ? { writeErr } : {}).description("Nolto CLI \u2014 register plans and update progress from your terminal.").option("--token <value>", "API token (overrides env/file)").option("--base-url <url>", "Nolto base URL (default: https://nolto.app)").option("--project <projectId>", "Default project ID").option("--json", "Output as JSON");
+  const writeErr = (_msg) => {
+  };
+  const program = new Command("nolto").version(deps.version, "-V, --version", "Print version number").exitOverride().configureOutput({ writeErr }).description("Nolto CLI \u2014 register plans and update progress from your terminal.").option("--token <value>", "API token (overrides env/file)").option("--base-url <url>", "Nolto base URL (default: https://nolto.app)").option("--project <projectId>", "Default project ID").option("--json", "Output as JSON");
   register(program, deps);
   register2(program, deps);
   register3(program, deps);
   register4(program, deps);
   register5(program, deps);
   register6(program, deps);
+  registerQueue(program, deps);
+  register7(program, deps);
   return program;
 }
 
 // src/index.ts
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire(import.meta.url);
+var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+var require2 = createRequire2(import.meta.url);
 function getVersion() {
   try {
-    const pkgPath = path3.resolve(__dirname, "../package.json");
+    const pkgPath = path5.resolve(__dirname2, "../package.json");
     const pkg = require2(pkgPath);
     return pkg.version ?? "0.0.0";
   } catch {
@@ -1076,7 +1519,8 @@ main().catch((err) => {
     if (err.exitCode === 0) {
       process.exit(0);
     }
-    const cliErr2 = new CliError(err.message, 2);
+    const cleanMsg = stripCommanderErrorPrefix(err.message);
+    const cliErr2 = new CliError(cleanMsg, 2);
     printError(cliErr2, mode);
     process.exitCode = 2;
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolto/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CLI for Nolto — register plans and update progress from your terminal.",
   "license": "MIT",
   "type": "module",