contextloop-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2253 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/api-client.ts
+import { ofetch, FetchError } from "ofetch";
+
+// src/lib/errors.ts
+var CLIError = class extends Error {
+  code;
+  hint;
+  constructor(code, message, hint) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+    this.hint = hint;
+  }
+  /**
+   * Get exit code for this error
+   */
+  getExitCode() {
+    const exitCodes = {
+      FILE_NOT_FOUND: 4,
+      FILE_READ_ERROR: 10,
+      FILE_WRITE_ERROR: 10,
+      STDIN_ERROR: 10,
+      CONFIG_ERROR: 6,
+      KEYCHAIN_ERROR: 2,
+      NETWORK_ERROR: 1,
+      AUTH_EXPIRED: 2,
+      PROJECT_NOT_SET: 6,
+      TIMEOUT: 12,
+      FILE_TOO_LARGE: 13
+    };
+    return exitCodes[this.code] ?? 1;
+  }
+};
+var APIError = class extends Error {
+  code;
+  details;
+  hint;
+  constructor(code, message, details, hint) {
+    super(message);
+    this.name = "APIError";
+    this.code = code;
+    this.details = details;
+    this.hint = hint;
+  }
+  /**
+   * Get exit code for this error
+   */
+  getExitCode() {
+    const exitCodes = {
+      UNAUTHORIZED: 2,
+      FORBIDDEN: 3,
+      NOT_FOUND: 4,
+      VALIDATION_ERROR: 5,
+      CONFLICT: 5,
+      RATE_LIMITED: 11,
+      INTERNAL_ERROR: 1
+    };
+    return exitCodes[this.code] ?? 1;
+  }
+  /**
+   * Get helpful hint based on error code
+   */
+  static getDefaultHint(code) {
+    const hints = {
+      UNAUTHORIZED: "Run 'contextloop auth login' to authenticate",
+      NOT_FOUND: "Use 'contextloop document list' to see available documents",
+      RATE_LIMITED: "Rate limit exceeded. Try again in a few seconds."
+    };
+    return hints[code];
+  }
+};
+function getExitCode(error) {
+  if (error instanceof CLIError || error instanceof APIError) {
+    return error.getExitCode();
+  }
+  return 1;
+}
+function formatError(error, format = "text") {
+  if (error instanceof CLIError || error instanceof APIError) {
+    if (format === "json") {
+      return JSON.stringify(
+        {
+          error: {
+            code: error.code,
+            message: error.message,
+            hint: error.hint,
+            ...error instanceof APIError && error.details ? { details: error.details } : {}
+          }
+        },
+        null,
+        2
+      );
+    }
+    let output = `Error: ${error.message}`;
+    if (error.code) {
+      output += ` (${error.code})`;
+    }
+    if (error.hint) {
+      output += `
+Hint: ${error.hint}`;
+    }
+    return output;
+  }
+  if (error instanceof Error) {
+    if (format === "json") {
+      return JSON.stringify(
+        {
+          error: {
+            code: "UNKNOWN_ERROR",
+            message: error.message
+          }
+        },
+        null,
+        2
+      );
+    }
+    return `Error: ${error.message}`;
+  }
+  return `Error: ${String(error)}`;
+}
+
+// src/lib/credentials.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto2 from "crypto";
+import * as os from "os";
+var SERVICE_NAME = "contextloop-cli";
+var CREDENTIALS_FILENAME = "credentials.enc";
+var KEY_API_KEY = "api-key";
+var KEY_ACCESS_TOKEN = "access-token";
+var KEY_REFRESH_TOKEN = "refresh-token";
+var ENCRYPTION_ALGORITHM = "aes-256-gcm";
+var KEY_LENGTH = 32;
+var IV_LENGTH = 16;
+var AUTH_TAG_LENGTH = 16;
+function getConfigDir() {
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "contextloop-cli");
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(home, ".config"), "contextloop-cli");
+}
+function getMachineKey() {
+  const machineId = `${os.hostname()}-${os.userInfo().username}-${SERVICE_NAME}`;
+  return crypto2.scryptSync(machineId, "contextloop-cli-salt", KEY_LENGTH);
+}
+function encrypt(data) {
+  const key = getMachineKey();
+  const iv = crypto2.randomBytes(IV_LENGTH);
+  const cipher = crypto2.createCipheriv(ENCRYPTION_ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return Buffer.concat([iv, authTag, encrypted]);
+}
+function decrypt(data) {
+  const key = getMachineKey();
+  const iv = data.subarray(0, IV_LENGTH);
+  const authTag = data.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
+  const encrypted = data.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
+  const decipher = crypto2.createDecipheriv(ENCRYPTION_ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+  return decipher.update(encrypted) + decipher.final("utf8");
+}
+var KeyringBackend = class {
+  name = "keyring";
+  Entry = null;
+  initialized = false;
+  available = false;
+  async init() {
+    if (this.initialized) return this.available;
+    this.initialized = true;
+    try {
+      const keyring = await import("@napi-rs/keyring");
+      this.Entry = keyring.Entry;
+      const testEntry = new this.Entry(SERVICE_NAME, "__test__");
+      try {
+        testEntry.getPassword();
+      } catch {
+      }
+      this.available = true;
+    } catch {
+      this.available = false;
+    }
+    return this.available;
+  }
+  async get(key) {
+    if (!await this.init() || !this.Entry) return null;
+    try {
+      const entry = new this.Entry(SERVICE_NAME, key);
+      return entry.getPassword();
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value) {
+    if (!await this.init() || !this.Entry) {
+      throw new Error("Keyring not available");
+    }
+    const entry = new this.Entry(SERVICE_NAME, key);
+    entry.setPassword(value);
+  }
+  async delete(key) {
+    if (!await this.init() || !this.Entry) return;
+    try {
+      const entry = new this.Entry(SERVICE_NAME, key);
+      entry.deletePassword();
+    } catch {
+    }
+  }
+  async isAvailable() {
+    return this.init();
+  }
+};
+var EncryptedFileBackend = class {
+  name = "encrypted-file";
+  configDir;
+  filePath;
+  constructor() {
+    this.configDir = getConfigDir();
+    this.filePath = path.join(this.configDir, CREDENTIALS_FILENAME);
+  }
+  readStore() {
+    try {
+      if (!fs.existsSync(this.filePath)) return {};
+      const encrypted = fs.readFileSync(this.filePath);
+      const decrypted = decrypt(encrypted);
+      return JSON.parse(decrypted);
+    } catch {
+      return {};
+    }
+  }
+  writeStore(store) {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true, mode: 448 });
+    }
+    const encrypted = encrypt(JSON.stringify(store));
+    fs.writeFileSync(this.filePath, encrypted, { mode: 384 });
+  }
+  async get(key) {
+    const store = this.readStore();
+    return store[key] ?? null;
+  }
+  async set(key, value) {
+    const store = this.readStore();
+    store[key] = value;
+    this.writeStore(store);
+  }
+  async delete(key) {
+    const store = this.readStore();
+    delete store[key];
+    if (Object.keys(store).length === 0) {
+      try {
+        fs.unlinkSync(this.filePath);
+      } catch {
+      }
+    } else {
+      this.writeStore(store);
+    }
+  }
+};
+var keyringBackend = null;
+var fileBackend = null;
+var activeBackend = null;
+var backendInitialized = false;
+async function getBackend() {
+  if (backendInitialized && activeBackend) {
+    return activeBackend;
+  }
+  keyringBackend = new KeyringBackend();
+  fileBackend = new EncryptedFileBackend();
+  if (await keyringBackend.isAvailable()) {
+    activeBackend = keyringBackend;
+  } else {
+    activeBackend = fileBackend;
+  }
+  backendInitialized = true;
+  return activeBackend;
+}
+async function storeApiKey(apiKey) {
+  try {
+    const backend = await getBackend();
+    await backend.set(KEY_API_KEY, apiKey);
+  } catch (error) {
+    throw new CLIError(
+      "KEYCHAIN_ERROR",
+      `Failed to store API key: ${error instanceof Error ? error.message : "Unknown error"}. You can use the CONTEXTLOOP_API_KEY environment variable instead.`
+    );
+  }
+}
+async function getApiKey() {
+  if (process.env.CONTEXTLOOP_API_KEY) {
+    return process.env.CONTEXTLOOP_API_KEY;
+  }
+  try {
+    const backend = await getBackend();
+    return await backend.get(KEY_API_KEY);
+  } catch {
+    return null;
+  }
+}
+async function storeTokens(accessToken, refreshToken) {
+  try {
+    const backend = await getBackend();
+    await backend.set(KEY_ACCESS_TOKEN, accessToken);
+    if (refreshToken) {
+      await backend.set(KEY_REFRESH_TOKEN, refreshToken);
+    }
+  } catch (error) {
+    throw new CLIError(
+      "KEYCHAIN_ERROR",
+      `Failed to store tokens: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+async function getTokens() {
+  try {
+    const backend = await getBackend();
+    const accessToken = await backend.get(KEY_ACCESS_TOKEN);
+    const refreshToken = await backend.get(KEY_REFRESH_TOKEN);
+    return { accessToken, refreshToken };
+  } catch {
+    return { accessToken: null, refreshToken: null };
+  }
+}
+async function getCredentials() {
+  const apiKey = await getApiKey();
+  const { accessToken, refreshToken } = await getTokens();
+  return {
+    apiKey: apiKey ?? void 0,
+    accessToken: accessToken ?? void 0,
+    refreshToken: refreshToken ?? void 0
+  };
+}
+async function clearCredentials() {
+  try {
+    const backend = await getBackend();
+    await backend.delete(KEY_API_KEY);
+    await backend.delete(KEY_ACCESS_TOKEN);
+    await backend.delete(KEY_REFRESH_TOKEN);
+  } catch {
+  }
+}
+
+// src/lib/api-client.ts
+var RATE_LIMIT_CONFIG = {
+  initialDelayMs: 1e3,
+  maxDelayMs: 6e4,
+  maxRetries: 5,
+  backoffMultiplier: 2,
+  jitterPercent: 0.1
+};
+function createAPIClient(config2, logger) {
+  const baseURL = config2.apiUrl.replace(/\/$/, "");
+  async function getAuthHeader() {
+    const apiKey = await getApiKey();
+    if (apiKey) {
+      return `Bearer ${apiKey}`;
+    }
+    const { accessToken } = await getTokens();
+    if (accessToken) {
+      return `Bearer ${accessToken}`;
+    }
+    return null;
+  }
+  function calculateRetryDelay(attempt, retryAfter) {
+    if (retryAfter) {
+      return retryAfter * 1e3;
+    }
+    const delay = Math.min(
+      RATE_LIMIT_CONFIG.initialDelayMs * Math.pow(RATE_LIMIT_CONFIG.backoffMultiplier, attempt),
+      RATE_LIMIT_CONFIG.maxDelayMs
+    );
+    const jitter = delay * RATE_LIMIT_CONFIG.jitterPercent * (Math.random() * 2 - 1);
+    return Math.floor(delay + jitter);
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function request(method, path4, options = {}) {
+    const authHeader = await getAuthHeader();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (authHeader) {
+      headers["Authorization"] = authHeader;
+    }
+    const query = options.query ? Object.fromEntries(
+      Object.entries(options.query).filter(([, v]) => v !== void 0)
+    ) : void 0;
+    let lastError = null;
+    for (let attempt = 0; attempt <= RATE_LIMIT_CONFIG.maxRetries; attempt++) {
+      try {
+        logger.debug(`${method} ${path4}`, { query, attempt });
+        const response = await ofetch(`${baseURL}${path4}`, {
+          method,
+          headers,
+          body: options.body,
+          query,
+          timeout: 3e4
+        });
+        return response;
+      } catch (error) {
+        if (error instanceof FetchError) {
+          const status = error.response?.status;
+          const data = error.data;
+          if (status === 429) {
+            if (attempt < RATE_LIMIT_CONFIG.maxRetries) {
+              const retryAfter = error.response?.headers.get("Retry-After");
+              const delay = calculateRetryDelay(
+                attempt,
+                retryAfter ? parseInt(retryAfter, 10) : void 0
+              );
+              logger.warn(
+                `Rate limited. Retrying in ${Math.round(delay / 1e3)}s... (attempt ${attempt + 1}/${RATE_LIMIT_CONFIG.maxRetries})`
+              );
+              await sleep(delay);
+              continue;
+            }
+            throw new APIError(
+              "RATE_LIMITED",
+              "Rate limit exceeded. Please try again later.",
+              void 0,
+              `Try again in ${RATE_LIMIT_CONFIG.maxDelayMs / 1e3} seconds.`
+            );
+          }
+          const errorCode = mapStatusToErrorCode(status);
+          const message = data?.error?.message || error.message || "Request failed";
+          const hint = APIError.getDefaultHint(errorCode);
+          throw new APIError(errorCode, message, data?.error?.details, hint);
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    throw lastError || new Error("Request failed after retries");
+  }
+  function mapStatusToErrorCode(status) {
+    switch (status) {
+      case 401:
+        return "UNAUTHORIZED";
+      case 403:
+        return "FORBIDDEN";
+      case 404:
+        return "NOT_FOUND";
+      case 400:
+      case 422:
+        return "VALIDATION_ERROR";
+      case 409:
+        return "CONFLICT";
+      case 429:
+        return "RATE_LIMITED";
+      default:
+        return "INTERNAL_ERROR";
+    }
+  }
+  return {
+    // Auth methods
+    async validateApiKey(apiKey) {
+      const response = await ofetch(`${baseURL}/cli/auth/me`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      return response;
+    },
+    async getCurrentUser() {
+      return request("GET", "/cli/auth/me");
+    },
+    async exchangeToken(apiKey) {
+      return request("POST", "/cli/auth/token", {
+        body: { apiKey }
+      });
+    },
+    // Project methods
+    async listProjects(params) {
+      return request("GET", "/cli/projects", {
+        query: {
+          page: params?.page,
+          pageSize: params?.pageSize
+        }
+      });
+    },
+    async getProject(projectId) {
+      return request("GET", `/cli/projects/${projectId}`);
+    },
+    // Document methods
+    async listDocuments(projectId, params) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/documents`,
+        {
+          query: {
+            page: params?.page,
+            pageSize: params?.pageSize,
+            tree: params?.tree,
+            path: params?.path
+          }
+        }
+      );
+    },
+    async getDocument(projectId, documentId) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/documents/${documentId}`
+      );
+    },
+    async getDocumentByPath(projectId, path4) {
+      return request("GET", `/cli/projects/${projectId}/documents`, {
+        query: { path: path4 }
+      });
+    },
+    async createDocument(projectId, data) {
+      return request("POST", `/cli/projects/${projectId}/documents`, {
+        body: data
+      });
+    },
+    async updateDocument(projectId, documentId, data) {
+      return request(
+        "PUT",
+        `/cli/projects/${projectId}/documents/${documentId}`,
+        { body: data }
+      );
+    },
+    async deleteDocument(projectId, documentId) {
+      await request(
+        "DELETE",
+        `/cli/projects/${projectId}/documents/${documentId}`
+      );
+    },
+    async listDocumentVersions(projectId, documentId) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/documents/${documentId}/versions`
+      );
+    },
+    // Context methods
+    async listContext(projectId, params) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/context`,
+        {
+          query: {
+            page: params?.page,
+            pageSize: params?.pageSize
+          }
+        }
+      );
+    },
+    async getContext(projectId, contextId) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/context/${contextId}`
+      );
+    },
+    async createContext(projectId, data) {
+      return request("POST", `/cli/projects/${projectId}/context`, {
+        body: data
+      });
+    },
+    async deleteContext(projectId, contextId) {
+      await request(
+        "DELETE",
+        `/cli/projects/${projectId}/context/${contextId}`
+      );
+    },
+    // Comment methods
+    async listComments(projectId, documentId, params) {
+      return request(
+        "GET",
+        `/cli/projects/${projectId}/documents/${documentId}/comments`,
+        {
+          query: {
+            page: params?.page,
+            pageSize: params?.pageSize
+          }
+        }
+      );
+    },
+    async createComment(projectId, documentId, data) {
+      return request(
+        "POST",
+        `/cli/projects/${projectId}/documents/${documentId}/comments`,
+        { body: data }
+      );
+    },
+    async resolveComment(projectId, commentId) {
+      return request(
+        "PATCH",
+        `/cli/projects/${projectId}/comments/${commentId}/resolve`
+      );
+    }
+  };
+}
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_API_URL = "https://contextloop.io/api";
+var LOCALHOST_URL = "http://localhost:3000/api";
+var schema = {
+  apiUrl: {
+    type: "string",
+    default: DEFAULT_API_URL
+  },
+  defaultProjectId: {
+    type: "string"
+  },
+  defaultProjectSlug: {
+    type: "string"
+  },
+  tokenExpiry: {
+    type: "number"
+  }
+};
+var conf = new Conf({
+  projectName: "contextloop-cli",
+  schema,
+  defaults: {
+    apiUrl: DEFAULT_API_URL
+  }
+});
+function resolveApiUrl(envUrl) {
+  const url = envUrl || conf.get("apiUrl") || DEFAULT_API_URL;
+  if (url === "local" || url === "localhost") {
+    return LOCALHOST_URL;
+  }
+  return url;
+}
+function loadConfig() {
+  const config2 = {
+    apiUrl: resolveApiUrl(process.env.CONTEXTLOOP_API_URL),
+    defaultProjectId: process.env.CONTEXTLOOP_PROJECT_ID || conf.get("defaultProjectId"),
+    defaultProjectSlug: conf.get("defaultProjectSlug"),
+    tokenExpiry: conf.get("tokenExpiry")
+  };
+  return config2;
+}
+function saveConfig(updates) {
+  if (updates.apiUrl !== void 0) {
+    const url = updates.apiUrl === "local" || updates.apiUrl === "localhost" ? LOCALHOST_URL : updates.apiUrl;
+    conf.set("apiUrl", url);
+  }
+  if (updates.defaultProjectId !== void 0) {
+    conf.set("defaultProjectId", updates.defaultProjectId);
+  }
+  if (updates.defaultProjectSlug !== void 0) {
+    conf.set("defaultProjectSlug", updates.defaultProjectSlug);
+  }
+  if (updates.tokenExpiry !== void 0) {
+    conf.set("tokenExpiry", updates.tokenExpiry);
+  }
+}
+function clearConfig(keys) {
+  for (const key of keys) {
+    conf.delete(key);
+  }
+}
+
+// src/lib/logger.ts
+import chalk from "chalk";
+function createLogger(options) {
+  const isQuiet = options.quiet ?? false;
+  const isVerbose = options.verbose ?? false;
+  const useColor = options.color !== false;
+  const colorize = (fn, str) => {
+    return useColor ? fn(str) : str;
+  };
+  return {
+    info(message, ...args) {
+      if (!isQuiet) {
+        console.log(message, ...args);
+      }
+    },
+    warn(message, ...args) {
+      if (!isQuiet) {
+        console.warn(colorize(chalk.yellow, `Warning: ${message}`), ...args);
+      }
+    },
+    error(message, ...args) {
+      console.error(colorize(chalk.red, `Error: ${message}`), ...args);
+    },
+    debug(message, ...args) {
+      if (isVerbose) {
+        console.debug(colorize(chalk.gray, `[debug] ${message}`), ...args);
+      }
+    }
+  };
+}
+
+// src/commands/auth.ts
+import chalk4 from "chalk";
+import ora from "ora";
+
+// src/lib/auth.ts
+import http from "http";
+import { URL } from "url";
+import open from "open";
+import chalk2 from "chalk";
+var CALLBACK_PORT = 54320;
+var CALLBACK_PATH = "/callback";
+var AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+var OAUTH_CLIENT_ID = "contextloop-cli";
+function startCallbackServer(expectedState, logger) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname !== CALLBACK_PATH) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+              <h1 style="color: #ef4444;">Authentication Failed</h1>
+              <p>${errorDescription || error}</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        server.close();
+        reject(
+          new CLIError(
+            "AUTH_EXPIRED",
+            errorDescription || error || "Authentication failed"
+          )
+        );
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+              <h1 style="color: #ef4444;">Missing Authorization Code</h1>
+              <p>The callback did not include an authorization code.</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        server.close();
+        reject(new CLIError("AUTH_EXPIRED", "Missing authorization code"));
+        return;
+      }
+      if (state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+              <h1 style="color: #ef4444;">Invalid State</h1>
+              <p>The state parameter did not match. This may be a security issue.</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+        server.close();
+        reject(new CLIError("AUTH_EXPIRED", "Invalid state parameter"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`
+        <html>
+          <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+            <h1 style="color: #22c55e;">Authentication Successful!</h1>
+            <p>You can close this window and return to the CLI.</p>
+          </body>
+        </html>
+      `);
+      server.close();
+      resolve({ code, state: state || void 0 });
+    });
+    server.on("error", (err) => {
+      logger.debug(`Callback server error: ${err.message}`);
+      reject(
+        new CLIError(
+          "NETWORK_ERROR",
+          `Failed to start callback server: ${err.message}`
+        )
+      );
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(
+        new CLIError(
+          "TIMEOUT",
+          "Authentication timed out. Please try again.",
+          "Run 'contextloop auth login' to try again"
+        )
+      );
+    }, AUTH_TIMEOUT_MS);
+    server.on("close", () => {
+      clearTimeout(timeout);
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+      logger.debug(`Callback server listening on port ${CALLBACK_PORT}`);
+    });
+  });
+}
+function generateState() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function generatePKCE() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  const verifier = Array.from(array, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  const challenge = btoa(String.fromCharCode(...hashArray)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return { verifier, challenge };
+}
+async function interactiveLogin(config2, logger) {
+  const state = generateState();
+  const { verifier, challenge } = await generatePKCE();
+  const redirectUri = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  const baseUrl = config2.apiUrl.replace(/\/api$/, "");
+  const authUrl = new URL(`${config2.apiUrl}/oauth/authorize`);
+  authUrl.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("resource", `${baseUrl}/mcp/http`);
+  console.log(chalk2.cyan("Opening browser for authentication..."));
+  console.log(
+    chalk2.gray(`If the browser doesn't open, visit: ${authUrl.toString()}`)
+  );
+  console.log();
+  const serverPromise = startCallbackServer(state, logger);
+  try {
+    await open(authUrl.toString());
+  } catch (err) {
+    logger.debug(`Failed to open browser: ${err}`);
+    console.log(chalk2.yellow("Could not open browser automatically."));
+    console.log(`Please visit this URL manually:
+${authUrl.toString()}`);
+  }
+  console.log(chalk2.gray("Waiting for authentication..."));
+  const { code } = await serverPromise;
+  console.log(chalk2.gray("Exchanging authorization code for tokens..."));
+  const tokenUrl = `${config2.apiUrl}/oauth/token`;
+  const formData = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: OAUTH_CLIENT_ID,
+    code_verifier: verifier
+  });
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: formData.toString()
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new CLIError(
+      "AUTH_EXPIRED",
+      error.error_description || error.error || "Failed to exchange authorization code",
+      "Run 'contextloop auth login' to try again"
+    );
+  }
+  const tokens = await response.json();
+  await storeTokens(tokens.access_token, tokens.refresh_token);
+  if (tokens.project_id) {
+    saveConfig({ defaultProjectId: tokens.project_id });
+    console.log(chalk2.green("Successfully authenticated!"));
+    console.log(chalk2.gray(`Default project set to: ${tokens.project_id}`));
+  } else {
+    console.log(chalk2.green("Successfully authenticated!"));
+  }
+}
+async function manualLogin(config2, logger) {
+  const state = generateState();
+  const { verifier, challenge } = await generatePKCE();
+  const redirectUri = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  const baseUrl = config2.apiUrl.replace(/\/api$/, "");
+  const authUrl = new URL(`${config2.apiUrl}/oauth/authorize`);
+  authUrl.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("resource", `${baseUrl}/mcp/http`);
+  console.log(chalk2.cyan("Manual authentication mode"));
+  console.log();
+  console.log("1. Visit this URL in a browser:");
+  console.log(chalk2.underline(authUrl.toString()));
+  console.log();
+  console.log(
+    `2. After authenticating, paste the full callback URL (starting with http://localhost:${CALLBACK_PORT}/callback?code=...)`
+  );
+  console.log();
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const callbackUrl = await new Promise((resolve) => {
+    rl.question("Callback URL: ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+  let url;
+  try {
+    url = new URL(callbackUrl);
+  } catch {
+    throw new CLIError("AUTH_EXPIRED", "Invalid callback URL");
+  }
+  const code = url.searchParams.get("code");
+  const returnedState = url.searchParams.get("state");
+  if (!code) {
+    throw new CLIError("AUTH_EXPIRED", "Missing authorization code in callback URL");
+  }
+  if (returnedState !== state) {
+    throw new CLIError(
+      "AUTH_EXPIRED",
+      "State mismatch. Please try again with a fresh login."
+    );
+  }
+  console.log(chalk2.gray("Exchanging authorization code for tokens..."));
+  const tokenUrl = `${config2.apiUrl}/oauth/token`;
+  const formData = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: OAUTH_CLIENT_ID,
+    code_verifier: verifier
+  });
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: formData.toString()
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new CLIError(
+      "AUTH_EXPIRED",
+      error.error_description || error.error || "Failed to exchange authorization code"
+    );
+  }
+  const tokens = await response.json();
+  await storeTokens(tokens.access_token, tokens.refresh_token);
+  if (tokens.project_id) {
+    saveConfig({ defaultProjectId: tokens.project_id });
+    console.log(chalk2.green("Successfully authenticated!"));
+    console.log(chalk2.gray(`Default project set to: ${tokens.project_id}`));
+  } else {
+    console.log(chalk2.green("Successfully authenticated!"));
+  }
+}
+
+// src/lib/format.ts
+import chalk3 from "chalk";
+function formatOutput(data, options, globalOptions) {
+  if (globalOptions.quiet) {
+    return "";
+  }
+  const format = globalOptions.format || "text";
+  if (format === "json") {
+    const jsonData = options.json ? options.json(data) : data;
+    return JSON.stringify(jsonData, null, 2);
+  }
+  return options.text(data);
+}
+function printOutput(data, options, globalOptions) {
+  const output = formatOutput(data, options, globalOptions);
+  if (output) {
+    console.log(output);
+  }
+}
+function formatTable(headers, rows, options = {}) {
+  const useColor = options.useColor !== false;
+  const widths = headers.map(
+    (h, i) => Math.max(
+      h.length,
+      ...rows.map((row) => (row[i] || "").length)
+    )
+  );
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const dataRows = rows.map(
+    (row) => row.map((cell, i) => (cell || "").padEnd(widths[i])).join("  ")
+  ).join("\n");
+  const colorizedHeader = useColor ? chalk3.bold(headerRow) : headerRow;
+  const colorizedSeparator = useColor ? chalk3.gray(separator) : separator;
+  return `${colorizedHeader}
+${colorizedSeparator}
+${dataRows}`;
+}
+function formatTree(items, indent = "") {
+  const lines = [];
+  items.forEach((item, index) => {
+    const isLast = index === items.length - 1;
+    const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childIndent = indent + (isLast ? "    " : "\u2502   ");
+    const name = item.isFolder ? `${item.name}/` : item.name;
+    lines.push(`${indent}${prefix}${name}`);
+    if (item.children && item.children.length > 0) {
+      lines.push(
+        formatTree(
+          item.children,
+          childIndent
+        )
+      );
+    }
+  });
+  return lines.join("\n");
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+function formatRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const d = typeof date === "string" ? new Date(date) : date;
+  const diffMs = now.getTime() - d.getTime();
+  const diffSec = Math.floor(diffMs / 1e3);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  if (diffSec < 60) {
+    return "just now";
+  } else if (diffMin < 60) {
+    return `${diffMin}m ago`;
+  } else if (diffHour < 24) {
+    return `${diffHour}h ago`;
+  } else if (diffDay < 30) {
+    return `${diffDay}d ago`;
+  } else {
+    return d.toLocaleDateString();
+  }
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2, context2) {
+  const auth = program2.command("auth").description("Authentication commands");
+  auth.command("login").description("Authenticate with ContextLoop").option("--api-key <key>", "Login with an API key").option("--manual", "Use manual login flow (for environments without browser)").action(async (options) => {
+    const globalOptions = program2.opts();
+    try {
+      if (options.apiKey) {
+        const spinner = ora("Validating API key...").start();
+        try {
+          const { user } = await context2.apiClient.validateApiKey(options.apiKey);
+          await storeApiKey(options.apiKey);
+          spinner.succeed(`Logged in as ${chalk4.bold(user.name)} (${user.email})`);
+        } catch (error) {
+          spinner.fail("Login failed");
+          throw error;
+        }
+      } else if (options.manual) {
+        await manualLogin(context2.config, context2.logger);
+      } else {
+        await interactiveLogin(context2.config, context2.logger);
+      }
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  auth.command("logout").description("Clear stored credentials").action(async () => {
+    const globalOptions = program2.opts();
+    try {
+      await clearCredentials();
+      clearConfig(["defaultProjectId", "defaultProjectSlug"]);
+      console.log(chalk4.green("Logged out successfully."));
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  auth.command("whoami").description("Display current user information").action(async () => {
+    const globalOptions = program2.opts();
+    try {
+      const creds = await getCredentials();
+      if (!creds.apiKey && !creds.accessToken) {
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify({ loggedIn: false }));
+        } else {
+          console.log(chalk4.yellow("Not logged in."));
+          console.log(
+            chalk4.gray("Run 'contextloop auth login' to authenticate.")
+          );
+        }
+        return;
+      }
+      const spinner = ora("Fetching user info...").start();
+      try {
+        const user = await context2.apiClient.getCurrentUser();
+        spinner.stop();
+        const defaultProjectId = context2.config.defaultProjectId;
+        printOutput(
+          user,
+          {
+            text: (u) => {
+              const lines = [
+                chalk4.bold(u.name),
+                chalk4.gray(u.email),
+                chalk4.gray(`ID: ${u.id}`)
+              ];
+              if (defaultProjectId) {
+                lines.push("");
+                lines.push(chalk4.gray(`Default project: ${defaultProjectId}`));
+              }
+              return lines.join("\n");
+            },
+            json: (u) => ({
+              loggedIn: true,
+              user: u,
+              defaultProjectId: defaultProjectId || null
+            })
+          },
+          globalOptions
+        );
+      } catch (error) {
+        spinner.fail("Failed to fetch user info");
+        throw error;
+      }
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  auth.command("refresh").description("Refresh authentication tokens").action(async () => {
+    const globalOptions = program2.opts();
+    try {
+      const creds = await getCredentials();
+      if (!creds.apiKey && !creds.accessToken) {
+        throw new CLIError(
+          "AUTH_EXPIRED",
+          "Not logged in",
+          "Run 'contextloop auth login' to authenticate"
+        );
+      }
+      if (creds.apiKey) {
+        const spinner = ora("Validating credentials...").start();
+        try {
+          await context2.apiClient.getCurrentUser();
+          spinner.succeed("Credentials are valid.");
+        } catch (error) {
+          spinner.fail("Credentials are invalid");
+          throw error;
+        }
+        return;
+      }
+      console.log(chalk4.yellow("Token refresh not yet implemented for OAuth."));
+      console.log(chalk4.gray("Run 'contextloop auth login' to re-authenticate."));
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+}
+
+// src/commands/project.ts
+import chalk5 from "chalk";
+import ora2 from "ora";
+function registerProjectCommands(program2, context2) {
+  const project = program2.command("project").description("Manage projects");
+  project.command("list").description("List accessible projects").option("--page <number>", "Page number", "1").option("--page-size <number>", "Items per page", "20").action(async (options) => {
+    const globalOptions = program2.opts();
+    try {
+      const spinner = ora2("Fetching projects...").start();
+      const response = await context2.apiClient.listProjects({
+        page: parseInt(options.page, 10),
+        pageSize: parseInt(options.pageSize, 10)
+      });
+      spinner.stop();
+      if (response.projects.length === 0) {
+        console.log(chalk5.yellow("No projects found."));
+        return;
+      }
+      printOutput(
+        response,
+        {
+          text: (r) => {
+            const config2 = loadConfig();
+            const rows = r.projects.map((p) => {
+              const isDefault = p.id === config2.defaultProjectId;
+              const name = isDefault ? `${p.name} ${chalk5.cyan("(default)")}` : p.name;
+              return [
+                name,
+                p.slug,
+                p.role,
+                String(p.documentCount),
+                formatRelativeTime(p.updatedAt)
+              ];
+            });
+            const table = formatTable(
+              ["Name", "Slug", "Role", "Documents", "Updated"],
+              rows
+            );
+            const pagination = r.pagination.totalPages > 1 ? chalk5.gray(
+              `
+Page ${r.pagination.page} of ${r.pagination.totalPages} (${r.pagination.totalItems} total)`
+            ) : "";
+            return table + pagination;
+          },
+          json: (r) => r
+        },
+        globalOptions
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  project.command("info").description("Show project details").argument("[project-id]", "Project ID or slug (uses default if not specified)").action(async (projectId) => {
+    const globalOptions = program2.opts();
+    try {
+      const id = projectId || globalOptions.project || context2.config.defaultProjectId;
+      if (!id) {
+        throw new CLIError(
+          "PROJECT_NOT_SET",
+          "No project specified",
+          "Use 'contextloop project use <id>' to set a default project"
+        );
+      }
+      const spinner = ora2("Fetching project info...").start();
+      const projectInfo = await context2.apiClient.getProject(id);
+      spinner.stop();
+      printOutput(
+        projectInfo,
+        {
+          text: (p) => [
+            chalk5.bold(p.name),
+            chalk5.gray(`Slug: ${p.slug}`),
+            chalk5.gray(`ID: ${p.id}`),
+            p.description ? `
+${p.description}` : "",
+            "",
+            chalk5.gray(`Role: ${p.role}`),
+            chalk5.gray(`Created: ${new Date(p.createdAt).toLocaleDateString()}`),
+            chalk5.gray(`Updated: ${formatRelativeTime(p.updatedAt)}`)
+          ].filter(Boolean).join("\n"),
+          json: (p) => p
+        },
+        globalOptions
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  project.command("use").description("Set default project").argument("<project-id>", "Project ID or slug to use as default").action(async (projectId) => {
+    const globalOptions = program2.opts();
+    try {
+      const spinner = ora2("Validating project...").start();
+      const projectInfo = await context2.apiClient.getProject(projectId);
+      saveConfig({
+        defaultProjectId: projectInfo.id,
+        defaultProjectSlug: projectInfo.slug
+      });
+      spinner.succeed(
+        `Default project set to ${chalk5.bold(projectInfo.name)} (${projectInfo.slug})`
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  project.command("current").description("Show current default project").action(async () => {
+    const globalOptions = program2.opts();
+    try {
+      const config2 = loadConfig();
+      if (!config2.defaultProjectId) {
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify({ defaultProject: null }));
+        } else {
+          console.log(chalk5.yellow("No default project set."));
+          console.log(
+            chalk5.gray("Use 'contextloop project use <id>' to set one.")
+          );
+        }
+        return;
+      }
+      const spinner = ora2("Fetching project info...").start();
+      try {
+        const projectInfo = await context2.apiClient.getProject(
+          config2.defaultProjectId
+        );
+        spinner.stop();
+        printOutput(
+          projectInfo,
+          {
+            text: (p) => [
+              `Current project: ${chalk5.bold(p.name)}`,
+              chalk5.gray(`Slug: ${p.slug}`),
+              chalk5.gray(`ID: ${p.id}`)
+            ].join("\n"),
+            json: (p) => ({ defaultProject: p })
+          },
+          globalOptions
+        );
+      } catch {
+        spinner.stop();
+        console.log(chalk5.yellow("Default project no longer accessible."));
+        console.log(chalk5.gray(`ID: ${config2.defaultProjectId}`));
+        console.log(
+          chalk5.gray("Use 'contextloop project use <id>' to set a new default.")
+        );
+      }
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+}
+
+// src/commands/document.ts
+import chalk6 from "chalk";
+import ora3 from "ora";
+import fs2 from "fs";
+import path2 from "path";
+import { glob } from "glob";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+function getProjectId(globalOptions, context2) {
+  const projectId = globalOptions.project || context2.config.defaultProjectId;
+  if (!projectId) {
+    throw new CLIError(
+      "PROJECT_NOT_SET",
+      "No project specified",
+      "Use --project <id> or run 'contextloop project use <id>' to set a default"
+    );
+  }
+  return projectId;
+}
+function isUUID(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    str
+  );
+}
+async function readContent(source) {
+  if (source === "-") {
+    return new Promise((resolve, reject) => {
+      let content = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("readable", () => {
+        let chunk;
+        while ((chunk = process.stdin.read()) !== null) {
+          content += chunk;
+        }
+      });
+      process.stdin.on("end", () => {
+        resolve({ content });
+      });
+      process.stdin.on("error", (err) => {
+        reject(
+          new CLIError("STDIN_ERROR", `Failed to read from stdin: ${err.message}`)
+        );
+      });
+    });
+  }
+  const filePath = path2.resolve(source);
+  if (!fs2.existsSync(filePath)) {
+    throw new CLIError("FILE_NOT_FOUND", `File not found: ${source}`);
+  }
+  const stats = fs2.statSync(filePath);
+  if (stats.size > MAX_FILE_SIZE) {
+    throw new CLIError(
+      "FILE_TOO_LARGE",
+      `File size (${formatBytes(stats.size)}) exceeds maximum allowed (${formatBytes(MAX_FILE_SIZE)})`
+    );
+  }
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    return { content, filename: path2.basename(filePath) };
+  } catch (err) {
+    throw new CLIError(
+      "FILE_READ_ERROR",
+      `Failed to read file: ${err instanceof Error ? err.message : "Unknown error"}`
+    );
+  }
+}
+function writeContent(filePath, content) {
+  try {
+    const dir = path2.dirname(filePath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(filePath, content, "utf8");
+  } catch (err) {
+    throw new CLIError(
+      "FILE_WRITE_ERROR",
+      `Failed to write file: ${err instanceof Error ? err.message : "Unknown error"}`
+    );
+  }
+}
+function buildTree(documents) {
+  const map = /* @__PURE__ */ new Map();
+  for (const doc of documents) {
+    const parentId = doc.parentId;
+    if (!map.has(parentId)) {
+      map.set(parentId, []);
+    }
+    map.get(parentId).push({
+      name: doc.title,
+      isFolder: doc.isFolder,
+      id: doc.id,
+      children: []
+    });
+  }
+  function buildNode(node) {
+    const children = map.get(node.id) || [];
+    return {
+      name: node.name,
+      isFolder: node.isFolder,
+      children: children.map(buildNode)
+    };
+  }
+  const roots = map.get(null) || [];
+  return roots.map(buildNode);
+}
+function registerDocumentCommands(program2, context2) {
+  const document = program2.command("document").alias("doc").description("Manage documents");
+  document.command("list").description("List documents in project").option("--tree", "Show as tree structure").option("--path <path>", "Filter by path prefix").option("--page <number>", "Page number", "1").option("--page-size <number>", "Items per page", "50").action(
+    async (options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId(globalOptions, context2);
+        const spinner = ora3("Fetching documents...").start();
+        const response = await context2.apiClient.listDocuments(projectId, {
+          tree: options.tree,
+          path: options.path,
+          page: parseInt(options.page, 10),
+          pageSize: parseInt(options.pageSize, 10)
+        });
+        spinner.stop();
+        if (response.documents.length === 0) {
+          console.log(chalk6.yellow("No documents found."));
+          return;
+        }
+        printOutput(
+          response,
+          {
+            text: (r) => {
+              if (options.tree) {
+                const tree = buildTree(r.documents);
+                return formatTree(tree);
+              }
+              const rows = r.documents.map((d) => [
+                d.isFolder ? chalk6.blue(d.title + "/") : d.title,
+                d.path,
+                String(d.version),
+                formatRelativeTime(d.updatedAt)
+              ]);
+              const table = formatTable(
+                ["Title", "Path", "Version", "Updated"],
+                rows
+              );
+              const pagination = r.pagination.totalPages > 1 ? chalk6.gray(
+                `
+Page ${r.pagination.page} of ${r.pagination.totalPages} (${r.pagination.totalItems} total)`
+              ) : "";
+              return table + pagination;
+            },
+            json: (r) => r
+          },
+          globalOptions
+        );
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  document.command("upload").description("Upload a document").argument("<file>", "File to upload (use - for stdin)").option("--path <path>", "Remote path for the document").option("--title <title>", "Document title").option("--update", "Update if document exists at path").option("--dry-run", "Preview without uploading").action(
+    async (file, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId(globalOptions, context2);
+        if (file.includes("*")) {
+          await handleBatchUpload(
+            file,
+            projectId,
+            options,
+            globalOptions,
+            context2
+          );
+          return;
+        }
+        const { content, filename } = await readContent(file);
+        let title = options.title;
+        if (!title && options.path) {
+          title = path2.basename(options.path);
+        }
+        if (!title && filename) {
+          title = filename;
+        }
+        if (!title && file === "-") {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Title is required when uploading from stdin",
+            "Use --title or --path to specify the document title"
+          );
+        }
+        if (options.dryRun) {
+          console.log(chalk6.cyan("Dry run - would upload:"));
+          console.log(`  Title: ${title}`);
+          console.log(`  Path: ${options.path || "(auto)"}`);
+          console.log(`  Content length: ${content.length} characters`);
+          return;
+        }
+        const spinner = ora3(`Uploading ${title}...`).start();
+        const doc = await context2.apiClient.createDocument(projectId, {
+          title,
+          content,
+          path: options.path
+        });
+        spinner.succeed(`Uploaded: ${chalk6.bold(doc.title)} (${doc.path})`);
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify(doc, null, 2));
+        }
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  document.command("download").description("Download a document").argument("<document-id>", "Document ID").option("-o, --output <file>", "Output file (stdout if not specified)").option("--path <path>", "Download by path instead of ID").option("--version <number>", "Download specific version").action(
+    async (documentId, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId(globalOptions, context2);
+        let doc;
+        const spinner = ora3("Downloading...").start();
+        if (options.path) {
+          doc = await context2.apiClient.getDocumentByPath(
+            projectId,
+            options.path
+          );
+        } else if (isUUID(documentId)) {
+          doc = await context2.apiClient.getDocument(projectId, documentId);
+        } else {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Invalid document identifier. Provide a UUID or use --path"
+          );
+        }
+        spinner.stop();
+        if (options.output) {
+          writeContent(options.output, doc.content);
+          console.log(chalk6.green(`Saved to ${options.output}`));
+        } else {
+          process.stdout.write(doc.content);
+        }
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  document.command("update").description("Update an existing document").argument("<document-id>", "Document ID").argument("<file>", "File with new content (use - for stdin)").option("--no-version", "Do not create a new version").action(
+    async (documentId, file, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId(globalOptions, context2);
+        if (!isUUID(documentId)) {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Invalid document ID. Must be a UUID."
+          );
+        }
+        const { content } = await readContent(file);
+        const spinner = ora3("Updating document...").start();
+        const doc = await context2.apiClient.updateDocument(
+          projectId,
+          documentId,
+          {
+            content,
+            createVersion: options.version !== false
+          }
+        );
+        spinner.succeed(
+          `Updated ${chalk6.bold(doc.title)} to version ${doc.version}`
+        );
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify(doc, null, 2));
+        }
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  document.command("delete").description("Delete a document").argument("<document-id>", "Document ID").option("-f, --force", "Skip confirmation").action(async (documentId, options) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId(globalOptions, context2);
+      if (!isUUID(documentId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid document ID. Must be a UUID."
+        );
+      }
+      if (!options.force) {
+        const doc = await context2.apiClient.getDocument(projectId, documentId);
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const answer = await new Promise((resolve) => {
+          rl.question(
+            `Delete "${doc.title}"? This cannot be undone. (y/N) `,
+            (answer2) => {
+              rl.close();
+              resolve(answer2.trim().toLowerCase());
+            }
+          );
+        });
+        if (answer !== "y" && answer !== "yes") {
+          console.log(chalk6.gray("Cancelled."));
+          return;
+        }
+      }
+      const spinner = ora3("Deleting document...").start();
+      await context2.apiClient.deleteDocument(projectId, documentId);
+      spinner.succeed("Document deleted.");
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  document.command("info").description("Show document metadata").argument("<document-id>", "Document ID").action(async (documentId) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId(globalOptions, context2);
+      if (!isUUID(documentId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid document ID. Must be a UUID."
+        );
+      }
+      const spinner = ora3("Fetching document info...").start();
+      const doc = await context2.apiClient.getDocument(projectId, documentId);
+      spinner.stop();
+      printOutput(
+        doc,
+        {
+          text: (d) => [
+            chalk6.bold(d.title),
+            chalk6.gray(`ID: ${d.id}`),
+            chalk6.gray(`Path: ${d.path}`),
+            chalk6.gray(`Version: ${d.version}`),
+            chalk6.gray(`Type: ${d.isFolder ? "Folder" : "Document"}`),
+            "",
+            chalk6.gray(
+              `Created: ${new Date(d.createdAt).toLocaleString()}`
+            ),
+            chalk6.gray(`Updated: ${formatRelativeTime(d.updatedAt)}`),
+            chalk6.gray(`Size: ${formatBytes(d.content.length)}`)
+          ].join("\n"),
+          json: (d) => d
+        },
+        globalOptions
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  document.command("versions").description("List document versions").argument("<document-id>", "Document ID").action(async (documentId) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId(globalOptions, context2);
+      if (!isUUID(documentId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid document ID. Must be a UUID."
+        );
+      }
+      const spinner = ora3("Fetching versions...").start();
+      const response = await context2.apiClient.listDocumentVersions(
+        projectId,
+        documentId
+      );
+      spinner.stop();
+      if (response.versions.length === 0) {
+        console.log(chalk6.yellow("No versions found."));
+        return;
+      }
+      printOutput(
+        response,
+        {
+          text: (r) => {
+            const rows = r.versions.map((v) => [
+              String(v.version),
+              v.changeDescription || "-",
+              v.createdBy,
+              formatRelativeTime(v.createdAt)
+            ]);
+            return formatTable(
+              ["Version", "Description", "Author", "Created"],
+              rows
+            );
+          },
+          json: (r) => r
+        },
+        globalOptions
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+}
+async function handleBatchUpload(pattern, projectId, options, globalOptions, context2) {
+  const basePath = options.path || ".";
+  const files = await glob(pattern, {
+    nodir: true,
+    ignore: ["node_modules/**", ".git/**"]
+  });
+  if (files.length === 0) {
+    console.log(chalk6.yellow("No files matched the pattern."));
+    return;
+  }
+  console.log(`Found ${files.length} file(s) to upload.`);
+  if (options.dryRun) {
+    console.log(chalk6.cyan("\nDry run - would upload:"));
+    for (const file of files) {
+      const remotePath = path2.join("/", path2.relative(basePath, file));
+      console.log(`  ${file} -> ${remotePath}`);
+    }
+    return;
+  }
+  let successCount = 0;
+  let errorCount = 0;
+  for (const file of files) {
+    const remotePath = path2.join("/", path2.relative(basePath, file));
+    const title = path2.basename(file);
+    try {
+      const content = fs2.readFileSync(file, "utf8");
+      await context2.apiClient.createDocument(projectId, {
+        title,
+        content,
+        path: remotePath
+      });
+      console.log(chalk6.green(`\u2713 ${file} -> ${remotePath}`));
+      successCount++;
+    } catch (error) {
+      console.log(
+        chalk6.red(
+          `\u2717 ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+      errorCount++;
+    }
+  }
+  console.log();
+  console.log(
+    `Uploaded: ${successCount}, Failed: ${errorCount}, Total: ${files.length}`
+  );
+}
+
+// src/commands/context.ts
+import chalk7 from "chalk";
+import ora4 from "ora";
+import fs3 from "fs";
+import path3 from "path";
+var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+function getProjectId2(globalOptions, context2) {
+  const projectId = globalOptions.project || context2.config.defaultProjectId;
+  if (!projectId) {
+    throw new CLIError(
+      "PROJECT_NOT_SET",
+      "No project specified",
+      "Use --project <id> or run 'contextloop project use <id>' to set a default"
+    );
+  }
+  return projectId;
+}
+function isUUID2(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    str
+  );
+}
+async function readContent2(source) {
+  if (source === "-") {
+    return new Promise((resolve, reject) => {
+      let content = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("readable", () => {
+        let chunk;
+        while ((chunk = process.stdin.read()) !== null) {
+          content += chunk;
+        }
+      });
+      process.stdin.on("end", () => {
+        resolve({ content });
+      });
+      process.stdin.on("error", (err) => {
+        reject(
+          new CLIError("STDIN_ERROR", `Failed to read from stdin: ${err.message}`)
+        );
+      });
+    });
+  }
+  const filePath = path3.resolve(source);
+  if (!fs3.existsSync(filePath)) {
+    throw new CLIError("FILE_NOT_FOUND", `File not found: ${source}`);
+  }
+  const stats = fs3.statSync(filePath);
+  if (stats.size > MAX_FILE_SIZE2) {
+    throw new CLIError(
+      "FILE_TOO_LARGE",
+      `File size (${formatBytes(stats.size)}) exceeds maximum allowed (${formatBytes(MAX_FILE_SIZE2)})`
+    );
+  }
+  try {
+    const content = fs3.readFileSync(filePath, "utf8");
+    return { content, filename: path3.basename(filePath) };
+  } catch (err) {
+    throw new CLIError(
+      "FILE_READ_ERROR",
+      `Failed to read file: ${err instanceof Error ? err.message : "Unknown error"}`
+    );
+  }
+}
+function registerContextCommands(program2, context2) {
+  const ctx = program2.command("context").alias("ctx").description("Manage context items");
+  ctx.command("list").description("List context items").option("--page <number>", "Page number", "1").option("--page-size <number>", "Items per page", "50").action(async (options) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId2(globalOptions, context2);
+      const spinner = ora4("Fetching context items...").start();
+      const response = await context2.apiClient.listContext(projectId, {
+        page: parseInt(options.page, 10),
+        pageSize: parseInt(options.pageSize, 10)
+      });
+      spinner.stop();
+      if (response.items.length === 0) {
+        console.log(chalk7.yellow("No context items found."));
+        return;
+      }
+      printOutput(
+        response,
+        {
+          text: (r) => {
+            const rows = r.items.map((item) => [
+              item.isFolder ? chalk7.blue(item.title + "/") : item.title,
+              item.path,
+              item.isEditable ? "Yes" : "No",
+              formatRelativeTime(item.updatedAt)
+            ]);
+            const table = formatTable(
+              ["Title", "Path", "Editable", "Updated"],
+              rows
+            );
+            const pagination = r.pagination.totalPages > 1 ? chalk7.gray(
+              `
+Page ${r.pagination.page} of ${r.pagination.totalPages} (${r.pagination.totalItems} total)`
+            ) : "";
+            return table + pagination;
+          },
+          json: (r) => r
+        },
+        globalOptions
+      );
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  ctx.command("upload").description("Upload a context item").argument("<file>", "File to upload (use - for stdin)").option("--name <name>", "Context item name").option("--type <type>", "Content type (text, json, etc.)").action(
+    async (file, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId2(globalOptions, context2);
+        const { content, filename } = await readContent2(file);
+        let title = options.name;
+        if (!title && filename) {
+          title = filename;
+        }
+        if (!title && file === "-") {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Name is required when uploading from stdin",
+            "Use --name to specify the context item name"
+          );
+        }
+        const spinner = ora4(`Uploading ${title}...`).start();
+        const item = await context2.apiClient.createContext(projectId, {
+          title,
+          content
+        });
+        spinner.succeed(`Uploaded: ${chalk7.bold(item.title)} (${item.path})`);
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify(item, null, 2));
+        }
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  ctx.command("download").description("Download a context item").argument("<context-id>", "Context item ID").option("-o, --output <file>", "Output file (stdout if not specified)").action(async (contextId, options) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId2(globalOptions, context2);
+      if (!isUUID2(contextId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid context ID. Must be a UUID."
+        );
+      }
+      const spinner = ora4("Downloading...").start();
+      const item = await context2.apiClient.getContext(projectId, contextId);
+      spinner.stop();
+      if (options.output) {
+        const dir = path3.dirname(options.output);
+        if (!fs3.existsSync(dir)) {
+          fs3.mkdirSync(dir, { recursive: true });
+        }
+        fs3.writeFileSync(options.output, item.content, "utf8");
+        console.log(chalk7.green(`Saved to ${options.output}`));
+      } else {
+        process.stdout.write(item.content);
+      }
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  ctx.command("delete").description("Delete a context item").argument("<context-id>", "Context item ID").option("-f, --force", "Skip confirmation").action(async (contextId, options) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId2(globalOptions, context2);
+      if (!isUUID2(contextId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid context ID. Must be a UUID."
+        );
+      }
+      if (!options.force) {
+        const item = await context2.apiClient.getContext(projectId, contextId);
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const answer = await new Promise((resolve) => {
+          rl.question(
+            `Delete "${item.title}"? This cannot be undone. (y/N) `,
+            (answer2) => {
+              rl.close();
+              resolve(answer2.trim().toLowerCase());
+            }
+          );
+        });
+        if (answer !== "y" && answer !== "yes") {
+          console.log(chalk7.gray("Cancelled."));
+          return;
+        }
+      }
+      const spinner = ora4("Deleting context item...").start();
+      await context2.apiClient.deleteContext(projectId, contextId);
+      spinner.succeed("Context item deleted.");
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+}
+
+// src/commands/comment.ts
+import chalk8 from "chalk";
+import ora5 from "ora";
+function getProjectId3(globalOptions, context2) {
+  const projectId = globalOptions.project || context2.config.defaultProjectId;
+  if (!projectId) {
+    throw new CLIError(
+      "PROJECT_NOT_SET",
+      "No project specified",
+      "Use --project <id> or run 'contextloop project use <id>' to set a default"
+    );
+  }
+  return projectId;
+}
+function isUUID3(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    str
+  );
+}
+async function readBody(body) {
+  if (body === "-") {
+    return new Promise((resolve, reject) => {
+      let content = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("readable", () => {
+        let chunk;
+        while ((chunk = process.stdin.read()) !== null) {
+          content += chunk;
+        }
+      });
+      process.stdin.on("end", () => {
+        resolve(content.trim());
+      });
+      process.stdin.on("error", (err) => {
+        reject(
+          new CLIError("STDIN_ERROR", `Failed to read from stdin: ${err.message}`)
+        );
+      });
+    });
+  }
+  return body;
+}
+function lineToOffset(content, lineNumber) {
+  const lines = content.split("\n");
+  let offset = 0;
+  for (let i = 0; i < lineNumber - 1 && i < lines.length; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset;
+}
+function formatComment(comment, indent = "") {
+  const status = comment.resolved ? chalk8.green("[resolved]") : chalk8.yellow("[open]");
+  const lines = [
+    `${indent}${chalk8.bold(comment.author.name)} ${status}`,
+    `${indent}${chalk8.gray(formatRelativeTime(comment.createdAt))}`
+  ];
+  if (comment.selectionText) {
+    lines.push(`${indent}${chalk8.cyan(`"${comment.selectionText}"`)}`);
+  }
+  lines.push(`${indent}${comment.body}`);
+  if (comment.replies.length > 0) {
+    lines.push("");
+    for (const reply of comment.replies) {
+      lines.push(
+        `${indent}  ${chalk8.bold(reply.author.name)} ${chalk8.gray(formatRelativeTime(reply.createdAt))}`
+      );
+      lines.push(`${indent}  ${reply.body}`);
+    }
+  }
+  return lines.join("\n");
+}
+function registerCommentCommands(program2, context2) {
+  const comment = program2.command("comment").description("Manage document comments");
+  comment.command("list").description("List comments on a document").argument("<document-id>", "Document ID").option("--page <number>", "Page number", "1").option("--page-size <number>", "Items per page", "50").action(
+    async (documentId, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId3(globalOptions, context2);
+        if (!isUUID3(documentId)) {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Invalid document ID. Must be a UUID."
+          );
+        }
+        const spinner = ora5("Fetching comments...").start();
+        const response = await context2.apiClient.listComments(
+          projectId,
+          documentId,
+          {
+            page: parseInt(options.page, 10),
+            pageSize: parseInt(options.pageSize, 10)
+          }
+        );
+        spinner.stop();
+        if (response.comments.length === 0) {
+          console.log(chalk8.yellow("No comments found."));
+          return;
+        }
+        printOutput(
+          response,
+          {
+            text: (r) => {
+              const formatted = r.comments.map((c) => formatComment(c)).join("\n\n" + chalk8.gray("\u2500".repeat(40)) + "\n\n");
+              const pagination = r.pagination.totalPages > 1 ? chalk8.gray(
+                `
+Page ${r.pagination.page} of ${r.pagination.totalPages} (${r.pagination.totalItems} total)`
+              ) : "";
+              return formatted + pagination;
+            },
+            json: (r) => r
+          },
+          globalOptions
+        );
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  comment.command("add").description("Add a comment to a document").argument("<document-id>", "Document ID").option("--body <text>", "Comment body (use - for stdin)").option("--line <number>", "Line number to comment on").action(
+    async (documentId, options) => {
+      const globalOptions = program2.opts();
+      try {
+        const projectId = getProjectId3(globalOptions, context2);
+        if (!isUUID3(documentId)) {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Invalid document ID. Must be a UUID."
+          );
+        }
+        if (!options.body) {
+          throw new CLIError(
+            "VALIDATION_ERROR",
+            "Comment body is required",
+            "Use --body <text> to specify the comment"
+          );
+        }
+        const body = await readBody(options.body);
+        if (!body.trim()) {
+          throw new CLIError("VALIDATION_ERROR", "Comment body cannot be empty");
+        }
+        let selectionStart;
+        let selectionEnd;
+        if (options.line) {
+          const lineNum = parseInt(options.line, 10);
+          if (isNaN(lineNum) || lineNum < 1) {
+            throw new CLIError(
+              "VALIDATION_ERROR",
+              "Line number must be a positive integer"
+            );
+          }
+          const doc = await context2.apiClient.getDocument(
+            projectId,
+            documentId
+          );
+          selectionStart = lineToOffset(doc.content, lineNum);
+          selectionEnd = selectionStart;
+        }
+        const spinner = ora5("Adding comment...").start();
+        const createdComment = await context2.apiClient.createComment(
+          projectId,
+          documentId,
+          {
+            body,
+            selectionStart,
+            selectionEnd
+          }
+        );
+        spinner.succeed("Comment added.");
+        if (globalOptions.format === "json") {
+          console.log(JSON.stringify(createdComment, null, 2));
+        }
+      } catch (error) {
+        console.error(formatError(error, globalOptions.format));
+        process.exit(getExitCode(error));
+      }
+    }
+  );
+  comment.command("reply").description("Reply to a comment").argument("<comment-id>", "Comment ID to reply to").option("--body <text>", "Reply body (use - for stdin)").action(async (commentId, options) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId3(globalOptions, context2);
+      if (!isUUID3(commentId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid comment ID. Must be a UUID."
+        );
+      }
+      if (!options.body) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Reply body is required",
+          "Use --body <text> to specify the reply"
+        );
+      }
+      const body = await readBody(options.body);
+      if (!body.trim()) {
+        throw new CLIError("VALIDATION_ERROR", "Reply body cannot be empty");
+      }
+      const spinner = ora5("Adding reply...").start();
+      console.log(chalk8.yellow("Reply functionality requires API support for comment threads."));
+      spinner.stop();
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+  comment.command("resolve").description("Resolve a comment").argument("<comment-id>", "Comment ID").action(async (commentId) => {
+    const globalOptions = program2.opts();
+    try {
+      const projectId = getProjectId3(globalOptions, context2);
+      if (!isUUID3(commentId)) {
+        throw new CLIError(
+          "VALIDATION_ERROR",
+          "Invalid comment ID. Must be a UUID."
+        );
+      }
+      const spinner = ora5("Resolving comment...").start();
+      const result = await context2.apiClient.resolveComment(
+        projectId,
+        commentId
+      );
+      spinner.succeed("Comment resolved.");
+      if (globalOptions.format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      console.error(formatError(error, globalOptions.format));
+      process.exit(getExitCode(error));
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("contextloop").description("CLI for ContextLoop - manage documents and context").version("0.1.0").option("-p, --project <id>", "Project ID or slug").option("-f, --format <format>", "Output format: text, json", "text").option("-q, --quiet", "Suppress non-essential output").option("-v, --verbose", "Enable verbose logging").option("--no-color", "Disable colored output");
+var config = loadConfig();
+var defaultLogger = createLogger({});
+var apiClient = createAPIClient(config, defaultLogger);
+var context = {
+  config,
+  apiClient,
+  logger: defaultLogger
+};
+registerAuthCommands(program, context);
+registerProjectCommands(program, context);
+registerDocumentCommands(program, context);
+registerContextCommands(program, context);
+registerCommentCommands(program, context);
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const format = program.opts().format;
+    console.error(formatError(error, format || "text"));
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(getExitCode(error));
+  }
+}
+main();