pnote 0.1.0

package/dist/index.js

@@ -0,0 +1,1548 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/lib/errors.ts
+import pc from "picocolors";
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  AUTH_ERROR: 2,
+  NOT_FOUND: 3,
+  NETWORK_ERROR: 4
+};
+var CLIError = class extends Error {
+  constructor(message, exitCode = ExitCode.GENERAL_ERROR, hint) {
+    super(message);
+    this.exitCode = exitCode;
+    this.hint = hint;
+    this.name = "CLIError";
+  }
+};
+var AuthError = class extends CLIError {
+  constructor(message, hint) {
+    super(message, ExitCode.AUTH_ERROR, hint);
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends CLIError {
+  constructor(resource, id) {
+    super(`${resource} not found (id: ${id})`, ExitCode.NOT_FOUND);
+    this.name = "NotFoundError";
+  }
+};
+var NetworkError = class extends CLIError {
+  constructor(message = "Network error. Check your connection.") {
+    super(message, ExitCode.NETWORK_ERROR);
+    this.name = "NetworkError";
+  }
+};
+function formatError(error, noColor = false) {
+  const red = noColor ? (s) => s : pc.red;
+  const dim = noColor ? (s) => s : pc.dim;
+  if (error instanceof CLIError) {
+    let message = `${red("Error:")} ${error.message}`;
+    if (error.hint) {
+      message += `
+${dim("Hint:")} ${error.hint}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `${red("Error:")} ${error.message}`;
+  }
+  return `${red("Error:")} ${String(error)}`;
+}
+function handleError(error, noColor = false) {
+  console.error(formatError(error, noColor));
+  if (error instanceof CLIError) {
+    process.exit(error.exitCode);
+  }
+  process.exit(ExitCode.GENERAL_ERROR);
+}
+
+// src/commands/auth/index.ts
+import { Command } from "commander";
+
+// src/commands/auth/login.ts
+import pc2 from "picocolors";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    return join(xdgConfig, "pnote");
+  }
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const macPath = join(homedir(), "Library", "Application Support", "pnote");
+    if (existsSync(macPath)) {
+      return macPath;
+    }
+  }
+  return join(homedir(), ".config", "pnote");
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  return dir;
+}
+var CREDENTIALS_FILE = "credentials.json";
+function getCredentialsPath() {
+  return join(getConfigDir(), CREDENTIALS_FILE);
+}
+function loadCredentials() {
+  const envToken = process.env.PNOTE_TOKEN;
+  if (envToken) {
+    return {
+      token: envToken,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const path = getCredentialsPath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  const dir = ensureConfigDir();
+  const path = join(dir, CREDENTIALS_FILE);
+  writeFileSync(path, JSON.stringify(credentials, null, 2), "utf-8");
+  chmodSync(path, 384);
+}
+function deleteCredentials() {
+  const path = getCredentialsPath();
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+function getToken() {
+  const creds = loadCredentials();
+  return creds?.token ?? null;
+}
+function isLoggedIn() {
+  return getToken() !== null;
+}
+function validateTokenFormat(token) {
+  return /^pn_[A-Za-z0-9_-]{20,50}$/.test(token);
+}
+var CONFIG_FILE = "config.json";
+function loadConfig() {
+  const path = join(getConfigDir(), CONFIG_FILE);
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+var DEFAULT_API_ENDPOINT = "https://tafnybfhwybgijozwfyq.supabase.co/functions/v1/promptnote-mcp/mcp";
+function getApiEndpoint() {
+  const config = loadConfig();
+  return config.api_endpoint ?? process.env.PNOTE_API_ENDPOINT ?? DEFAULT_API_ENDPOINT;
+}
+
+// src/commands/auth/login.ts
+async function loginAction() {
+  if (isLoggedIn()) {
+    console.log(pc2.yellow("Already logged in."));
+    console.log(pc2.dim(`Credentials stored at: ${getCredentialsPath()}`));
+    console.log("");
+    console.log(`Run ${pc2.cyan("'pnote auth logout'")} to logout first.`);
+    return;
+  }
+  console.log(pc2.bold("Login to PromptNote"));
+  console.log("");
+  console.log("To authenticate, you need a Personal Access Token (PAT).");
+  console.log("");
+  console.log(pc2.dim("Steps:"));
+  console.log("  1. Open " + pc2.cyan("https://app.promptnoteapp.com"));
+  console.log("  2. Go to Settings > API Tokens");
+  console.log("  3. Generate a new token");
+  console.log("  4. Run: " + pc2.cyan("pnote auth token <your-token>"));
+  console.log("");
+  console.log(pc2.dim("Or set the PROMTIE_TOKEN environment variable."));
+}
+
+// src/commands/auth/token.ts
+import pc3 from "picocolors";
+
+// src/lib/api.ts
+function getRestApiBase() {
+  const mcpEndpoint = getApiEndpoint();
+  return mcpEndpoint.replace(/\/mcp$/, "/v1");
+}
+async function callRestApi(method, path, body, options = {}) {
+  const token = getToken();
+  if (!token) {
+    throw new AuthError(
+      "Not logged in",
+      "Run 'pnote auth login' or 'pnote auth token <token>' to authenticate"
+    );
+  }
+  const baseUrl = getRestApiBase();
+  const url = `${baseUrl}${path}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`
+  };
+  if (options.pin) {
+    headers["X-PromptNote-PIN"] = options.pin;
+  }
+  let response;
+  try {
+    const fetchOptions = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(options.timeout ?? 3e4)
+    };
+    if (body && (method === "POST" || method === "PATCH")) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    response = await fetch(url, fetchOptions);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "TimeoutError" || error.name === "AbortError") {
+        throw new NetworkError("Request timed out. Please try again.");
+      }
+      if (error.message.includes("fetch")) {
+        throw new NetworkError("Unable to connect to PromptNote API. Check your internet connection.");
+      }
+    }
+    throw new NetworkError();
+  }
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    if (response.status === 401) {
+      throw new AuthError(
+        errorBody.message || "Invalid or expired token",
+        "Run 'pnote auth login' to re-authenticate"
+      );
+    }
+    if (response.status === 403) {
+      throw new CLIError("Permission denied", ExitCode.AUTH_ERROR);
+    }
+    if (response.status === 404) {
+      throw new CLIError(errorBody.message || "Resource not found", ExitCode.NOT_FOUND);
+    }
+    if (response.status === 400) {
+      throw new CLIError(errorBody.message || "Invalid request", ExitCode.GENERAL_ERROR);
+    }
+    throw new CLIError(`API error (${response.status}): ${errorBody.message || "Unknown error"}`);
+  }
+  return response.json();
+}
+async function listNotes(params = {}, options = {}) {
+  const query = new URLSearchParams();
+  if (params.tag) query.set("tag", params.tag);
+  if (params.archived !== void 0) query.set("archived", String(params.archived));
+  if (params.pinned !== void 0) query.set("pinned", String(params.pinned));
+  if (params.deleted !== void 0) query.set("deleted", String(params.deleted));
+  if (params.protected !== void 0) query.set("protected", String(params.protected));
+  if (params.search) query.set("search", params.search);
+  if (params.limit) query.set("limit", String(params.limit));
+  if (params.offset) query.set("offset", String(params.offset));
+  const queryString = query.toString();
+  return callRestApi("GET", `/notes${queryString ? `?${queryString}` : ""}`, void 0, options);
+}
+async function getNote(id, options = {}) {
+  return callRestApi("GET", `/notes/${id}`, void 0, options);
+}
+async function createNote(data, options = {}) {
+  return callRestApi("POST", "/notes", data, options);
+}
+async function updateNote(id, data, options = {}) {
+  return callRestApi("PATCH", `/notes/${id}`, data, options);
+}
+async function deleteNote(id, options = {}) {
+  return callRestApi("DELETE", `/notes/${id}`, void 0, options);
+}
+async function listSnippets(params, options = {}) {
+  const query = new URLSearchParams();
+  query.set("note_id", params.note_id);
+  if (params.include_deleted !== void 0) query.set("include_deleted", String(params.include_deleted));
+  if (params.limit) query.set("limit", String(params.limit));
+  return callRestApi("GET", `/snippets?${query.toString()}`, void 0, options);
+}
+async function createSnippet(data, options = {}) {
+  return callRestApi("POST", "/snippets", data, options);
+}
+async function toggleFavorite(id, options = {}) {
+  return callRestApi("POST", `/snippets/${id}/favorite`, {}, options);
+}
+async function listTags(params = {}, options = {}) {
+  const query = new URLSearchParams();
+  if (params.include_archived !== void 0) query.set("include_archived", String(params.include_archived));
+  const queryString = query.toString();
+  return callRestApi("GET", `/tags${queryString ? `?${queryString}` : ""}`, void 0, options);
+}
+async function renameTag(data, options = {}) {
+  return callRestApi("POST", "/tags/rename", data, options);
+}
+async function mergeTags(data, options = {}) {
+  return callRestApi("POST", "/tags/merge", data, options);
+}
+async function search(params, options = {}) {
+  const query = new URLSearchParams();
+  query.set("q", params.query);
+  if (params.search_notes !== void 0) query.set("search_notes", String(params.search_notes));
+  if (params.search_snippets !== void 0) query.set("search_snippets", String(params.search_snippets));
+  if (params.limit) query.set("limit", String(params.limit));
+  return callRestApi("GET", `/search?${query.toString()}`, void 0, options);
+}
+var requestId = 0;
+function getNextId() {
+  return ++requestId;
+}
+async function callMCP(toolName, args = {}) {
+  const token = getToken();
+  if (!token) {
+    throw new AuthError(
+      "Not logged in",
+      "Run 'pnote auth login' or 'pnote auth token <token>' to authenticate"
+    );
+  }
+  const endpoint = getApiEndpoint();
+  const request = {
+    jsonrpc: "2.0",
+    id: getNextId(),
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args
+    }
+  };
+  let response;
+  try {
+    response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(3e4)
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "TimeoutError" || error.name === "AbortError") {
+        throw new NetworkError("Request timed out. Please try again.");
+      }
+      if (error.message.includes("fetch")) {
+        throw new NetworkError("Unable to connect to PromptNote API. Check your internet connection.");
+      }
+    }
+    throw new NetworkError();
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    if (response.status === 401) {
+      throw new AuthError(
+        "Invalid or expired token",
+        "Run 'pnote auth login' to re-authenticate"
+      );
+    }
+    if (response.status === 403) {
+      throw new CLIError("Permission denied", ExitCode.AUTH_ERROR);
+    }
+    throw new CLIError(`API error (${response.status}): ${body}`);
+  }
+  const mcpResponse = await response.json();
+  if (mcpResponse.error) {
+    throw new CLIError(`MCP error: ${mcpResponse.error.message}`);
+  }
+  if (!mcpResponse.result) {
+    throw new CLIError("Invalid response from API");
+  }
+  const content = mcpResponse.result.content;
+  if (!content || content.length === 0) {
+    throw new CLIError("Empty response from API");
+  }
+  if (mcpResponse.result.isError) {
+    const errorText = content[0]?.text || "Unknown error";
+    if (errorText.includes("not found") || errorText.includes("PGRST116")) {
+      throw new CLIError("Resource not found", ExitCode.NOT_FOUND);
+    }
+    if (errorText.includes("Unauthorized")) {
+      throw new AuthError(errorText);
+    }
+    throw new CLIError(errorText);
+  }
+  const textContent = content[0]?.text;
+  if (!textContent) {
+    throw new CLIError("No content in response");
+  }
+  try {
+    return JSON.parse(textContent);
+  } catch {
+    return textContent;
+  }
+}
+async function verifyToken(token) {
+  const baseUrl = getApiEndpoint().replace(/\/mcp$/, "/v1");
+  try {
+    const response = await fetch(`${baseUrl}/notes?limit=1`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (response.status === 401) {
+      return { valid: false };
+    }
+    if (!response.ok) {
+      return { valid: false };
+    }
+    return { valid: true };
+  } catch {
+    throw new NetworkError("Unable to verify token. Check your internet connection.");
+  }
+}
+
+// src/commands/auth/token.ts
+async function tokenAction(token) {
+  if (!validateTokenFormat(token)) {
+    throw new CLIError(
+      "Invalid token format",
+      1,
+      "Token should start with 'pn_' followed by 20-50 characters"
+    );
+  }
+  console.log(pc3.dim("Verifying token..."));
+  try {
+    const result = await verifyToken(token);
+    if (!result.valid) {
+      throw new CLIError(
+        "Invalid token",
+        2,
+        "The token was rejected by the server. Please generate a new one."
+      );
+    }
+    saveCredentials({
+      token,
+      email: result.email,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log(pc3.green("\u2713") + " Token saved successfully!");
+    console.log(pc3.dim(`Credentials stored at: ${getCredentialsPath()}`));
+    console.log("");
+    console.log(`You can now use ${pc3.cyan("pnote")} commands.`);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/commands/auth/logout.ts
+import pc4 from "picocolors";
+async function logoutAction() {
+  if (!isLoggedIn()) {
+    console.log(pc4.dim("Not logged in."));
+    return;
+  }
+  const deleted = deleteCredentials();
+  if (deleted) {
+    console.log(pc4.green("\u2713") + " Logged out successfully.");
+  } else {
+    console.log(pc4.dim("No credentials to remove."));
+  }
+  if (process.env.PROMTIE_TOKEN) {
+    console.log("");
+    console.log(
+      pc4.yellow("Note:") + " PROMTIE_TOKEN environment variable is still set."
+    );
+    console.log(pc4.dim("Unset it with: unset PROMTIE_TOKEN"));
+  }
+}
+
+// src/commands/auth/whoami.ts
+import pc5 from "picocolors";
+async function whoamiAction() {
+  if (!isLoggedIn()) {
+    throw new AuthError(
+      "Not logged in",
+      "Run 'pnote auth login' to authenticate"
+    );
+  }
+  const creds = loadCredentials();
+  if (!creds) {
+    throw new AuthError("No credentials found");
+  }
+  try {
+    const result = await callMCP("promptnote_list_notes", {
+      limit: 1
+    });
+    console.log(pc5.green("\u2713") + " Authenticated");
+    console.log("");
+    if (creds.email) {
+      console.log(pc5.dim("Email: ") + creds.email);
+    }
+    console.log(pc5.dim("Token: ") + creds.token.slice(0, 7) + "..." + creds.token.slice(-4));
+    console.log(pc5.dim("Stored: ") + getCredentialsPath());
+    if (process.env.PROMTIE_TOKEN) {
+      console.log(pc5.dim("Source: ") + "PROMTIE_TOKEN environment variable");
+    } else {
+      console.log(pc5.dim("Source: ") + "credentials file");
+    }
+    console.log("");
+    console.log(pc5.dim(`Total notes: ${result.count}`));
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/commands/auth/index.ts
+var authCommand = new Command("auth").description("Manage authentication").addHelpText(
+  "after",
+  `
+Examples:
+  $ pnote auth login           Open browser to login
+  $ pnote auth token pn_xxx    Set token directly
+  $ pnote auth whoami          Show current user
+  $ pnote auth logout          Remove credentials
+`
+);
+authCommand.command("login").description("Login to PromptNote (opens browser)").action(loginAction);
+authCommand.command("token").description("Set API token directly").argument("<token>", "Personal Access Token (pn_xxx)").action(tokenAction);
+authCommand.command("logout").description("Remove stored credentials").action(logoutAction);
+authCommand.command("whoami").description("Show current authenticated user").action(whoamiAction);
+
+// src/commands/notes/index.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/output.ts
+import pc6 from "picocolors";
+function shouldUseColor(ctx) {
+  if (ctx.noColor) return false;
+  if (process.env.NO_COLOR) return false;
+  if (process.env.TERM === "dumb") return false;
+  return process.stdout.isTTY ?? false;
+}
+function isHumanOutput(ctx) {
+  if (ctx.json) return false;
+  if (ctx.plain) return false;
+  return process.stdout.isTTY ?? false;
+}
+function getColors(ctx) {
+  const useColor = shouldUseColor(ctx);
+  return {
+    dim: useColor ? pc6.dim : (s) => s,
+    bold: useColor ? pc6.bold : (s) => s,
+    green: useColor ? pc6.green : (s) => s,
+    yellow: useColor ? pc6.yellow : (s) => s,
+    blue: useColor ? pc6.blue : (s) => s,
+    cyan: useColor ? pc6.cyan : (s) => s,
+    red: useColor ? pc6.red : (s) => s,
+    magenta: useColor ? pc6.magenta : (s) => s
+  };
+}
+function formatRelativeTime(dateStr) {
+  const date = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffDays > 30) {
+    return date.toLocaleDateString();
+  }
+  if (diffDays > 0) {
+    return `${diffDays}d ago`;
+  }
+  if (diffHours > 0) {
+    return `${diffHours}h ago`;
+  }
+  if (diffMins > 0) {
+    return `${diffMins}m ago`;
+  }
+  return "just now";
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function pad(str, width) {
+  if (str.length >= width) return str.slice(0, width);
+  return str + " ".repeat(width - str.length);
+}
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function outputNotes(notes, ctx) {
+  if (ctx.json) {
+    outputJson(notes);
+    return;
+  }
+  if (notes.length === 0) {
+    const c2 = getColors(ctx);
+    console.log(c2.dim("No notes found."));
+    return;
+  }
+  const c = getColors(ctx);
+  if (isHumanOutput(ctx)) {
+    console.log(
+      c.dim(pad("ID", 12)) + "  " + c.dim(pad("TITLE", 30)) + "  " + c.dim(pad("TAGS", 20)) + "  " + c.dim("UPDATED")
+    );
+    for (const note of notes) {
+      const id = truncate(note.id.slice(0, 8), 12);
+      const title = truncate(note.title || "(untitled)", 30);
+      const tags = truncate(note.tags.join(", ") || "-", 20);
+      const updated = formatRelativeTime(note.updated_at);
+      let line = pad(id, 12) + "  " + pad(title, 30) + "  " + pad(tags, 20) + "  " + updated;
+      const indicators = [];
+      if (note.pinned) indicators.push(c.yellow("*"));
+      if (note.archived) indicators.push(c.dim("[A]"));
+      if (note.is_protected) indicators.push(c.magenta("[P]"));
+      if (indicators.length > 0) {
+        line = indicators.join("") + " " + line;
+      }
+      console.log(line);
+    }
+  } else {
+    for (const note of notes) {
+      console.log(
+        [note.id, note.title, note.tags.join(","), note.updated_at].join("	")
+      );
+    }
+  }
+}
+function outputNote(note, snippet, ctx) {
+  if (ctx.json) {
+    outputJson({ ...note, latest_snippet: snippet });
+    return;
+  }
+  const c = getColors(ctx);
+  if (isHumanOutput(ctx)) {
+    console.log(c.bold(note.title || "(untitled)"));
+    console.log(c.dim("ID: ") + note.id);
+    console.log(c.dim("Tags: ") + (note.tags.length > 0 ? note.tags.join(", ") : "-"));
+    console.log(c.dim("Created: ") + new Date(note.created_at).toLocaleString());
+    console.log(c.dim("Updated: ") + new Date(note.updated_at).toLocaleString());
+    const status = [];
+    if (note.pinned) status.push(c.yellow("pinned"));
+    if (note.archived) status.push(c.dim("archived"));
+    if (note.is_protected) status.push(c.magenta("protected"));
+    if (status.length > 0) {
+      console.log(c.dim("Status: ") + status.join(", "));
+    }
+    if (snippet) {
+      console.log("");
+      console.log(c.dim(`--- Snippet v${snippet.version} ---`));
+      console.log(snippet.content);
+    } else {
+      console.log("");
+      console.log(c.dim("(no content)"));
+    }
+  } else {
+    console.log(`Title: ${note.title}`);
+    console.log(`ID: ${note.id}`);
+    console.log(`Tags: ${note.tags.join(", ")}`);
+    if (snippet) {
+      console.log("");
+      console.log(snippet.content);
+    }
+  }
+}
+function outputSnippet(snippet, ctx) {
+  if (ctx.json) {
+    outputJson(snippet);
+    return;
+  }
+  console.log(snippet.content);
+}
+function outputSnippets(snippets, ctx) {
+  if (ctx.json) {
+    outputJson(snippets);
+    return;
+  }
+  if (snippets.length === 0) {
+    const c2 = getColors(ctx);
+    console.log(c2.dim("No snippets found."));
+    return;
+  }
+  const c = getColors(ctx);
+  if (isHumanOutput(ctx)) {
+    for (const snippet of snippets) {
+      const header = `v${snippet.version}` + (snippet.favorite ? c.yellow(" \u2605") : "") + c.dim(` (${formatRelativeTime(snippet.created_at)})`);
+      console.log(c.bold(header));
+      console.log(snippet.content);
+      console.log("");
+    }
+  } else {
+    for (const snippet of snippets) {
+      console.log(`v${snippet.version}	${snippet.id}	${snippet.content.slice(0, 100)}`);
+    }
+  }
+}
+function outputTags(tags, hierarchy, ctx) {
+  if (ctx.json) {
+    outputJson({ tags, hierarchy });
+    return;
+  }
+  if (tags.length === 0) {
+    const c2 = getColors(ctx);
+    console.log(c2.dim("No tags found."));
+    return;
+  }
+  const c = getColors(ctx);
+  if (isHumanOutput(ctx)) {
+    let printTree2 = function(tagPath, prefix, isLast) {
+      const count = tagCountMap.get(tagPath) || 0;
+      const name = tagPath.split("/").pop() || tagPath;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      console.log(prefix + connector + c.cyan(name) + c.dim(` (${count})`));
+      const children = childrenMap.get(tagPath) || [];
+      children.sort();
+      const newPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      children.forEach((child, i) => {
+        printTree2(child, newPrefix, i === children.length - 1);
+      });
+    };
+    var printTree = printTree2;
+    const roots = [];
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      const parts = tag.tag.split("/");
+      if (parts.length === 1) {
+        roots.push(tag.tag);
+      } else {
+        const parent = parts.slice(0, -1).join("/");
+        const children = childrenMap.get(parent) || [];
+        children.push(tag.tag);
+        childrenMap.set(parent, children);
+      }
+    }
+    roots.sort();
+    const tagCountMap = new Map(tags.map((t) => [t.tag, t.count]));
+    roots.forEach((root, i) => {
+      const count = tagCountMap.get(root) || 0;
+      console.log(c.cyan(root) + c.dim(` (${count})`));
+      const children = childrenMap.get(root) || [];
+      children.sort();
+      children.forEach((child, j) => {
+        printTree2(child, "", j === children.length - 1);
+      });
+    });
+  } else {
+    for (const tag of tags) {
+      console.log(`${tag.tag}	${tag.count}`);
+    }
+  }
+}
+function outputSearchResults(query, notes, snippets, ctx) {
+  if (ctx.json) {
+    outputJson({ query, notes, snippets });
+    return;
+  }
+  const c = getColors(ctx);
+  if (notes.length === 0 && snippets.length === 0) {
+    console.log(c.dim(`No results for "${query}"`));
+    return;
+  }
+  if (notes.length > 0) {
+    console.log(c.bold(`Notes (${notes.length})`));
+    console.log("");
+    for (const note of notes) {
+      console.log(
+        "  " + c.cyan(note.id.slice(0, 8)) + "  " + note.title + "  " + c.dim(note.tags.join(", "))
+      );
+    }
+    console.log("");
+  }
+  if (snippets.length > 0) {
+    console.log(c.bold(`Snippets (${snippets.length})`));
+    console.log("");
+    for (const snippet of snippets) {
+      console.log(
+        "  " + c.cyan(snippet.note_id.slice(0, 8)) + "  " + snippet.note_title + c.dim(` v${snippet.version}`)
+      );
+      console.log("    " + c.dim(truncate(snippet.content_preview, 60)));
+    }
+  }
+}
+function outputMessage(message, ctx) {
+  if (ctx.json) {
+    outputJson({ message });
+    return;
+  }
+  const c = getColors(ctx);
+  console.log(c.green("\u2713") + " " + message);
+}
+function logStatus(message) {
+  if (process.stderr.isTTY) {
+    console.error(pc6.dim(message));
+  }
+}
+
+// src/commands/notes/list.ts
+async function listNotesAction(options, ctx) {
+  try {
+    const result = await listNotes(
+      {
+        tag: options.tag,
+        archived: options.archived ?? false,
+        pinned: options.pinned,
+        deleted: options.deleted ?? false,
+        search: options.search,
+        limit: options.limit ? parseInt(options.limit, 10) : 50
+      },
+      { pin: ctx.pin }
+    );
+    outputNotes(result.notes, ctx);
+    if (result.warning && !ctx.json) {
+      console.error("");
+      console.error(result.warning);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/notes/get.ts
+async function getNoteAction(id, ctx) {
+  try {
+    const result = await getNote(id, { pin: ctx.pin });
+    if (!result) {
+      throw new NotFoundError("Note", id);
+    }
+    outputNote(result, result.latest_snippet, ctx);
+    if (result.protection_status?.error && !ctx.json) {
+      console.error("");
+      console.error("Warning: " + result.protection_status.error);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/notes/create.ts
+async function createNoteAction(title, options, ctx) {
+  try {
+    let content = options.content;
+    if (!content && !process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+      if (stdinContent) {
+        content = stdinContent;
+      }
+    }
+    const result = await createNote(
+      {
+        title,
+        tags: options.tag && options.tag.length > 0 ? options.tag : void 0,
+        content
+      },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      outputMessage(`Created note: ${result.note.title} (${result.note.id})`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/notes/archive.ts
+async function archiveNoteAction(id, options, ctx) {
+  try {
+    const archived = !options.undo;
+    const result = await updateNote(
+      id,
+      { archived },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      const action = archived ? "Archived" : "Unarchived";
+      outputMessage(`${action} note: ${result.note.title}`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/notes/pin.ts
+async function pinNoteAction(id, ctx) {
+  try {
+    const note = await getNote(id, { pin: ctx.pin });
+    const newPinned = !note.pinned;
+    const result = await updateNote(
+      id,
+      { pinned: newPinned },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      const action = newPinned ? "Pinned" : "Unpinned";
+      outputMessage(`${action} note: ${result.note.title}`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/notes/delete.ts
+import pc7 from "picocolors";
+import { createInterface } from "readline";
+async function confirm(message) {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(message + " [y/N] ", (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function deleteNoteAction(id, options, ctx) {
+  try {
+    const note = await getNote(id, { pin: ctx.pin });
+    if (!options.force && !ctx.json) {
+      console.log(`About to delete: ${pc7.bold(note.title)}`);
+      const confirmed = await confirm("Are you sure?");
+      if (!confirmed) {
+        console.log(pc7.dim("Cancelled."));
+        return;
+      }
+    }
+    const result = await deleteNote(id, { pin: ctx.pin });
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      outputMessage(`Deleted note: ${note.title}`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/lib/pin.ts
+import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, statSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import pc8 from "picocolors";
+var PIN_CACHE_TTL_MS = 5 * 60 * 1e3;
+var PIN_MAX_ATTEMPTS = 3;
+function getPinCachePath() {
+  const uid = process.getuid?.() ?? "unknown";
+  return join2(tmpdir(), `pnote-pin-${uid}`);
+}
+function getCachedPin() {
+  const cachePath = getPinCachePath();
+  if (!existsSync2(cachePath)) {
+    return null;
+  }
+  try {
+    const stat = statSync(cachePath);
+    const age = Date.now() - stat.mtimeMs;
+    if (age > PIN_CACHE_TTL_MS) {
+      unlinkSync2(cachePath);
+      return null;
+    }
+    const content = readFileSync2(cachePath, "utf-8").trim();
+    return content || null;
+  } catch {
+    return null;
+  }
+}
+function setCachedPin(pin) {
+  const cachePath = getPinCachePath();
+  try {
+    writeFileSync2(cachePath, pin, { mode: 384 });
+  } catch {
+  }
+}
+async function readPinFromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+    const content2 = Buffer.concat(chunks).toString("utf-8");
+    if (content2.includes("\n")) {
+      break;
+    }
+  }
+  const content = Buffer.concat(chunks).toString("utf-8");
+  const firstLine = content.split("\n")[0]?.trim() || "";
+  if (!firstLine) {
+    throw new Error("No PIN provided via stdin");
+  }
+  return firstLine;
+}
+async function promptForPin(noteTitle, hint, maxAttempts = PIN_MAX_ATTEMPTS) {
+  if (!process.stdin.isTTY) {
+    return null;
+  }
+  if (noteTitle) {
+    console.error(pc8.yellow("\u{1F512}") + ` Note "${noteTitle}" is PIN-protected.`);
+  } else {
+    console.error(pc8.yellow("\u{1F512}") + " This action requires your PIN.");
+  }
+  if (hint) {
+    console.error(pc8.dim(`Hint: ${hint}`));
+  }
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const pin = await readPinHidden(
+      attempt > 1 ? `Enter PIN (${attempt}/${maxAttempts}): ` : "Enter PIN: "
+    );
+    if (pin) {
+      return pin;
+    }
+    if (attempt < maxAttempts) {
+      console.error(pc8.red("Invalid or empty PIN. Try again."));
+    }
+  }
+  console.error(pc8.red("Too many attempts."));
+  return null;
+}
+async function readPinHidden(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode?.(true);
+    }
+    process.stderr.write(prompt);
+    let pin = "";
+    const onKeypress = (key) => {
+      const char = key.toString();
+      if (char === "\r" || char === "\n") {
+        process.stderr.write("\n");
+        cleanup();
+        resolve(pin);
+      } else if (char === "") {
+        process.stderr.write("\n");
+        cleanup();
+        process.exit(130);
+      } else if (char === "\x7F" || char === "\b") {
+        if (pin.length > 0) {
+          pin = pin.slice(0, -1);
+          process.stderr.write("\b \b");
+        }
+      } else if (char.length === 1 && char >= " ") {
+        pin += char;
+        process.stderr.write("*");
+      }
+    };
+    const cleanup = () => {
+      process.stdin.removeListener("data", onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode?.(false);
+      }
+      rl.close();
+    };
+    process.stdin.on("data", onKeypress);
+  });
+}
+async function resolvePin(options) {
+  const { pinArg, pinFromStdin, noteTitle, hint, skipCache, skipPrompt } = options;
+  if (pinArg) {
+    return pinArg;
+  }
+  if (pinFromStdin) {
+    try {
+      return await readPinFromStdin();
+    } catch {
+      return null;
+    }
+  }
+  const envPin = process.env.PNOTE_PIN;
+  if (envPin) {
+    return envPin;
+  }
+  if (!skipCache) {
+    const cached = getCachedPin();
+    if (cached) {
+      return cached;
+    }
+  }
+  if (!skipPrompt && process.stdin.isTTY) {
+    const pin = await promptForPin(noteTitle, hint);
+    if (pin) {
+      setCachedPin(pin);
+      return pin;
+    }
+  }
+  return null;
+}
+
+// src/commands/notes/index.ts
+async function buildContext(globalOpts) {
+  const pin = await resolvePin({
+    pinArg: globalOpts.pin,
+    pinFromStdin: globalOpts.pinStdin,
+    skipPrompt: true
+    // Don't prompt interactively for list/search operations
+  });
+  return {
+    json: globalOpts.json ?? false,
+    noColor: globalOpts.noColor ?? false,
+    plain: globalOpts.plain ?? false,
+    pin: pin ?? void 0
+  };
+}
+var notesCommand = new Command2("notes").description("List and manage notes").option("--tag <tag>", 'Filter by tag (e.g., "AI/art")').option("--archived", "Show archived notes").option("--pinned", "Show only pinned notes").option("--deleted", "Show deleted notes").option("--search <query>", "Search notes by title").option("--limit <n>", "Limit number of results", "50").action(async (options, cmd) => {
+  const globalOpts = cmd.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await listNotesAction(options, ctx);
+}).addHelpText(
+  "after",
+  `
+Examples:
+  $ pnote notes                    List all active notes
+  $ pnote notes --tag "AI/art"     Filter by tag
+  $ pnote notes --archived         Show archived notes
+  $ pnote notes --pinned           Show only pinned notes
+  $ pnote notes get abc123         Get note details
+  $ pnote notes create "My Note"   Create a new note
+`
+);
+notesCommand.command("get").description("Get a note with its latest snippet").argument("<id>", "Note ID").action(async (id, _options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await getNoteAction(id, ctx);
+});
+notesCommand.command("create").description("Create a new note").argument("<title>", "Note title").option("--tag <tags...>", "Tags for the note").option("--content <content>", "Initial snippet content").action(async (title, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await createNoteAction(title, options, ctx);
+});
+notesCommand.command("archive").description("Archive or unarchive a note").argument("<id>", "Note ID").option("--undo", "Unarchive the note").action(async (id, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await archiveNoteAction(id, options, ctx);
+});
+notesCommand.command("pin").description("Pin or unpin a note").argument("<id>", "Note ID").action(async (id, _options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await pinNoteAction(id, ctx);
+});
+notesCommand.command("delete").description("Delete a note (soft delete)").argument("<id>", "Note ID").option("--force", "Skip confirmation").action(async (id, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext(globalOpts);
+  await deleteNoteAction(id, options, ctx);
+});
+
+// src/commands/snippet/index.ts
+import { Command as Command3 } from "commander";
+
+// src/commands/snippet/show.ts
+async function showSnippetAction(noteId, options, ctx) {
+  try {
+    if (options.all) {
+      const result = await listSnippets(
+        { note_id: noteId, limit: 100 },
+        { pin: ctx.pin }
+      );
+      outputSnippets(result.snippets, ctx);
+    } else {
+      const result = await getNote(noteId, { pin: ctx.pin });
+      if (result.latest_snippet) {
+        outputSnippet(result.latest_snippet, ctx);
+      } else {
+        if (!ctx.json) {
+          console.error("No snippet content found.");
+        }
+        process.exit(3);
+      }
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/snippet/copy.ts
+import pc9 from "picocolors";
+
+// src/lib/clipboard.ts
+import { default as clipboardy } from "clipboardy";
+async function copyToClipboard(text) {
+  try {
+    await clipboardy.write(text);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("xsel")) {
+      throw new CLIError(
+        "Clipboard not available. Install xsel or xclip on Linux.",
+        1,
+        "Content will be printed to stdout instead."
+      );
+    }
+    throw new CLIError("Failed to copy to clipboard");
+  }
+}
+
+// src/commands/snippet/copy.ts
+async function copySnippetAction(noteId, options, ctx) {
+  try {
+    let snippet = null;
+    if (options.version) {
+      const versionNum = parseInt(options.version, 10);
+      if (isNaN(versionNum)) {
+        throw new CLIError("Invalid version number");
+      }
+      const result = await listSnippets(
+        { note_id: noteId, limit: 100 },
+        { pin: ctx.pin }
+      );
+      snippet = result.snippets.find((s) => s.version === versionNum) || null;
+      if (!snippet) {
+        throw new CLIError(`Version ${versionNum} not found`);
+      }
+    } else {
+      const result = await getNote(noteId, { pin: ctx.pin });
+      snippet = result.latest_snippet;
+    }
+    if (!snippet) {
+      throw new CLIError("No snippet content found");
+    }
+    try {
+      await copyToClipboard(snippet.content);
+      logStatus("Copied to clipboard");
+      if (ctx.json) {
+        console.log(JSON.stringify({ copied: true, content: snippet.content }));
+      }
+    } catch (clipboardError) {
+      if (!ctx.json) {
+        console.error(pc9.yellow("Clipboard not available, printing to stdout:"));
+        console.error("");
+      }
+      console.log(snippet.content);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/snippet/add.ts
+async function addSnippetAction(noteId, options, ctx) {
+  try {
+    let content;
+    if (process.stdin.isTTY) {
+      throw new CLIError(
+        "No content provided",
+        1,
+        "Pipe content to this command: echo 'content' | pnote snippet add <note-id>"
+      );
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    content = Buffer.concat(chunks).toString("utf-8");
+    if (content.endsWith("\n")) {
+      content = content.slice(0, -1);
+    }
+    if (!content) {
+      throw new CLIError("Empty content provided");
+    }
+    const result = await createSnippet(
+      {
+        note_id: noteId,
+        content,
+        title: options.title
+      },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      outputMessage(`Created snippet v${result.snippet.version}`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/snippet/favorite.ts
+async function favoriteSnippetAction(snippetId, ctx) {
+  try {
+    const result = await toggleFavorite(snippetId, { pin: ctx.pin });
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      const status = result.snippet.favorite ? "favorited" : "unfavorited";
+      outputMessage(`Snippet ${status}`, ctx);
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/snippet/index.ts
+async function buildContext2(globalOpts) {
+  const pin = await resolvePin({
+    pinArg: globalOpts.pin,
+    pinFromStdin: globalOpts.pinStdin,
+    skipPrompt: true
+  });
+  return {
+    json: globalOpts.json ?? false,
+    noColor: globalOpts.noColor ?? false,
+    plain: globalOpts.plain ?? false,
+    pin: pin ?? void 0
+  };
+}
+var snippetCommand = new Command3("snippet").description("Read and manage snippets (note versions)").argument("[note-id]", "Note ID to show snippet for").option("--all", "Show all snippet versions").action(async (noteId, options, cmd) => {
+  const globalOpts = cmd.parent?.opts() || {};
+  const ctx = await buildContext2(globalOpts);
+  if (noteId) {
+    await showSnippetAction(noteId, options, ctx);
+  } else {
+    cmd.help();
+  }
+}).addHelpText(
+  "after",
+  `
+Examples:
+  $ pnote snippet abc123           Show latest snippet
+  $ pnote snippet abc123 --all     Show all versions
+  $ pnote snippet copy abc123      Copy to clipboard
+  $ cat file.txt | pnote snippet add abc123
+`
+);
+snippetCommand.command("copy").description("Copy snippet content to clipboard").argument("<note-id>", "Note ID").option("--version <n>", "Specific version number").action(async (noteId, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext2(globalOpts);
+  await copySnippetAction(noteId, options, ctx);
+});
+snippetCommand.command("add").description("Add a new snippet version (from stdin)").argument("<note-id>", "Note ID").option("--title <title>", "Snippet title").action(async (noteId, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext2(globalOpts);
+  await addSnippetAction(noteId, options, ctx);
+});
+snippetCommand.command("favorite").description("Toggle favorite status on a snippet").argument("<snippet-id>", "Snippet ID").action(async (snippetId, _options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext2(globalOpts);
+  await favoriteSnippetAction(snippetId, ctx);
+});
+
+// src/commands/tags/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/tags/list.ts
+async function listTagsAction(options, ctx) {
+  try {
+    const result = await listTags(
+      { include_archived: options.includeArchived ?? false },
+      { pin: ctx.pin }
+    );
+    outputTags(result.tags, result.hierarchy, ctx);
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/tags/rename.ts
+async function renameTagAction(oldTag, newTag, ctx) {
+  try {
+    const result = await renameTag(
+      { old_tag: oldTag, new_tag: newTag },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      outputMessage(
+        `Renamed "${oldTag}" to "${newTag}" (${result.notes_updated} notes updated)`,
+        ctx
+      );
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/tags/merge.ts
+async function mergeTagsAction(sourceTags, targetTag, ctx) {
+  try {
+    if (sourceTags.includes(targetTag)) {
+      throw new CLIError("Source tags cannot include the target tag");
+    }
+    if (sourceTags.length === 0) {
+      throw new CLIError("At least one source tag is required");
+    }
+    const result = await mergeTags(
+      { source_tags: sourceTags, target_tag: targetTag },
+      { pin: ctx.pin }
+    );
+    if (ctx.json) {
+      outputJson(result);
+    } else {
+      const sourceList = sourceTags.map((t) => `"${t}"`).join(", ");
+      outputMessage(
+        `Merged ${sourceList} into "${targetTag}" (${result.notes_updated} notes updated)`,
+        ctx
+      );
+    }
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+
+// src/commands/tags/index.ts
+async function buildContext3(globalOpts) {
+  const pin = await resolvePin({
+    pinArg: globalOpts.pin,
+    pinFromStdin: globalOpts.pinStdin,
+    skipPrompt: true
+  });
+  return {
+    json: globalOpts.json ?? false,
+    noColor: globalOpts.noColor ?? false,
+    plain: globalOpts.plain ?? false,
+    pin: pin ?? void 0
+  };
+}
+var tagsCommand = new Command4("tags").description("List and manage tags").option("--include-archived", "Include tags from archived notes").action(async (options, cmd) => {
+  const globalOpts = cmd.parent?.opts() || {};
+  const ctx = await buildContext3(globalOpts);
+  await listTagsAction(options, ctx);
+}).addHelpText(
+  "after",
+  `
+Examples:
+  $ pnote tags                         List all tags
+  $ pnote tags rename "old" "new"      Rename a tag
+  $ pnote tags merge "tag1" "tag2" --into "target"
+`
+);
+tagsCommand.command("rename").description("Rename a tag across all notes").argument("<old-tag>", "Current tag name").argument("<new-tag>", "New tag name").action(async (oldTag, newTag, _options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext3(globalOpts);
+  await renameTagAction(oldTag, newTag, ctx);
+});
+tagsCommand.command("merge").description("Merge multiple tags into one").argument("<source-tags...>", "Tags to merge (space-separated)").requiredOption("--into <target>", "Target tag to merge into").action(async (sourceTags, options, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() || {};
+  const ctx = await buildContext3(globalOpts);
+  await mergeTagsAction(sourceTags, options.into, ctx);
+});
+
+// src/commands/search.ts
+import { Command as Command5 } from "commander";
+async function searchAction(query, options, ctx) {
+  try {
+    let search_notes = true;
+    let search_snippets = true;
+    if (options.notesOnly) {
+      search_notes = true;
+      search_snippets = false;
+    } else if (options.snippetsOnly) {
+      search_notes = false;
+      search_snippets = true;
+    }
+    const result = await search(
+      {
+        query,
+        search_notes,
+        search_snippets,
+        limit: options.limit ? parseInt(options.limit, 10) : 20
+      },
+      { pin: ctx.pin }
+    );
+    outputSearchResults(query, result.notes, result.snippets, ctx);
+  } catch (error) {
+    handleError(error, ctx.noColor);
+  }
+}
+var searchCommand = new Command5("search").description("Search notes and snippets").argument("<query>", "Search query").option("--notes-only", "Only search note titles and tags").option("--snippets-only", "Only search snippet content").option("--limit <n>", "Limit results", "20").action(async (query, options, cmd) => {
+  const globalOpts = cmd.parent?.opts() || {};
+  const ctx = {
+    json: globalOpts.json ?? false,
+    noColor: globalOpts.noColor ?? false,
+    plain: globalOpts.plain ?? false,
+    pin: globalOpts.pin
+  };
+  await searchAction(query, options, ctx);
+}).addHelpText(
+  "after",
+  `
+Examples:
+  $ pnote search "portrait"          Search all
+  $ pnote search "AI" --notes-only   Search note titles only
+  $ pnote search "code" --limit 50   Limit results
+`
+);
+
+// src/index.ts
+var program = new Command6();
+program.name("pnote").description("pnote - The PromptNote CLI").version("0.1.0", "-V, --version", "Show version number").option("--json", "Output as JSON (for scripting)").option("--no-color", "Disable colored output").option("--plain", "Force plain text output (no formatting)").option("-p, --pin <pin>", "PIN for accessing protected notes").option("--pin-stdin", "Read PIN from stdin (first line only)").configureHelp({
+  sortSubcommands: true,
+  sortOptions: true
+}).addHelpText(
+  "after",
+  `
+PIN Protection:
+  Protected notes require a PIN to access their content.
+  You can provide the PIN in several ways:
+    -p, --pin <pin>      Pass PIN directly (visible in history)
+    --pin-stdin          Read PIN from stdin
+    PNOTE_PIN            Set as environment variable (recommended)
+
+Examples:
+  $ pnote notes                           List all notes
+  $ pnote notes --tag "AI/art"            Filter notes by tag
+  $ pnote notes get abc123 -p 1234        Get protected note with PIN
+  $ export PNOTE_PIN=1234 && pnote notes
+  $ pnote snippet copy abc123             Copy snippet to clipboard
+  $ pnote search "portrait"               Search notes and snippets
+
+Documentation: https://promptnoteapp.com/docs
+`
+);
+program.addCommand(authCommand);
+program.addCommand(notesCommand);
+program.addCommand(snippetCommand);
+program.addCommand(tagsCommand);
+program.addCommand(searchCommand);
+process.on("SIGINT", () => {
+  console.error("\nInterrupted");
+  process.exit(130);
+});
+process.on("SIGTERM", () => {
+  process.exit(0);
+});
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") {
+    process.exit(0);
+  }
+  throw err;
+});
+program.parseAsync(process.argv).catch((error) => {
+  const noColor = program.opts().noColor ?? process.env.NO_COLOR !== void 0;
+  handleError(error, noColor);
+});
+//# sourceMappingURL=index.js.map