@codespring-app/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1403 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/lib/credentials.ts
+import { join } from "path";
+import { homedir } from "os";
+import { mkdir } from "fs/promises";
+async function loadCredentials() {
+  try {
+    const file = Bun.file(CREDENTIALS_PATH);
+    if (!await file.exists())
+      return null;
+    return await file.json();
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(creds) {
+  await mkdir(CODESPRING_DIR, { recursive: true });
+  await Bun.write(CREDENTIALS_PATH, JSON.stringify(creds, null, 2));
+}
+async function clearCredentials() {
+  try {
+    const file = Bun.file(CREDENTIALS_PATH);
+    if (await file.exists()) {
+      await Bun.write(CREDENTIALS_PATH, "");
+      const { unlink } = await import("fs/promises");
+      await unlink(CREDENTIALS_PATH);
+    }
+  } catch {}
+}
+var CODESPRING_DIR, CREDENTIALS_PATH;
+var init_credentials = __esm(() => {
+  CODESPRING_DIR = join(homedir(), ".codespring");
+  CREDENTIALS_PATH = join(CODESPRING_DIR, "credentials.json");
+});
+
+// src/lib/prompts.ts
+import * as readline from "readline";
+function isTTY() {
+  return process.stdin.isTTY === true;
+}
+function createRL() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+}
+async function selectOne(message, options) {
+  if (!isTTY()) {
+    throw new Error("Interactive prompts require a TTY. Use flags instead.");
+  }
+  const rl = createRL();
+  console.error(`
+${message}`);
+  for (let i = 0;i < options.length; i++) {
+    console.error(`  ${i + 1}) ${options[i].label}`);
+  }
+  return new Promise((resolve, reject) => {
+    rl.question(`
+  Select (number): `, (answer) => {
+      rl.close();
+      const idx = parseInt(answer.trim(), 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx].value);
+      } else {
+        reject(new Error("Invalid selection"));
+      }
+    });
+  });
+}
+async function confirm(message) {
+  if (!isTTY())
+    return true;
+  const rl = createRL();
+  return new Promise((resolve) => {
+    rl.question(`${message} [Y/n] `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === "" || trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+async function input(message) {
+  if (!isTTY()) {
+    throw new Error("Interactive prompts require a TTY. Use flags instead.");
+  }
+  const rl = createRL();
+  return new Promise((resolve) => {
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var init_prompts = () => {};
+
+// src/lib/output.ts
+function getMode(flags) {
+  if (flags.json)
+    return "json";
+  if (flags.md)
+    return "md";
+  return process.stdout.isTTY ? "md" : "json";
+}
+function output(data, flags = {}) {
+  const mode = getMode(flags);
+  if (mode === "md") {
+    console.log(toMarkdown(data));
+  } else {
+    console.log(JSON.stringify(data, null, flags.pretty ? 2 : undefined));
+  }
+}
+function success(message) {
+  console.error(`\u2713 ${message}`);
+}
+function toMarkdown(data, depth = 0) {
+  if (data == null)
+    return "_null_";
+  if (typeof data === "string")
+    return data;
+  if (typeof data === "number" || typeof data === "boolean")
+    return String(data);
+  if (Array.isArray(data)) {
+    if (data.length === 0)
+      return "_empty_";
+    if (typeof data[0] === "object" && data[0] !== null && !Array.isArray(data[0])) {
+      return toTable(data);
+    }
+    return data.map((item) => `- ${toMarkdown(item, depth + 1)}`).join(`
+`);
+  }
+  if (typeof data === "object") {
+    const obj = data;
+    if ("data" in obj && Object.keys(obj).length <= 3) {
+      const inner = obj.data;
+      const extra = [];
+      if ("count" in obj)
+        extra.push(`**${obj.count}** results`);
+      if ("hasMore" in obj && obj.hasMore)
+        extra.push("_(has more)_");
+      const footer = extra.length ? `
+
+${extra.join(" | ")}` : "";
+      return toMarkdown(inner, depth) + footer;
+    }
+    if ("content" in obj && typeof obj.content === "string" && obj.content.length > 100) {
+      const meta = Object.entries(obj).filter(([k]) => k !== "content").map(([k, v]) => `**${formatKey(k)}:** ${truncate(String(v ?? ""), 80)}`).join(`
+`);
+      return `${meta}
+
+---
+
+${obj.content}`;
+    }
+    return Object.entries(obj).filter(([, v]) => v != null).map(([k, v]) => {
+      if (typeof v === "object" && v !== null) {
+        return `### ${formatKey(k)}
+
+${toMarkdown(v, depth + 1)}`;
+      }
+      return `**${formatKey(k)}:** ${truncate(String(v), 120)}`;
+    }).join(`
+`);
+  }
+  return String(data);
+}
+function toTable(rows) {
+  const allKeys = Object.keys(rows[0]);
+  const columns = allKeys.filter((k) => {
+    if (SKIP_FIELDS.has(k))
+      return false;
+    if (rows.every((r) => r[k] == null))
+      return false;
+    const sample = rows[0][k];
+    if (typeof sample === "string" && sample.length > 300)
+      return false;
+    if (typeof sample === "object" && sample !== null && !Array.isArray(sample))
+      return false;
+    return true;
+  });
+  const cols = columns.slice(0, 7);
+  const header = cols.map(formatKey);
+  const separator = cols.map(() => "---");
+  const body = rows.map((row) => cols.map((col) => {
+    const val = row[col];
+    if (val == null)
+      return "-";
+    if (Array.isArray(val))
+      return val.length ? val.join(", ") : "-";
+    return truncate(String(val), 50);
+  }));
+  const lines = [
+    `| ${header.join(" | ")} |`,
+    `| ${separator.join(" | ")} |`,
+    ...body.map((row) => `| ${row.join(" | ")} |`)
+  ];
+  return lines.join(`
+`);
+}
+function formatKey(key) {
+  return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).replace(/\bId\b/g, "ID").replace(/\bUrl\b/g, "URL").replace(/\bPrd\b/g, "PRD");
+}
+function truncate(str, max) {
+  if (str.length <= max)
+    return str;
+  return `${str.slice(0, max - 1)}\u2026`;
+}
+var SKIP_FIELDS;
+var init_output = __esm(() => {
+  SKIP_FIELDS = new Set([
+    "flowJson",
+    "mindmapData",
+    "plan",
+    "toolPreferences",
+    "marketResearchId",
+    "currentCheckpointId",
+    "initialCheckpointId",
+    "selectedStarterKit",
+    "userId",
+    "mindmapId"
+  ]);
+});
+
+// src/lib/oauth.ts
+function generateCodeVerifier() {
+  const array = new Uint8Array(64);
+  crypto.getRandomValues(array);
+  return base64url(array);
+}
+async function computeCodeChallenge(verifier) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return base64url(new Uint8Array(hash));
+}
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    Bun.spawn(["open", url]);
+  } else if (platform === "linux") {
+    Bun.spawn(["xdg-open", url]);
+  } else if (platform === "win32") {
+    Bun.spawn(["cmd", "/c", "start", url]);
+  }
+}
+async function startCallbackServer(preferredPort, expectedState) {
+  const port = await findAvailablePort(preferredPort);
+  let resolveCallback;
+  let rejectCallback;
+  const promise = new Promise((resolve, reject) => {
+    resolveCallback = resolve;
+    rejectCallback = reject;
+  });
+  const server = Bun.serve({
+    port,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          const desc = url.searchParams.get("error_description") || error;
+          rejectCallback(new Error(`OAuth error: ${desc}`));
+          return new Response("<html><body><h2>Login failed</h2><p>You can close this tab.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+        }
+        if (!code || state !== expectedState) {
+          rejectCallback(new Error("Invalid callback: missing code or state mismatch"));
+          return new Response("Invalid callback", { status: 400 });
+        }
+        resolveCallback({ code, state });
+        return new Response("<html><body><h2>Login successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      return new Response("Not found", { status: 404 });
+    }
+  });
+  return {
+    promise,
+    stop: () => server.stop(),
+    port
+  };
+}
+async function findAvailablePort(start) {
+  for (let port = start;port < start + 10; port++) {
+    try {
+      const server = Bun.serve({ port, fetch: () => new Response("") });
+      server.stop();
+      return port;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`No available port found (tried ${start}-${start + 9})`);
+}
+
+// src/commands/auth/login.ts
+var exports_login = {};
+__export(exports_login, {
+  authLogin: () => authLogin
+});
+function getApiUrl() {
+  return process.env.CODESPRING_API_URL || DEFAULT_API_URL;
+}
+async function authLogin(flags) {
+  const apiUrl = flags.url || getApiUrl();
+  if (flags["api-key"]) {
+    await apiKeyLogin(apiUrl);
+    return;
+  }
+  await oauthLogin(apiUrl);
+}
+async function apiKeyLogin(apiUrl) {
+  const key = await input("Paste your API key (csk_...):");
+  if (!key.startsWith("csk_")) {
+    throw new Error("Invalid API key format. Keys start with csk_");
+  }
+  const response = await fetch(`${apiUrl}/api/workspaces`, {
+    headers: { "x-api-key": key }
+  });
+  if (!response.ok) {
+    throw new Error("Invalid API key. Please check and try again.");
+  }
+  await saveCredentials({
+    type: "api-key",
+    apiKey: key,
+    apiUrl
+  });
+  success("Authenticated with API key.");
+}
+async function oauthLogin(apiUrl) {
+  const existing = await loadCredentials();
+  if (existing?.accessToken) {
+    console.error("Already logged in. Use 'codespring auth logout' first, or --api-key to switch.");
+  }
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = await computeCodeChallenge(codeVerifier);
+  const state = crypto.randomUUID();
+  const { promise: callbackPromise, stop, port } = await startCallbackServer(CALLBACK_PORT, state);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: "codespring-cli",
+    redirect_uri: redirectUri,
+    scope: "openid profile email offline_access",
+    state,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  });
+  const authUrl = `${apiUrl}/api/auth/oauth2/authorize?${params}`;
+  console.error("Opening browser to log in...");
+  openBrowser(authUrl);
+  console.error("Waiting for authentication...");
+  try {
+    const { code } = await callbackPromise;
+    const tokenResponse = await fetch(`${apiUrl}/api/auth/oauth2/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: redirectUri,
+        client_id: "codespring-cli",
+        code_verifier: codeVerifier
+      })
+    });
+    if (!tokenResponse.ok) {
+      const errText = await tokenResponse.text();
+      throw new Error(`Token exchange failed: ${errText}`);
+    }
+    const tokens = await tokenResponse.json();
+    await saveCredentials({
+      type: "oauth",
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiresAt: new Date(Date.now() + tokens.expires_in * 1000).toISOString(),
+      apiUrl
+    });
+    success("Logged in successfully.");
+  } finally {
+    stop();
+  }
+}
+var DEFAULT_API_URL = "https://server.codespring.app", CALLBACK_PORT = 8923;
+var init_login = __esm(() => {
+  init_credentials();
+  init_prompts();
+  init_output();
+});
+
+// src/commands/auth/status.ts
+var exports_status = {};
+__export(exports_status, {
+  authStatus: () => authStatus
+});
+async function authStatus(flags) {
+  const creds = await loadCredentials();
+  if (!creds || !creds.accessToken && !creds.apiKey) {
+    output({ authenticated: false, message: "Not logged in" }, flags);
+    return;
+  }
+  output({
+    authenticated: true,
+    type: creds.type,
+    apiUrl: creds.apiUrl,
+    ...creds.expiresAt && { expiresAt: creds.expiresAt }
+  }, flags);
+}
+var init_status = __esm(() => {
+  init_credentials();
+  init_output();
+});
+
+// src/commands/auth/logout.ts
+var exports_logout = {};
+__export(exports_logout, {
+  authLogout: () => authLogout
+});
+async function authLogout() {
+  await clearCredentials();
+  success("Logged out.");
+}
+var init_logout = __esm(() => {
+  init_credentials();
+  init_output();
+});
+
+// src/lib/config.ts
+import { join as join2 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+function getConfigDir(cwd) {
+  return join2(cwd || process.cwd(), ".codespring");
+}
+function getConfigPath(cwd) {
+  return join2(getConfigDir(cwd), "config.json");
+}
+async function loadConfig(cwd) {
+  try {
+    const file = Bun.file(getConfigPath(cwd));
+    if (!await file.exists())
+      return null;
+    return await file.json();
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config, cwd) {
+  const dir = getConfigDir(cwd);
+  await mkdir2(dir, { recursive: true });
+  await Bun.write(getConfigPath(cwd), JSON.stringify(config, null, 2) + `
+`);
+  await ensureGitignore(cwd);
+}
+async function ensureGitignore(cwd) {
+  const gitignorePath = join2(cwd || process.cwd(), ".gitignore");
+  try {
+    const file = Bun.file(gitignorePath);
+    if (await file.exists()) {
+      const content = await file.text();
+      if (!content.includes(".codespring")) {
+        await Bun.write(gitignorePath, content.trimEnd() + `
+
+# CodeSpring local config
+.codespring/
+`);
+      }
+    }
+  } catch {}
+}
+var init_config = () => {};
+
+// src/lib/api.ts
+async function refreshToken(creds) {
+  if (!creds.refreshToken) {
+    throw new Error("No refresh token available. Run: codespring auth login");
+  }
+  const response = await fetch(`${creds.apiUrl}/api/auth/oauth2/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: creds.refreshToken,
+      client_id: "codespring-cli"
+    })
+  });
+  if (!response.ok) {
+    throw new Error("Token refresh failed. Run: codespring auth login");
+  }
+  const tokens = await response.json();
+  const updated = {
+    ...creds,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token || creds.refreshToken,
+    expiresAt: new Date(Date.now() + tokens.expires_in * 1000).toISOString()
+  };
+  await saveCredentials(updated);
+  return updated;
+}
+async function apiCall(options) {
+  let creds = await loadCredentials();
+  if (!creds) {
+    throw new Error("Not authenticated. Run: codespring auth login");
+  }
+  if (creds.type === "oauth" && creds.expiresAt && new Date(creds.expiresAt) < new Date) {
+    creds = await refreshToken(creds);
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (creds.type === "api-key" && creds.apiKey) {
+    headers["x-api-key"] = creds.apiKey;
+  } else if (creds.type === "oauth" && creds.accessToken) {
+    headers["Authorization"] = `Bearer ${creds.accessToken}`;
+  }
+  const apiUrl = creds.apiUrl || DEFAULT_API_URL2;
+  const baseUrl = apiUrl.replace(/\/api\/?$/, "");
+  const response = await fetch(`${baseUrl}/api${options.path}`, {
+    method: options.method,
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`API error (${response.status}): ${text.slice(0, 200)}`);
+  }
+  try {
+    return { data: JSON.parse(text), status: response.status };
+  } catch {
+    return { data: text, status: response.status };
+  }
+}
+var DEFAULT_API_URL2 = "https://server.codespring.app";
+var init_api = __esm(() => {
+  init_credentials();
+});
+
+// src/commands/init.ts
+var exports_init = {};
+__export(exports_init, {
+  init: () => init
+});
+import { basename } from "path";
+async function init(flags) {
+  const existing = await loadConfig();
+  if (existing && !flags.force) {
+    console.error(`Already linked to: ${existing.projectName}`);
+    const proceed2 = await confirm("Re-link to a different project?");
+    if (!proceed2)
+      return;
+  }
+  if (flags.project) {
+    const { data } = await apiCall({
+      path: `/projects/${flags.project}`,
+      method: "GET"
+    });
+    const project2 = data;
+    await saveConfig({
+      version: "1.0",
+      projectId: project2.id,
+      projectName: project2.name,
+      organizationId: project2.organizationId,
+      linkedAt: new Date().toISOString()
+    });
+    output({ linked: true, project: project2.name, projectId: project2.id }, flags);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive init requires a TTY. Use: codespring init --project <id>");
+  }
+  const proceed = await confirm(`Set up CodeSpring in "${process.cwd()}"?`);
+  if (!proceed)
+    return;
+  const { data: wsData } = await apiCall({
+    path: "/workspaces",
+    method: "GET"
+  });
+  const workspaces = wsData.data;
+  const workspace = await selectOne("Select a workspace:", workspaces.map((w) => ({
+    label: `${w.name} (${w.projectCount} projects)${w.role ? ` - ${w.role}` : ""}`,
+    value: w
+  })));
+  const orgParam = workspace.id ? `?organizationId=${workspace.id}` : "";
+  const { data: projData } = await apiCall({
+    path: `/projects${orgParam}`,
+    method: "GET"
+  });
+  const projects = projData.data;
+  if (projects.length === 0) {
+    throw new Error("No projects found in this workspace.");
+  }
+  const dirName = basename(process.cwd()).toLowerCase();
+  const autoMatch = projects.find((p) => p.name.toLowerCase() === dirName || slugify(p.name) === dirName);
+  let project;
+  if (autoMatch) {
+    const useMatch = await confirm(`Found project "${autoMatch.name}". Link to it?`);
+    if (useMatch) {
+      project = autoMatch;
+    } else {
+      project = await selectOne("Select a project:", projects.map((p) => ({ label: p.name, value: p })));
+    }
+  } else {
+    project = await selectOne("Select a project:", projects.map((p) => ({ label: p.name, value: p })));
+  }
+  await saveConfig({
+    version: "1.0",
+    projectId: project.id,
+    projectName: project.name,
+    organizationId: project.organizationId,
+    linkedAt: new Date().toISOString()
+  });
+  success(`Linked to ${project.name}`);
+  output({ linked: true, project: project.name, projectId: project.id }, flags);
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var init_init = __esm(() => {
+  init_config();
+  init_api();
+  init_output();
+  init_prompts();
+});
+
+// src/commands/status.ts
+var exports_status2 = {};
+__export(exports_status2, {
+  status: () => status
+});
+async function status(flags) {
+  const config = await loadConfig();
+  const creds = await loadCredentials();
+  output({
+    linked: !!config,
+    ...config && {
+      projectId: config.projectId,
+      projectName: config.projectName,
+      organizationId: config.organizationId,
+      linkedAt: config.linkedAt
+    },
+    authenticated: !!(creds?.accessToken || creds?.apiKey),
+    authType: creds?.type || null
+  }, flags);
+}
+var init_status2 = __esm(() => {
+  init_config();
+  init_credentials();
+  init_output();
+});
+
+// src/commands/workspaces.ts
+var exports_workspaces = {};
+__export(exports_workspaces, {
+  workspaces: () => workspaces
+});
+async function workspaces(flags) {
+  const { data } = await apiCall({ path: "/workspaces", method: "GET" });
+  output(data, flags);
+}
+var init_workspaces = __esm(() => {
+  init_api();
+  init_output();
+});
+
+// src/commands/projects.ts
+var exports_projects = {};
+__export(exports_projects, {
+  projects: () => projects
+});
+async function projects(flags) {
+  const params = new URLSearchParams;
+  if (flags.org)
+    params.set("organizationId", flags.org);
+  const query = params.toString();
+  const { data } = await apiCall({
+    path: `/projects${query ? `?${query}` : ""}`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+var init_projects = __esm(() => {
+  init_api();
+  init_output();
+});
+
+// src/lib/ensure-linked.ts
+async function ensureLinked() {
+  const config = await loadConfig();
+  if (config)
+    return config;
+  if (!process.stdin.isTTY) {
+    throw new Error("Not linked to a CodeSpring project. Run: codespring init");
+  }
+  console.error("This directory is not linked to a CodeSpring project.");
+  await init({});
+  const newConfig = await loadConfig();
+  if (!newConfig) {
+    throw new Error("Failed to link project. Run: codespring init");
+  }
+  return newConfig;
+}
+var init_ensure_linked = __esm(() => {
+  init_config();
+  init_init();
+});
+
+// src/commands/features.ts
+var exports_features = {};
+__export(exports_features, {
+  features: () => features
+});
+async function features(flags) {
+  const config = await ensureLinked();
+  const { data } = await apiCall({
+    path: `/mindmap-features/project/${config.projectId}`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+var init_features = __esm(() => {
+  init_api();
+  init_output();
+  init_ensure_linked();
+});
+
+// src/commands/tasks.ts
+var exports_tasks = {};
+__export(exports_tasks, {
+  tasks: () => tasks,
+  taskUpdate: () => taskUpdate,
+  taskStart: () => taskStart,
+  taskDone: () => taskDone
+});
+async function tasks(flags) {
+  const config = await ensureLinked();
+  const params = new URLSearchParams;
+  if (flags.status)
+    params.set("status", flags.status);
+  if (flags.feature)
+    params.set("featureId", flags.feature);
+  if (flags.priority)
+    params.set("priority", flags.priority);
+  const query = params.toString();
+  const { data } = await apiCall({
+    path: `/tasks/${config.projectId}${query ? `?${query}` : ""}`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+async function taskStart(taskId, flags) {
+  const config = await ensureLinked();
+  const { data } = await apiCall({
+    path: `/tasks/${config.projectId}/${taskId}`,
+    method: "PATCH",
+    body: { status: "in_progress" }
+  });
+  output(data, flags);
+}
+async function taskDone(taskId, flags) {
+  const config = await ensureLinked();
+  const { data } = await apiCall({
+    path: `/tasks/${config.projectId}/${taskId}`,
+    method: "PATCH",
+    body: { status: "done" }
+  });
+  output(data, flags);
+}
+async function taskUpdate(taskId, flags) {
+  const config = await ensureLinked();
+  const body = {};
+  if (flags.status)
+    body.status = flags.status;
+  if (flags.title)
+    body.title = flags.title;
+  if (flags.description)
+    body.description = flags.description;
+  if (flags.priority)
+    body.priority = flags.priority;
+  if (flags.estimate)
+    body.estimate = flags.estimate;
+  if (Object.keys(body).length === 0) {
+    throw new Error("No fields to update. Use --status, --title, etc.");
+  }
+  const { data } = await apiCall({
+    path: `/tasks/${config.projectId}/${taskId}`,
+    method: "PATCH",
+    body
+  });
+  output(data, flags);
+}
+var init_tasks = __esm(() => {
+  init_api();
+  init_output();
+  init_ensure_linked();
+});
+
+// src/commands/prds.ts
+var exports_prds = {};
+__export(exports_prds, {
+  prds: () => prds,
+  prdSync: () => prdSync,
+  prdGet: () => prdGet
+});
+async function prds(flags) {
+  const config = await ensureLinked();
+  const { data } = await apiCall({
+    path: `/prds/project/${config.projectId}/structure?includeContent=false`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+async function prdGet(prdId, flags) {
+  const { data } = await apiCall({
+    path: `/prds/${prdId}`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+async function prdSync(prdId, flags) {
+  let content;
+  if (flags.file) {
+    const file = Bun.file(flags.file);
+    if (!await file.exists()) {
+      throw new Error(`File not found: ${flags.file}`);
+    }
+    content = await file.text();
+  } else if (flags.stdin) {
+    const chunks = [];
+    const reader = process.stdin;
+    for await (const chunk of reader) {
+      chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+    }
+    content = chunks.join("");
+  } else {
+    throw new Error("Provide --file <path> or --stdin");
+  }
+  const body = { content };
+  if (flags.name)
+    body.name = flags.name;
+  const { data } = await apiCall({
+    path: `/prds/${prdId}`,
+    method: "PUT",
+    body
+  });
+  output(data, flags);
+}
+var init_prds = __esm(() => {
+  init_api();
+  init_output();
+  init_ensure_linked();
+});
+
+// src/commands/mindmap.ts
+var exports_mindmap = {};
+__export(exports_mindmap, {
+  mindmapTechStack: () => mindmapTechStack,
+  mindmapNote: () => mindmapNote,
+  mindmapGet: () => mindmapGet,
+  mindmapFeatures: () => mindmapFeatures
+});
+async function mindmapGet(flags) {
+  const config = await ensureLinked();
+  const { data } = await apiCall({
+    path: `/mindmaps/project/${config.projectId}`,
+    method: "GET"
+  });
+  output(data, flags);
+}
+async function mindmapTechStack(flags) {
+  const config = await ensureLinked();
+  if (!flags.add) {
+    throw new Error("Provide --add '<json array of items>'");
+  }
+  let items;
+  try {
+    items = JSON.parse(flags.add);
+  } catch {
+    throw new Error("Invalid JSON for --add. Expected array of {id, title, description}");
+  }
+  const { data } = await apiCall({
+    path: `/mindmaps/project/${config.projectId}/tech-stack`,
+    method: "PATCH",
+    body: {
+      items,
+      mode: flags.replace ? "replace" : "merge"
+    }
+  });
+  output(data, flags);
+}
+async function mindmapFeatures(flags) {
+  const config = await ensureLinked();
+  if (!flags.add) {
+    throw new Error("Provide --add '<json array of items>'");
+  }
+  let items;
+  try {
+    items = JSON.parse(flags.add);
+  } catch {
+    throw new Error("Invalid JSON for --add. Expected array of {title, description}");
+  }
+  const { data } = await apiCall({
+    path: `/mindmaps/project/${config.projectId}/features`,
+    method: "PATCH",
+    body: {
+      items,
+      mode: flags.replace ? "replace" : "append"
+    }
+  });
+  output(data, flags);
+}
+async function mindmapNote(featureId, flags) {
+  const config = await ensureLinked();
+  if (!flags.text) {
+    throw new Error("Provide --text '<note content>'");
+  }
+  const content = flags.text;
+  const title = flags.title || "Notes";
+  const { data: mindmapData } = await apiCall({
+    path: `/mindmaps/project/${config.projectId}`,
+    method: "GET"
+  });
+  const mindmap = mindmapData;
+  if (!mindmap.flowJson) {
+    throw new Error("Mindmap has no flowJson data");
+  }
+  const nodes = mindmap.flowJson.nodes;
+  const edges = mindmap.flowJson.edges;
+  const featuresNode = nodes.find((n) => n.id === "node-features");
+  if (!featuresNode?.data?.items) {
+    throw new Error("Features node not found or has no items");
+  }
+  const featureItems = featuresNode.data.items;
+  const feature = featureItems.find((item) => item.id === featureId);
+  if (!feature) {
+    const validIds = featureItems.map((i) => i.id).join(", ");
+    throw new Error(`Feature "${featureId}" not found. Valid IDs: ${validIds}`);
+  }
+  const bridgeNodeId = `bridge-feature-${featureId}`;
+  let bridgeNode = nodes.find((n) => n.id === bridgeNodeId);
+  const newNodes = [];
+  const newEdges = [];
+  if (!bridgeNode) {
+    const featuresX = featuresNode.position?.x || 1200;
+    const featuresY = featuresNode.position?.y || 200;
+    const featureIndex = featureItems.findIndex((i) => i.id === featureId);
+    const bridgeX = featuresX + 496;
+    const bridgeY = featuresY + 56 + featureIndex * 50;
+    bridgeNode = {
+      id: bridgeNodeId,
+      type: "bridge",
+      position: { x: bridgeX, y: bridgeY },
+      data: {
+        featureId,
+        count: 1,
+        isExpanded: true,
+        handlePosition: "left"
+      }
+    };
+    newNodes.push(bridgeNode);
+    newEdges.push({
+      id: `edge-features-bridge-${featureId}`,
+      source: "node-features",
+      target: bridgeNodeId,
+      sourceHandle: `node-features-source-${featureId}`,
+      targetHandle: `${bridgeNodeId}-target-${featureId}`,
+      type: "default",
+      animated: true,
+      className: "stroke-foreground",
+      style: { strokeWidth: 2 }
+    });
+  }
+  const notesNodeId = `notes-${featureId}`;
+  let notesNode = nodes.find((n) => n.id === notesNodeId);
+  if (notesNode) {
+    notesNode.data = { ...notesNode.data, title, content };
+  } else {
+    const bridgeX = bridgeNode.position?.x || 1700;
+    const bridgeY = bridgeNode.position?.y || 256;
+    notesNode = {
+      id: notesNodeId,
+      type: "tertiary",
+      position: { x: bridgeX + 200, y: bridgeY },
+      data: {
+        type: "notes",
+        title,
+        content,
+        handlePosition: "left"
+      }
+    };
+    newNodes.push(notesNode);
+    newEdges.push({
+      id: `edge-bridge-${featureId}-notes`,
+      source: bridgeNodeId,
+      target: notesNodeId,
+      sourceHandle: `${bridgeNodeId}-source-notes`,
+      targetHandle: `${notesNodeId}-target-notes`,
+      type: "default",
+      animated: true,
+      className: "stroke-foreground",
+      style: { strokeWidth: 2 }
+    });
+    if (bridgeNode.data) {
+      const currentCount = typeof bridgeNode.data.count === "number" ? bridgeNode.data.count : 0;
+      bridgeNode.data.count = currentCount + 1;
+    }
+  }
+  const updatedNodes = [
+    ...nodes.filter((n) => n.id !== notesNodeId && !newNodes.some((nn) => nn.id === n.id)),
+    ...newNodes,
+    ...notesNode && !newNodes.includes(notesNode) ? [notesNode] : []
+  ];
+  const updatedEdges = [...edges, ...newEdges];
+  const { data } = await apiCall({
+    path: `/mindmaps/project/${config.projectId}`,
+    method: "PUT",
+    body: { flowJson: { nodes: updatedNodes, edges: updatedEdges } }
+  });
+  output(data, flags);
+}
+var init_mindmap = __esm(() => {
+  init_api();
+  init_output();
+  init_ensure_linked();
+});
+
+// src/commands/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  schema: () => schema
+});
+async function schema(flags) {
+  output(SCHEMA, flags);
+}
+var SCHEMA;
+var init_schema = __esm(() => {
+  init_output();
+  SCHEMA = {
+    project: {
+      id: "string (UUID)",
+      name: "string",
+      description: "string | null",
+      userId: "string",
+      organizationId: "string | null",
+      planningComplete: "boolean",
+      createdAt: "Date",
+      updatedAt: "Date"
+    },
+    mindmap: {
+      id: "string",
+      projectId: "string",
+      flowJson: "{ nodes: MindmapNode[], edges: MindmapEdge[] }"
+    },
+    techStackItem: {
+      id: 'string (e.g., "tech-react")',
+      title: 'string (e.g., "React")',
+      description: 'string (category, e.g., "Frontend")'
+    },
+    featureItem: {
+      id: "string (optional, auto-generated)",
+      title: 'string (e.g., "Authentication")',
+      description: "string (brief description)"
+    },
+    prd: {
+      id: "string (UUID)",
+      name: "string",
+      projectId: "string",
+      prdType: "frontend | backend | database",
+      content: "string (Markdown)"
+    },
+    techCategories: [
+      "Frontend",
+      "Backend",
+      "Database",
+      "State",
+      "Styling",
+      "Testing",
+      "DevTools",
+      "Infrastructure",
+      "Utilities"
+    ]
+  };
+});
+
+// src/commands/node-types.ts
+var exports_node_types = {};
+__export(exports_node_types, {
+  nodeTypes: () => nodeTypes
+});
+async function nodeTypes(flags) {
+  output(NODE_TYPES, flags);
+}
+var NODE_TYPES;
+var init_node_types = __esm(() => {
+  init_output();
+  NODE_TYPES = {
+    primary: {
+      description: "Central project node",
+      exampleId: "node-primary",
+      dataFields: ["title", "description", "githubUrl"]
+    },
+    secondary: {
+      description: "Major category nodes (features, tech-stack, competitors, audience)",
+      exampleIds: [
+        "node-features",
+        "node-tech-stack",
+        "node-competitors",
+        "node-audience"
+      ],
+      dataFields: ["title", "subtitle", "handlePosition", "layout", "items"]
+    },
+    bridge: {
+      description: "Connector nodes between features and detail nodes",
+      idPattern: "bridge-feature-{featureId}",
+      dataFields: ["featureId", "count", "isExpanded", "handlePosition"]
+    },
+    tertiary: {
+      description: "Detail nodes (notes, PRDs)",
+      idPattern: "notes-{featureId} or prd-{featureId}",
+      dataFields: ["type", "title", "content", "handlePosition"]
+    },
+    specialNodeIds: {
+      "node-primary": "Main project node (required)",
+      "node-features": "Features list (required)",
+      "node-tech-stack": "Tech stack (required)",
+      "node-competitors": "Competitors list",
+      "node-audience": "Target audience"
+    },
+    handlePatterns: {
+      featureToBridge: {
+        sourceHandle: "node-features-source-{featureId}",
+        targetHandle: "bridge-feature-{featureId}-target-{featureId}"
+      },
+      bridgeToNotes: {
+        sourceHandle: "bridge-feature-{featureId}-source-notes",
+        targetHandle: "notes-{featureId}-target-notes"
+      }
+    }
+  };
+});
+
+// src/index.ts
+var VERSION = "0.1.0";
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { positional, flags };
+}
+function showHelp() {
+  console.log(`codespring v${VERSION} \u2014 CodeSpring CLI
+
+Usage: codespring <command> [options]
+
+Auth:
+  auth login [--api-key] [--url <api-url>]   Log in via browser OAuth or API key
+  auth status                                 Show authentication status
+  auth logout                                 Clear stored credentials
+
+Setup:
+  init [--project <id>] [--force]             Link directory to a CodeSpring project
+  status                                      Show linked project info
+
+Data:
+  workspaces                                  List workspaces
+  projects [--org <id>]                       List projects
+  features                                    List features for linked project
+
+Tasks:
+  tasks [--status <s>] [--feature <id>] [--priority <p>]   List tasks
+  task start <id>                             Mark task as in_progress
+  task done <id>                              Mark task as done
+  task update <id> --status <s>               Update task fields
+
+PRDs:
+  prds                                        List PRDs by feature
+  prd <id>                                    Get full PRD content
+  prd sync <id> --file <path>                 Update PRD content from file
+
+Mindmap:
+  mindmap                                     Get mindmap structure
+  mindmap tech-stack --add '<json>' [--replace]   Update tech stack
+  mindmap features --add '<json>' [--replace]     Update features
+  mindmap note <featureId> --text '<text>'        Add notes to a feature
+
+Reference:
+  schema                                      Show data schema reference
+  node-types                                  Show mindmap node types
+
+Options:
+  --md                                        Markdown output (default in terminal)
+  --json                                      JSON output (default when piped)
+  --pretty                                    Pretty-print JSON output
+  --help, -h                                  Show this help
+  --version, -v                               Show version`);
+}
+async function main() {
+  const { positional, flags } = parseArgs(process.argv.slice(2));
+  const [command, subcommand, ...rest] = positional;
+  if (flags.help || flags.h) {
+    showHelp();
+    return;
+  }
+  if (flags.version || flags.v) {
+    console.log(VERSION);
+    return;
+  }
+  if (!command) {
+    showHelp();
+    return;
+  }
+  try {
+    switch (command) {
+      case "auth": {
+        switch (subcommand) {
+          case "login": {
+            const { authLogin: authLogin2 } = await Promise.resolve().then(() => (init_login(), exports_login));
+            return authLogin2(flags);
+          }
+          case "status": {
+            const { authStatus: authStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+            return authStatus2(flags);
+          }
+          case "logout": {
+            const { authLogout: authLogout2 } = await Promise.resolve().then(() => (init_logout(), exports_logout));
+            return authLogout2();
+          }
+          default:
+            console.error("Usage: codespring auth <login|status|logout>");
+            process.exit(1);
+        }
+        break;
+      }
+      case "init": {
+        const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+        return init2(flags);
+      }
+      case "status": {
+        const { status: status2 } = await Promise.resolve().then(() => (init_status2(), exports_status2));
+        return status2(flags);
+      }
+      case "workspaces": {
+        const { workspaces: workspaces2 } = await Promise.resolve().then(() => (init_workspaces(), exports_workspaces));
+        return workspaces2(flags);
+      }
+      case "projects": {
+        const { projects: projects2 } = await Promise.resolve().then(() => (init_projects(), exports_projects));
+        return projects2(flags);
+      }
+      case "features": {
+        const { features: features2 } = await Promise.resolve().then(() => (init_features(), exports_features));
+        return features2(flags);
+      }
+      case "tasks": {
+        const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+        return tasks2(flags);
+      }
+      case "task": {
+        switch (subcommand) {
+          case "start": {
+            const taskId = rest[0];
+            if (!taskId)
+              throw new Error("Usage: codespring task start <id>");
+            const { taskStart: taskStart2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+            return taskStart2(taskId, flags);
+          }
+          case "done": {
+            const taskId = rest[0];
+            if (!taskId)
+              throw new Error("Usage: codespring task done <id>");
+            const { taskDone: taskDone2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+            return taskDone2(taskId, flags);
+          }
+          case "update": {
+            const taskId = rest[0];
+            if (!taskId)
+              throw new Error("Usage: codespring task update <id> --status <s>");
+            const { taskUpdate: taskUpdate2 } = await Promise.resolve().then(() => (init_tasks(), exports_tasks));
+            return taskUpdate2(taskId, flags);
+          }
+          default:
+            console.error("Usage: codespring task <start|done|update> <id>");
+            process.exit(1);
+        }
+        break;
+      }
+      case "prds": {
+        const { prds: prds2 } = await Promise.resolve().then(() => (init_prds(), exports_prds));
+        return prds2(flags);
+      }
+      case "prd": {
+        if (subcommand === "sync") {
+          const prdId = rest[0];
+          if (!prdId)
+            throw new Error("Usage: codespring prd sync <id> --file <path>");
+          const { prdSync: prdSync2 } = await Promise.resolve().then(() => (init_prds(), exports_prds));
+          return prdSync2(prdId, flags);
+        }
+        if (!subcommand)
+          throw new Error("Usage: codespring prd <id>");
+        const { prdGet: prdGet2 } = await Promise.resolve().then(() => (init_prds(), exports_prds));
+        return prdGet2(subcommand, flags);
+      }
+      case "mindmap": {
+        switch (subcommand) {
+          case "tech-stack": {
+            const { mindmapTechStack: mindmapTechStack2 } = await Promise.resolve().then(() => (init_mindmap(), exports_mindmap));
+            return mindmapTechStack2(flags);
+          }
+          case "features": {
+            const { mindmapFeatures: mindmapFeatures2 } = await Promise.resolve().then(() => (init_mindmap(), exports_mindmap));
+            return mindmapFeatures2(flags);
+          }
+          case "note": {
+            const featureId = rest[0];
+            if (!featureId)
+              throw new Error("Usage: codespring mindmap note <featureId> --text '<text>'");
+            const { mindmapNote: mindmapNote2 } = await Promise.resolve().then(() => (init_mindmap(), exports_mindmap));
+            return mindmapNote2(featureId, flags);
+          }
+          default: {
+            const { mindmapGet: mindmapGet2 } = await Promise.resolve().then(() => (init_mindmap(), exports_mindmap));
+            return mindmapGet2(flags);
+          }
+        }
+      }
+      case "schema": {
+        const { schema: schema2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+        return schema2(flags);
+      }
+      case "node-types": {
+        const { nodeTypes: nodeTypes2 } = await Promise.resolve().then(() => (init_node_types(), exports_node_types));
+        return nodeTypes2(flags);
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(JSON.stringify({ error: message }));
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@codespring-app/cli",
+	"version": "0.1.0",
+	"description": "CodeSpring CLI — project planning and management from the terminal",
+	"type": "module",
+	"bin": {
+		"codespring": "./dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"dev": "bun src/index.ts",
+		"build": "bun build src/index.ts --outdir=dist --target=bun",
+		"compile": "bun build src/index.ts --compile --outfile=dist/codespring"
+	},
+	"dependencies": {
+		"zod": "^3.23.8"
+	},
+	"devDependencies": {
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	}
+}