@nolto/cli 0.2.1 → 0.3.1

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path5 from "path";
+import path6 from "path";
 import { CommanderError } from "commander";
 
 // src/config.ts
@@ -311,9 +311,9 @@ function getCliVersion() {
   }
   return "0.0.0";
 }
-function register(program, _deps) {
+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);
+    const configPath = deps.configPath;
     if (!opts.force) {
       let existing = null;
       try {
@@ -411,6 +411,409 @@ async function promptHidden(rl, prompt) {
   return value;
 }
 
+// src/commands/login.ts
+import readline2 from "readline/promises";
+
+// src/http.ts
+function createHttpClient(opts) {
+  const { baseUrl, version, token } = opts;
+  const base = baseUrl.replace(/\/+$/, "");
+  return {
+    async post(path7, body) {
+      if (!path7.startsWith("/api/")) {
+        throw new CliError(`HTTP client path must start with /api/, got: ${path7}`, 2);
+      }
+      const url = `${base}${path7}`;
+      const headers = {
+        "Content-Type": "application/json",
+        "User-Agent": `${CLI_USER_AGENT_NAME}/${version}`
+      };
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      let response;
+      try {
+        response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+      } catch (err) {
+        if (isNetworkError(err)) {
+          throw new CliError(
+            `Network error contacting ${base}: ${err instanceof Error ? err.message : String(err)}`,
+            5
+          );
+        }
+        throw err;
+      }
+      if (!response.ok) {
+        const retryAfter = response.headers.get("retry-after") ?? void 0;
+        const wwwAuthenticate = response.headers.get("www-authenticate") ?? void 0;
+        throw mapHttpStatusToCliError(response.status, retryAfter, wwwAuthenticate);
+      }
+      return response.json();
+    }
+  };
+}
+
+// src/login-poll.ts
+async function pollUntilToken(opts) {
+  const { http, deviceCode, expiresIn, baseUrl } = opts;
+  let intervalSeconds = opts.intervalSeconds;
+  const deadline = Date.now() + expiresIn * 1e3;
+  await sleep(intervalSeconds * 1e3);
+  while (Date.now() < deadline) {
+    let resp;
+    try {
+      resp = await http.post("/api/cli/auth/poll", {
+        device_code: deviceCode
+      });
+    } catch (err) {
+      if (err instanceof CliError && err.exitCode === 4) {
+        await sleep(intervalSeconds * 1e3);
+        continue;
+      }
+      throw err;
+    }
+    if (!resp.error) {
+      if (!resp.token) {
+        throw new CliError("Server returned success but no token.", 5);
+      }
+      return resp.token;
+    }
+    switch (resp.error) {
+      case "authorization_pending":
+        await sleep(intervalSeconds * 1e3);
+        break;
+      case "slow_down":
+        intervalSeconds += 5;
+        await sleep(intervalSeconds * 1e3);
+        break;
+      case "expired_token":
+        throw new CliError("Device code expired. Run `nolto login` again.", 2);
+      case "access_denied":
+        throw new CliError("\u30ED\u30B0\u30A4\u30F3\u304C\u62D2\u5426\u3055\u308C\u307E\u3057\u305F\u3002", 3);
+      case "token_cap_exceeded":
+        throw new CliError(
+          `\u30A2\u30AF\u30C6\u30A3\u30D6\u306A API token \u304C\u4E0A\u9650(20)\u3067\u3059\u3002${baseUrl}/settings/tokens \u3067\u4E0D\u8981\u306A\u30C8\u30FC\u30AF\u30F3\u3092\u5931\u52B9\u3057\u3066\u304B\u3089\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
+          2
+        );
+      default:
+        throw new CliError(`Unexpected poll response: ${resp.error}`, 5);
+    }
+  }
+  throw new CliError("Login timed out. Run `nolto login` again.", 2);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/client-inject.ts
+import { readFile as readFile2, writeFile as writeFile2, rename, mkdir as mkdir2, unlink } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import os2 from "os";
+import path3 from "path";
+function getExecFileAsync() {
+  return promisify(execFile);
+}
+async function atomicWrite(filePath, content, mode2) {
+  const dir = path3.dirname(filePath);
+  await mkdir2(dir, { recursive: true, mode: 448 });
+  const tmp = `${filePath}.tmp.${Date.now()}`;
+  try {
+    await writeFile2(tmp, content, { mode: mode2 });
+    await rename(tmp, filePath);
+  } catch (err) {
+    await unlink(tmp).catch(() => void 0);
+    throw err;
+  }
+}
+async function readJsonConfig(filePath) {
+  try {
+    const raw = await readFile2(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { parsed, raw };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return null;
+    return null;
+  }
+}
+async function injectCursor(opts) {
+  const configDir = opts.cursorConfigDir ?? process.env["CURSOR_CONFIG_DIR"] ?? path3.join(os2.homedir(), ".cursor");
+  const configPath = path3.join(configDir, "mcp.json");
+  const mcpUrl = `${opts.baseUrl.replace(/\/+$/, "")}/mcp`;
+  let existing = {};
+  const raw = await readFile2(configPath, "utf8").catch((err) => {
+    if (err.code === "ENOENT") return null;
+    return null;
+  });
+  if (raw !== null) {
+    try {
+      existing = JSON.parse(raw);
+    } catch {
+      const backupPath = `${configPath}.bak.${Date.now()}`;
+      process.stdout.write(
+        `Warning: ${configPath} contains invalid JSON. Backing up to ${backupPath}
+`
+      );
+      await writeFile2(backupPath, raw, { mode: 384 }).catch(() => void 0);
+      existing = {};
+    }
+  }
+  const updatedServers = {
+    ...existing.mcpServers,
+    nolto: {
+      url: mcpUrl,
+      headers: {
+        Authorization: `Bearer ${opts.token}`
+      }
+    }
+  };
+  const newConfig = {
+    ...existing,
+    mcpServers: updatedServers
+  };
+  await atomicWrite(configPath, JSON.stringify(newConfig, null, 2) + "\n", 384);
+  process.stdout.write(`Updated ${configPath} (cursor)
+`);
+}
+async function injectClaude(opts) {
+  const mcpUrl = `${opts.baseUrl.replace(/\/+$/, "")}/mcp`;
+  const claudePath = await findOnPath("claude");
+  if (claudePath) {
+    const execFileAsync2 = getExecFileAsync();
+    await execFileAsync2(claudePath, ["mcp", "remove", "nolto", "--scope", "user"]).catch(
+      () => void 0
+    );
+    try {
+      const { stderr } = await execFileAsync2(claudePath, [
+        "mcp",
+        "add",
+        "nolto",
+        mcpUrl,
+        "--transport",
+        "http",
+        "--scope",
+        "user",
+        "--header",
+        `Authorization: Bearer ${opts.token}`
+      ]);
+      if (stderr) {
+        process.stderr.write(`[claude mcp add] ${stderr}
+`);
+      }
+      process.stdout.write("Registered nolto MCP server in Claude Code (user scope).\n");
+      process.stdout.write("Reconnect or restart Claude Code to use it.\n");
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `Warning: claude mcp add failed (${msg}); writing project .mcp.json instead.
+`
+      );
+    }
+  }
+  const cwd = opts.claudeCwd ?? process.cwd();
+  const configPath = path3.join(cwd, ".mcp.json");
+  const result = await readJsonConfig(configPath);
+  const existing = result?.parsed ?? {};
+  const updatedServers = {
+    ...existing.mcpServers,
+    nolto: {
+      url: mcpUrl,
+      headers: {
+        Authorization: `Bearer ${opts.token}`
+      },
+      env: {
+        NOLTO_MCP_TOKEN: opts.token
+      }
+    }
+  };
+  const newConfig = {
+    ...existing,
+    mcpServers: updatedServers
+  };
+  await atomicWrite(configPath, JSON.stringify(newConfig, null, 2) + "\n", 384);
+  process.stdout.write(`Updated ${configPath} (claude project .mcp.json)
+`);
+}
+async function injectCodex(opts) {
+  const mcpUrl = `${opts.baseUrl.replace(/\/+$/, "")}/mcp`;
+  const codexPath = await findOnPath("codex");
+  if (!codexPath) {
+    process.stdout.write(
+      `
+To add Nolto to Codex, run:
+
+  codex mcp add nolto --url ${mcpUrl} --bearer-token-env-var NOLTO_TOKEN
+
+Then set NOLTO_TOKEN=${opts.token} in your environment.
+`
+    );
+    return;
+  }
+  try {
+    const execFileAsync2 = getExecFileAsync();
+    const { stderr } = await execFileAsync2(codexPath, [
+      "mcp",
+      "add",
+      "nolto",
+      "--url",
+      mcpUrl,
+      "--bearer-token-env-var",
+      "NOLTO_TOKEN"
+    ]);
+    if (stderr) {
+      process.stderr.write(`[codex mcp add] ${stderr}
+`);
+    }
+    process.stdout.write(`Registered nolto MCP server in Codex.
+`);
+    process.stdout.write(
+      `Set NOLTO_TOKEN=${opts.token.slice(0, 8)}... in your environment (or shell profile).
+`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new CliError(`codex mcp add failed: ${msg}`, 5);
+  }
+}
+async function findOnPath(bin) {
+  try {
+    const execFileAsync2 = getExecFileAsync();
+    const { stdout } = await execFileAsync2(
+      process.platform === "win32" ? "where" : "which",
+      [bin]
+    );
+    const found = stdout.trim().split("\n")[0]?.trim();
+    return found && found.length > 0 ? found : null;
+  } catch {
+    return null;
+  }
+}
+async function injectClient(opts) {
+  switch (opts.client) {
+    case "cursor":
+      return injectCursor(opts);
+    case "claude":
+      return injectClaude(opts);
+    case "codex":
+      return injectCodex(opts);
+    default: {
+      const _never = opts.client;
+      throw new CliError(`Unknown client: ${String(_never)}`, 2);
+    }
+  }
+}
+
+// src/commands/login.ts
+function register2(program, deps) {
+  program.command("login").description("Authenticate via browser and save an API token to the config file.").option("--client <name>", "Inject token into MCP client config (cursor|claude|codex)").option("--force", "Overwrite existing token without prompting").action(
+    async (opts) => {
+      const { configPath, settings, output } = deps;
+      const validClients = ["cursor", "claude", "codex"];
+      if (opts.client !== void 0 && !validClients.includes(opts.client)) {
+        throw new CliError(
+          `--client must be one of: ${validClients.join(", ")}. Got: ${opts.client}`,
+          2
+        );
+      }
+      const clientTarget = opts.client;
+      if (!opts.force) {
+        let existing = null;
+        try {
+          existing = await loadConfigFile(configPath);
+        } catch {
+        }
+        if (existing?.token) {
+          const rl = readline2.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+          try {
+            const answer = await rl.question(
+              `A token is already configured (${maskToken(existing.token)}). Overwrite? [y/N] `
+            );
+            if (answer.trim().toLowerCase() !== "y") {
+              process.stdout.write("Cancelled.\n");
+              return;
+            }
+          } finally {
+            rl.close();
+          }
+        }
+      }
+      const http = createHttpClient({
+        baseUrl: settings.baseUrl,
+        version: deps.version
+      });
+      let startResp;
+      try {
+        startResp = await http.post("/api/cli/auth/start", {});
+      } catch (err) {
+        if (err instanceof CliError && err.exitCode === 4) {
+          throw new CliError(
+            "Rate limit reached. Please wait a few minutes and try again.",
+            4
+          );
+        }
+        throw err;
+      }
+      process.stdout.write("\n");
+      process.stdout.write("Open the following URL in your browser to log in:\n\n");
+      process.stdout.write(`  ${startResp.verification_url}
+
+`);
+      process.stdout.write(`Your confirmation code: ${startResp.user_code}
+
+`);
+      process.stdout.write("Waiting for browser confirmation...\n");
+      const token = await pollUntilToken({
+        http,
+        deviceCode: startResp.device_code,
+        intervalSeconds: startResp.interval,
+        expiresIn: startResp.expires_in,
+        baseUrl: settings.baseUrl
+      });
+      const existingConfig = await loadConfigFile(configPath).catch(() => null);
+      const newConfig = {
+        ...existingConfig,
+        token
+      };
+      await saveConfigFile(configPath, newConfig);
+      process.stdout.write("\n");
+      if (output.mode === "json") {
+        process.stdout.write(
+          JSON.stringify({ ok: true, token: `...${maskToken(token)}` }, null, 2) + "\n"
+        );
+      } else {
+        process.stdout.write(`Saved ${configPath}
+`);
+        process.stdout.write(`token: ${maskToken(token)}
+`);
+      }
+      if (clientTarget) {
+        try {
+          await injectClient({
+            client: clientTarget,
+            token,
+            baseUrl: settings.baseUrl
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(
+            `Warning: failed to inject into ${clientTarget} config: ${msg}
+`
+          );
+        }
+      }
+    }
+  );
+}
+
 // src/output.ts
 function printResult(value, mode2, opts = {}) {
   const out = opts.stream ?? process.stdout;
@@ -480,7 +883,7 @@ function formatValue(value) {
 }
 
 // src/commands/whoami.ts
-function register2(program, deps) {
+function register3(program, deps) {
   program.command("whoami").description("Show the current authentication and configuration state.").action(async () => {
     const { settings, output, configPath } = deps;
     const mode2 = output.mode;
@@ -533,7 +936,7 @@ function assertToken(token) {
     );
   }
 }
-function register3(program, deps) {
+function register4(program, deps) {
   const project = program.command("project").description("Manage projects.");
   project.command("list").description("List all projects.").action(async () => {
     assertToken(deps.settings.token);
@@ -570,9 +973,8 @@ function register3(program, deps) {
   });
   project.command("set-default <projectId>").description("Set the default project.").option("--local", "Write to local config file only (no MCP call)").action(async (projectId, opts) => {
     if (opts.local) {
-      const configPath = getConfigPath(process.env);
-      const existing = await loadConfigFile(configPath).catch(() => null);
-      await saveConfigFile(configPath, { ...existing ?? {}, defaultProjectId: projectId });
+      const existing = await loadConfigFile(deps.configPath).catch(() => null);
+      await saveConfigFile(deps.configPath, { ...existing ?? {}, defaultProjectId: projectId });
     } else {
       assertToken(deps.settings.token);
       await deps.caller.call("set_default_project", { projectId });
@@ -583,18 +985,18 @@ function register3(program, deps) {
 }
 
 // src/commands/plan-register.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 import { z as z2 } from "zod";
 
 // src/fsx.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import path4 from "path";
 async function readPlanFile(filePath) {
-  const absPath = path3.resolve(filePath);
+  const absPath = path4.resolve(filePath);
   let content;
   try {
-    content = await readFile2(absPath, "utf8");
+    content = await readFile3(absPath, "utf8");
   } catch (err) {
     const code = err != null && typeof err === "object" && "code" in err ? err.code : "";
     if (code === "ENOENT") {
@@ -612,11 +1014,11 @@ async function readPlanFile(filePath) {
       2
     );
   }
-  const stem = path3.basename(absPath, path3.extname(absPath));
+  const stem = path4.basename(absPath, path4.extname(absPath));
   return { content: trimmed, sourcePath: absPath, titleFallback: stem };
 }
 async function readDocFile(filePath) {
-  const absPath = path3.resolve(filePath);
+  const absPath = path4.resolve(filePath);
   let fileSize;
   try {
     const info = await stat2(absPath);
@@ -633,12 +1035,12 @@ async function readDocFile(filePath) {
   }
   let buf;
   try {
-    buf = await readFile2(absPath);
+    buf = await readFile3(absPath);
   } catch (err) {
     throw new CliError(`Cannot read file: ${absPath}: ${String(err)}`, 2);
   }
   const isBinary = buf.includes(0) || !isUtf8RoundTrip(buf);
-  const rawFilename = path3.basename(absPath);
+  const rawFilename = path4.basename(absPath);
   const filename = rawFilename.slice(0, DOCUMENT_FILENAME_MAX);
   if (isBinary) {
     return { content: buf.toString("base64"), encoding: "base64", filename };
@@ -695,7 +1097,7 @@ function extractTitle(md) {
 }
 
 // src/commands/plan-register.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify2(execFile2);
 function assertToken2(token) {
   if (token == null) {
     throw new CliError(
@@ -842,7 +1244,7 @@ function assertToken3(token) {
     );
   }
 }
-function register4(program, deps) {
+function register5(program, deps) {
   const plan = program.command("plan").description("Manage plans.");
   plan.command("list").description("List plans.").option("--status <status>", "Filter by status").action(async (opts) => {
     assertToken3(deps.settings.token);
@@ -930,7 +1332,7 @@ function assertToken4(token) {
     );
   }
 }
-function register5(program, deps) {
+function register6(program, deps) {
   const phase = program.command("phase").description("Manage plan phases.");
   phase.command("status <planId> <phaseId> <status>").description("Update a phase status.").option("--message <text>", "Optional message").action(async (planId, phaseId, status, opts) => {
     assertToken4(deps.settings.token);
@@ -1004,7 +1406,7 @@ function assertToken5(token) {
     );
   }
 }
-function register6(program, deps) {
+function register7(program, deps) {
   const doc = program.command("doc").description("Manage plan documents.");
   doc.command("upload <planId>").description("Upload a document to a plan.").requiredOption("--file <path>", "Path to document file").requiredOption("--kind <kind>", `Document kind (${PLAN_DOCUMENT_KINDS.join(", ")})`).option("--phase <phaseId>", "Associate with a specific phase").option("--filename <name>", "Override filename").action(async (planId, opts) => {
     assertToken5(deps.settings.token);
@@ -1038,17 +1440,17 @@ 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 { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3, unlink as unlink2, appendFile } from "fs/promises";
+import path5 from "path";
 import crypto from "crypto";
 function queueFilePath(projectDir) {
-  return path4.join(projectDir, ".nolto", "pending.jsonl");
+  return path5.join(projectDir, ".nolto", "pending.jsonl");
 }
 function lockFilePath(projectDir) {
-  return path4.join(projectDir, ".nolto", "flush.lock");
+  return path5.join(projectDir, ".nolto", "flush.lock");
 }
 function logFilePath(projectDir) {
-  return path4.join(projectDir, ".nolto", "flush.log");
+  return path5.join(projectDir, ".nolto", "flush.log");
 }
 function resolveQueueDir(inputs) {
   if (inputs.flagDir != null) return inputs.flagDir;
@@ -1062,7 +1464,7 @@ function findAncestorWithMarker(startDir) {
     if (hasMarkerSync(current, ".git") || hasMarkerSync(current, ".nolto")) {
       return current;
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -1070,7 +1472,7 @@ function findAncestorWithMarker(startDir) {
 }
 function hasMarkerSync(dir, marker) {
   try {
-    statSync(path4.join(dir, marker));
+    statSync(path5.join(dir, marker));
     return true;
   } catch {
     return false;
@@ -1080,7 +1482,7 @@ async function readQueue(projectDir) {
   const filePath = queueFilePath(projectDir);
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch {
     return [];
   }
@@ -1098,8 +1500,8 @@ async function readQueue(projectDir) {
   return entries;
 }
 async function appendEntry(projectDir, entry) {
-  const noltoDir = path4.join(projectDir, ".nolto");
-  await mkdir2(noltoDir, { recursive: true, mode: 448 });
+  const noltoDir = path5.join(projectDir, ".nolto");
+  await mkdir3(noltoDir, { recursive: true, mode: 448 });
   const existing = await readQueue(projectDir);
   if (existing.length >= QUEUE_MAX_ENTRIES) {
     throw new CliError(
@@ -1129,23 +1531,23 @@ async function atomicRewriteQueue(projectDir, entries) {
   const filePath = queueFilePath(projectDir);
   if (entries.length === 0) {
     try {
-      await unlink(filePath);
+      await unlink2(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 noltoDir = path5.join(projectDir, ".nolto");
+  await mkdir3(noltoDir, { recursive: true });
   const tmpPath = filePath + ".tmp";
   const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await writeFile2(tmpPath, content, "utf8");
+  await writeFile3(tmpPath, content, "utf8");
   renameSync(tmpPath, filePath);
 }
 async function acquireLock(projectDir) {
-  const noltoDir = path4.join(projectDir, ".nolto");
-  await mkdir2(noltoDir, { recursive: true });
+  const noltoDir = path5.join(projectDir, ".nolto");
+  await mkdir3(noltoDir, { recursive: true });
   const lockPath = lockFilePath(projectDir);
   return tryAcquire(lockPath);
 }
@@ -1160,7 +1562,7 @@ async function tryAcquire(lockPath) {
   }
   let pidStr;
   try {
-    pidStr = await readFile3(lockPath, "utf8");
+    pidStr = await readFile4(lockPath, "utf8");
   } catch {
     try {
       unlinkSync(lockPath);
@@ -1205,8 +1607,8 @@ function makeLockHandle(lockPath) {
 }
 async function appendLog(projectDir, level, message) {
   try {
-    const noltoDir = path4.join(projectDir, ".nolto");
-    await mkdir2(noltoDir, { recursive: true });
+    const noltoDir = path5.join(projectDir, ".nolto");
+    await mkdir3(noltoDir, { recursive: true });
     const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${message}
 `;
     await appendFile(logFilePath(projectDir), line, "utf8");
@@ -1413,7 +1815,7 @@ async function runFlushWorker(deps, projectDir) {
     await lock.release();
   }
 }
-function register7(program, deps) {
+function register8(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,
@@ -1459,17 +1861,18 @@ function buildProgram(deps) {
   register4(program, deps);
   register5(program, deps);
   register6(program, deps);
-  registerQueue(program, deps);
   register7(program, deps);
+  registerQueue(program, deps);
+  register8(program, deps);
   return program;
 }
 
 // src/index.ts
-var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
 var require2 = createRequire2(import.meta.url);
 function getVersion() {
   try {
-    const pkgPath = path5.resolve(__dirname2, "../package.json");
+    const pkgPath = path6.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.2.1",
+  "version": "0.3.1",
   "description": "CLI for Nolto — register plans and update progress from your terminal.",
   "license": "MIT",
   "type": "module",