codmir 0.1.0 → 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,769 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+
+// src/cli/utils/auth.ts
+var import_http = __toESM(require("http"));
+var import_open = __toESM(require("open"));
+
+// src/cli/utils/config.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".codmir");
+var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+var PROJECT_CONFIG_FILE = ".codmir.json";
+function ensureConfigDir() {
+  if (!import_fs.default.existsSync(CONFIG_DIR)) {
+    import_fs.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readConfig() {
+  ensureConfigDir();
+  if (!import_fs.default.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const data = import_fs.default.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    console.error("Error reading config:", error);
+    return {};
+  }
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  import_fs.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function clearConfig() {
+  if (import_fs.default.existsSync(CONFIG_FILE)) {
+    import_fs.default.unlinkSync(CONFIG_FILE);
+  }
+}
+function readProjectConfig(cwd = process.cwd()) {
+  const configPath = import_path.default.join(cwd, PROJECT_CONFIG_FILE);
+  if (!import_fs.default.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const data = import_fs.default.readFileSync(configPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    console.error("Error reading project config:", error);
+    return null;
+  }
+}
+function writeProjectConfig(config, cwd = process.cwd()) {
+  const configPath = import_path.default.join(cwd, PROJECT_CONFIG_FILE);
+  import_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  const gitignorePath = import_path.default.join(cwd, ".gitignore");
+  if (import_fs.default.existsSync(gitignorePath)) {
+    const gitignore = import_fs.default.readFileSync(gitignorePath, "utf-8");
+    if (!gitignore.includes(PROJECT_CONFIG_FILE)) {
+      import_fs.default.appendFileSync(gitignorePath, `
+# codmir
+${PROJECT_CONFIG_FILE}
+`);
+    }
+  }
+}
+function getToken() {
+  const config = readConfig();
+  return config.token || null;
+}
+function isAuthenticated() {
+  const token = getToken();
+  return !!token;
+}
+
+// src/cli/utils/auth.ts
+async function startOAuthFlow(baseUrl = "https://codmir.com") {
+  return new Promise((resolve, reject) => {
+    const server = import_http.default.createServer(async (req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1>\u274C Authentication Failed</h1>
+                <p>${error}</p>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (!token) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1>\u274C No token received</h1>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error("No token received"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; padding: 40px; text-align: center;">
+              <h1>\u2705 Authentication Successful!</h1>
+              <p>You can now close this window and return to your terminal.</p>
+              <script>setTimeout(() => window.close(), 2000);</script>
+            </body>
+          </html>
+        `);
+        try {
+          const userResponse = await fetch(`${baseUrl}/api/user/profile`, {
+            headers: {
+              "Authorization": `Bearer ${token}`
+            }
+          });
+          if (!userResponse.ok) {
+            throw new Error("Failed to fetch user info");
+          }
+          const user = await userResponse.json();
+          server.close();
+          resolve({
+            token,
+            user: {
+              id: user.id,
+              email: user.email,
+              name: user.name
+            }
+          });
+        } catch (error2) {
+          server.close();
+          reject(error2);
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    const port = 3333;
+    server.listen(port, () => {
+      const authUrl = `${baseUrl}/cli/auth?port=${port}`;
+      console.log("\u{1F510} Opening browser for authentication...");
+      console.log(`   If browser doesn't open, visit: ${authUrl}`);
+      (0, import_open.default)(authUrl).catch(() => {
+        console.log("\n\u26A0\uFE0F  Could not open browser automatically.");
+        console.log(`   Please visit: ${authUrl}`);
+      });
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateWithToken(token, baseUrl = "https://codmir.com") {
+  const response = await fetch(`${baseUrl}/api/user/profile`, {
+    headers: {
+      "Authorization": `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Invalid token");
+  }
+  const user = await response.json();
+  return {
+    token,
+    user: {
+      id: user.id,
+      email: user.email,
+      name: user.name
+    }
+  };
+}
+function saveAuth(authResult) {
+  const config = readConfig();
+  writeConfig({
+    ...config,
+    token: authResult.token,
+    userId: authResult.user.id,
+    email: authResult.user.email,
+    name: authResult.user.name,
+    lastLogin: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/cli/commands/login.ts
+var import_chalk = __toESM(require("chalk"));
+async function loginCommand(options) {
+  if (isAuthenticated()) {
+    const config = readConfig();
+    console.log(import_chalk.default.yellow("\u26A0\uFE0F  Already logged in as:"), import_chalk.default.bold(config.email));
+    console.log(import_chalk.default.dim("   Run"), import_chalk.default.cyan("codmir logout"), import_chalk.default.dim("to log out first"));
+    return;
+  }
+  console.log(import_chalk.default.bold("\u{1F680} codmir login"));
+  console.log(import_chalk.default.dim("   Authenticate to start using codmir CLI\n"));
+  try {
+    let authResult;
+    if (options.token) {
+      console.log(import_chalk.default.dim("   Authenticating with provided token..."));
+      authResult = await authenticateWithToken(options.token);
+    } else {
+      authResult = await startOAuthFlow();
+    }
+    saveAuth(authResult);
+    console.log(import_chalk.default.green("\n\u2705 Successfully logged in!"));
+    console.log(import_chalk.default.dim("   User:"), import_chalk.default.bold(authResult.user.name));
+    console.log(import_chalk.default.dim("   Email:"), import_chalk.default.bold(authResult.user.email));
+    console.log(import_chalk.default.dim("\n   You can now use"), import_chalk.default.cyan("codmir link"), import_chalk.default.dim("to connect your project"));
+  } catch (error) {
+    console.error(import_chalk.default.red("\n\u274C Login failed:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+
+// src/client.ts
+var CodmirClient = class {
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey || "",
+      baseUrl: config.baseUrl || "https://codmir.com",
+      timeout: config.timeout || 3e4,
+      headers: config.headers || {}
+    };
+    this.tickets = new TicketsAPI(this.config);
+    this.testCases = new TestCasesAPI(this.config);
+  }
+  /**
+   * Make an HTTP request to the codmir API
+   */
+  async request(method, path3, body) {
+    const url = `${this.config.baseUrl}${path3}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw this.createError(
+          errorData.error || `HTTP ${response.status}: ${response.statusText}`,
+          response.status,
+          errorData
+        );
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw this.createError("Request timeout", 408);
+      }
+      if (error instanceof Error && "statusCode" in error) {
+        throw error;
+      }
+      throw this.createError(
+        error.message || "Network error occurred",
+        void 0,
+        error
+      );
+    }
+  }
+  createError(message, statusCode, response) {
+    const error = new Error(message);
+    error.name = "CodmirError";
+    error.statusCode = statusCode;
+    error.response = response;
+    return error;
+  }
+};
+var TicketsAPI = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(method, path3, body) {
+    const url = `${this.config.baseUrl}${path3}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = new Error(errorData.error || `HTTP ${response.status}`);
+        error.statusCode = response.status;
+        error.response = errorData;
+        throw error;
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        const timeoutError = new Error("Request timeout");
+        timeoutError.statusCode = 408;
+        throw timeoutError;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create a ticket in a board
+   * 
+   * @param projectId - The project ID
+   * @param boardId - The board ID
+   * @param data - Ticket data
+   */
+  async createInBoard(projectId, boardId, data) {
+    const response = await this.request(
+      "POST",
+      `/api/project/${projectId}/board/${boardId}/ticket`,
+      data
+    );
+    return response.ticket;
+  }
+  /**
+   * Create a ticket in a workspace
+   * 
+   * @param projectId - The project ID
+   * @param workspaceId - The workspace ID
+   * @param data - Ticket data
+   */
+  async createInWorkspace(projectId, workspaceId, data) {
+    return this.request(
+      "POST",
+      `/api/project/${projectId}/workspaces/${workspaceId}/tickets`,
+      data
+    );
+  }
+  /**
+   * Alias for createInBoard - creates a ticket in a board
+   */
+  async create(projectId, boardId, data) {
+    return this.createInBoard(projectId, boardId, data);
+  }
+};
+var TestCasesAPI = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(method, path3, body) {
+    const url = `${this.config.baseUrl}${path3}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = new Error(errorData.error || `HTTP ${response.status}`);
+        error.statusCode = response.status;
+        error.response = errorData;
+        throw error;
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        const timeoutError = new Error("Request timeout");
+        timeoutError.statusCode = 408;
+        throw timeoutError;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all test cases for a project
+   * 
+   * @param projectId - The project ID
+   */
+  async list(projectId) {
+    const response = await this.request(
+      "GET",
+      `/api/project/${projectId}/test-cases`
+    );
+    return response.data || [];
+  }
+  /**
+   * Get a specific test case by ID
+   * 
+   * @param projectId - The project ID
+   * @param testCaseId - The test case ID (numeric UD)
+   */
+  async get(projectId, testCaseId) {
+    const response = await this.request(
+      "GET",
+      `/api/project/${projectId}/test-cases/${testCaseId}`
+    );
+    if (!response.data) {
+      throw new Error("Test case not found");
+    }
+    return response.data;
+  }
+  /**
+   * Create a new test case
+   * 
+   * @param projectId - The project ID
+   * @param data - Test case data
+   */
+  async create(projectId, data) {
+    const response = await this.request(
+      "POST",
+      `/api/project/${projectId}/test-cases`,
+      data
+    );
+    if (!response.data) {
+      throw new Error("Failed to create test case");
+    }
+    return response.data;
+  }
+  /**
+   * Update an existing test case
+   * 
+   * @param projectId - The project ID
+   * @param testCaseId - The test case ID (numeric UD)
+   * @param data - Test case update data
+   */
+  async update(projectId, testCaseId, data) {
+    const response = await this.request(
+      "PATCH",
+      `/api/project/${projectId}/test-cases/${testCaseId}`,
+      data
+    );
+    if (!response.data) {
+      throw new Error("Failed to update test case");
+    }
+    return response.data;
+  }
+  /**
+   * Delete a test case
+   * 
+   * @param projectId - The project ID
+   * @param testCaseId - The test case ID (numeric UD)
+   */
+  async delete(projectId, testCaseId) {
+    await this.request(
+      "DELETE",
+      `/api/project/${projectId}/test-cases/${testCaseId}`
+    );
+  }
+};
+
+// src/cli/commands/link.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+async function linkCommand(options) {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk2.default.red("\u274C Not authenticated"));
+    console.log(import_chalk2.default.dim("   Run"), import_chalk2.default.cyan("codmir login"), import_chalk2.default.dim("first"));
+    process.exit(1);
+  }
+  console.log(import_chalk2.default.bold("\n\u{1F517} codmir link"));
+  console.log(import_chalk2.default.dim("   Link this directory to a codmir project\n"));
+  const existing = readProjectConfig();
+  if (existing) {
+    console.log(import_chalk2.default.yellow("\u26A0\uFE0F  This directory is already linked to:"));
+    console.log(import_chalk2.default.dim("   Project ID:"), import_chalk2.default.bold(existing.projectId));
+    if (existing.projectName) {
+      console.log(import_chalk2.default.dim("   Project:"), import_chalk2.default.bold(existing.projectName));
+    }
+    const { overwrite } = await (0, import_prompts.default)({
+      type: "confirm",
+      name: "overwrite",
+      message: "Do you want to overwrite this configuration?",
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(import_chalk2.default.dim("   Cancelled"));
+      return;
+    }
+  }
+  try {
+    const client = new CodmirClient({
+      apiKey: token,
+      baseUrl: process.env.CODMIR_API_URL || "https://codmir.com"
+    });
+    let projectId = options.project;
+    let orgId = options.org;
+    console.log(import_chalk2.default.dim("   Fetching your projects...\n"));
+    const response = await fetch(`${process.env.CODMIR_API_URL || "https://codmir.com"}/api/projects`, {
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch projects");
+    }
+    const projects = await response.json();
+    if (!projectId) {
+      if (projects.length === 0) {
+        console.log(import_chalk2.default.yellow("\u26A0\uFE0F  You don't have any projects yet"));
+        console.log(import_chalk2.default.dim("   Create a project at"), import_chalk2.default.cyan("https://codmir.com"));
+        process.exit(1);
+      }
+      const { selectedProject } = await (0, import_prompts.default)({
+        type: "select",
+        name: "selectedProject",
+        message: "Select a project to link:",
+        choices: projects.map((p) => ({
+          title: `${p.name} (${p.key})`,
+          value: p.id,
+          description: p.description || void 0
+        }))
+      });
+      if (!selectedProject) {
+        console.log(import_chalk2.default.dim("   Cancelled"));
+        return;
+      }
+      projectId = selectedProject;
+    }
+    const project = projects.find((p) => p.id === projectId);
+    if (!project) {
+      console.error(import_chalk2.default.red("\u274C Project not found"));
+      process.exit(1);
+    }
+    writeProjectConfig({
+      projectId: project.id,
+      organizationId: project.organizationId || orgId,
+      projectName: project.name
+    });
+    console.log(import_chalk2.default.green("\n\u2705 Successfully linked!"));
+    console.log(import_chalk2.default.dim("   Project:"), import_chalk2.default.bold(project.name));
+    console.log(import_chalk2.default.dim("   ID:"), import_chalk2.default.bold(project.id));
+    console.log(import_chalk2.default.dim("\n   Configuration saved to"), import_chalk2.default.cyan(".codmir.json"));
+    console.log(import_chalk2.default.dim("   You can now use the codmir package in your project"));
+  } catch (error) {
+    console.error(import_chalk2.default.red("\n\u274C Link failed:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/whoami.ts
+var import_chalk3 = __toESM(require("chalk"));
+async function whoamiCommand() {
+  if (!isAuthenticated()) {
+    console.error(import_chalk3.default.red("\u274C Not authenticated"));
+    console.log(import_chalk3.default.dim("   Run"), import_chalk3.default.cyan("codmir login"), import_chalk3.default.dim("first"));
+    process.exit(1);
+  }
+  const config = readConfig();
+  console.log(import_chalk3.default.bold("\n\u{1F464} Current User\n"));
+  console.log(import_chalk3.default.dim("   Name:"), import_chalk3.default.bold(config.name || "N/A"));
+  console.log(import_chalk3.default.dim("   Email:"), import_chalk3.default.bold(config.email || "N/A"));
+  console.log(import_chalk3.default.dim("   User ID:"), import_chalk3.default.dim(config.userId || "N/A"));
+  if (config.lastLogin) {
+    const lastLogin = new Date(config.lastLogin);
+    console.log(import_chalk3.default.dim("   Last Login:"), import_chalk3.default.dim(lastLogin.toLocaleString()));
+  }
+}
+
+// src/cli/commands/logout.ts
+var import_chalk4 = __toESM(require("chalk"));
+async function logoutCommand() {
+  if (!isAuthenticated()) {
+    console.log(import_chalk4.default.yellow("\u26A0\uFE0F  Not logged in"));
+    return;
+  }
+  const config = readConfig();
+  clearConfig();
+  console.log(import_chalk4.default.green("\u2705 Successfully logged out"));
+  if (config.email) {
+    console.log(import_chalk4.default.dim("   Goodbye,"), import_chalk4.default.bold(config.email));
+  }
+}
+
+// src/cli/commands/init.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+async function initCommand() {
+  console.log(import_chalk5.default.bold("\n\u{1F389} Initialize codmir\n"));
+  const config = readProjectConfig();
+  if (!config) {
+    console.log(import_chalk5.default.yellow("\u26A0\uFE0F  Project not linked"));
+    console.log(import_chalk5.default.dim("   Run"), import_chalk5.default.cyan("codmir link"), import_chalk5.default.dim("to link this project first"));
+    return;
+  }
+  console.log(import_chalk5.default.dim("   Project:"), import_chalk5.default.bold(config.projectName || config.projectId));
+  const exampleFile = import_path2.default.join(process.cwd(), "codmir.example.ts");
+  if (import_fs2.default.existsSync(exampleFile)) {
+    console.log(import_chalk5.default.yellow("\n\u26A0\uFE0F  codmir.example.ts already exists"));
+  } else {
+    const example = `import { CodmirClient } from 'codmir';
+
+// Initialize the client
+const codmir = new CodmirClient({
+  apiKey: process.env.CODMIR_API_KEY!, // Get token from: codmir login
+});
+
+// Example: Create a ticket
+async function createTicket() {
+  const ticket = await codmir.tickets.create(
+    '${config.projectId}',
+    'board-id',
+    {
+      title: 'Example ticket',
+      description: 'Created from codmir package',
+      priority: 'HIGH',
+    }
+  );
+  
+  console.log('Created ticket:', ticket.id);
+}
+
+// Example: Create a test case
+async function createTestCase() {
+  const testCase = await codmir.testCases.create('${config.projectId}', {
+    title: 'Example test case',
+    suiteId: 'suite-id',
+    template: 'steps',
+    steps: [
+      { action: 'Do something', expected: 'It works' },
+    ],
+  });
+  
+  console.log('Created test case:', testCase.id);
+}
+
+// Run examples
+createTicket().catch(console.error);
+createTestCase().catch(console.error);
+`;
+    import_fs2.default.writeFileSync(exampleFile, example);
+    console.log(import_chalk5.default.green("\n\u2705 Created"), import_chalk5.default.cyan("codmir.example.ts"));
+  }
+  console.log(import_chalk5.default.bold("\n\u{1F4DA} Next Steps:\n"));
+  console.log(import_chalk5.default.dim("   1."), "Install the package:", import_chalk5.default.cyan("npm install codmir"));
+  console.log(import_chalk5.default.dim("   2."), "Get your API token from:", import_chalk5.default.cyan("https://codmir.com/settings/tokens"));
+  console.log(import_chalk5.default.dim("   3."), "Set environment variable:", import_chalk5.default.cyan("CODMIR_API_KEY=your-token"));
+  console.log(import_chalk5.default.dim("   4."), "Check", import_chalk5.default.cyan("codmir.example.ts"), "for usage examples");
+  console.log(import_chalk5.default.dim("\n   \u{1F4D6} Documentation:"), import_chalk5.default.cyan("https://codmir.com/docs"));
+}
+
+// src/cli/commands/projects.ts
+var import_chalk6 = __toESM(require("chalk"));
+async function projectsCommand() {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk6.default.red("\u274C Not authenticated"));
+    console.log(import_chalk6.default.dim("   Run"), import_chalk6.default.cyan("codmir login"), import_chalk6.default.dim("first"));
+    process.exit(1);
+  }
+  console.log(import_chalk6.default.bold("\n\u{1F4C1} Your Projects\n"));
+  try {
+    const response = await fetch(`${process.env.CODMIR_API_URL || "https://codmir.com"}/api/projects`, {
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch projects");
+    }
+    const projects = await response.json();
+    if (projects.length === 0) {
+      console.log(import_chalk6.default.yellow("   No projects found"));
+      console.log(import_chalk6.default.dim("   Create one at"), import_chalk6.default.cyan("https://codmir.com"));
+      return;
+    }
+    projects.forEach((project, index) => {
+      console.log(import_chalk6.default.bold(`   ${index + 1}. ${project.name}`), import_chalk6.default.dim(`(${project.key})`));
+      console.log(import_chalk6.default.dim("      ID:"), project.id);
+      if (project.description) {
+        console.log(import_chalk6.default.dim("      Description:"), project.description);
+      }
+      console.log("");
+    });
+    console.log(import_chalk6.default.dim("   Link a project:"), import_chalk6.default.cyan("codmir link"));
+  } catch (error) {
+    console.error(import_chalk6.default.red("\n\u274C Failed to fetch projects:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new import_commander.Command();
+program.name("codmir").description("codmir CLI - the AI that prevents wasted engineering time").version("0.1.0");
+program.command("login").description("Authenticate with codmir").option("--token <token>", "Use an API token directly").action(loginCommand);
+program.command("link").description("Link current directory to a codmir project").option("--project <projectId>", "Project ID to link").option("--org <orgId>", "Organization ID").action(linkCommand);
+program.command("whoami").description("Show current authenticated user").action(whoamiCommand);
+program.command("logout").description("Log out of codmir").action(logoutCommand);
+program.command("init").description("Initialize codmir in your project").action(initCommand);
+program.command("projects").alias("ls").description("List your projects").action(projectsCommand);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}