@nolto/cli 0.1.1 → 0.2.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path4 from "path";
+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({
@@ -1023,6 +1024,415 @@ 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;
@@ -1037,15 +1447,17 @@ function buildProgram(deps) {
   register4(program, deps);
   register5(program, deps);
   register6(program, deps);
+  registerQueue(program, deps);
+  register7(program, deps);
   return program;
 }
 
 // src/index.ts
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
 var require2 = createRequire2(import.meta.url);
 function getVersion() {
   try {
-    const pkgPath = path4.resolve(__dirname2, "../package.json");
+    const pkgPath = path5.resolve(__dirname2, "../package.json");
     const pkg = require2(pkgPath);
     return pkg.version ?? "0.0.0";
   } catch {

package/package.json

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