codmir 0.3.1 → 0.3.3

package/dist/cli/index.mjs

@@ -1,175 +1,188 @@
 #!/usr/bin/env node
 import {
   CodmirClient
-} from "../chunk-7HVQNURM.mjs";
+} from "../chunk-LXEEBTWT.mjs";
+import {
+  analyzeCommand,
+  clearConfig,
+  ensureConfigDir,
+  getBaseUrl,
+  getExecutionContext,
+  getProjectConfig,
+  getToken,
+  isAuthenticated,
+  readConfig,
+  readProjectConfig,
+  writeConfig,
+  writeProjectConfig
+} from "../chunk-ASGAT3Z5.mjs";
+import {
+  __commonJS
+} from "../chunk-EBO3CZXG.mjs";
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "codmir",
+      version: "0.3.3",
+      description: "Official codmir SDK - CLI and SDK for AI-powered development: codebase analysis, task replication, usage tracking, and intelligent automation",
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      bin: {
+        codmir: "dist/cli/index.js"
+      },
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          require: "./dist/index.js",
+          import: "./dist/index.mjs"
+        }
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "runkit-example.js"
+      ],
+      scripts: {
+        build: "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts --clean",
+        dev: "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts --watch",
+        prepublishOnly: "pnpm build",
+        test: "jest",
+        "test:login": "node scripts/test/login.mjs",
+        "test:link": "node scripts/test/link.mjs",
+        "test:projects": "node scripts/test/projects.mjs",
+        "test:whoami": "node scripts/test/whoami.mjs",
+        "test:logout": "node scripts/test/logout.mjs",
+        "test:all": "npm run test:logout && npm run test:login && npm run test:whoami && npm run test:projects"
+      },
+      keywords: [
+        "codmir",
+        "sdk",
+        "cli",
+        "ai",
+        "codebase-analysis",
+        "knowledge-base",
+        "task-replication",
+        "usage-tracking",
+        "observability",
+        "project-management",
+        "tickets",
+        "tasks",
+        "automation",
+        "multi-agent",
+        "ai-assistant"
+      ],
+      author: "codmir",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/codmir/codmir.git",
+        directory: "apps/web/packages/codmir-client"
+      },
+      bugs: {
+        url: "https://github.com/codmir/codmir/issues"
+      },
+      homepage: "https://codmir.com",
+      runkit: {
+        example: "runkit-example.js"
+      },
+      devDependencies: {
+        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/commit-analyzer": "^13.0.0",
+        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/github": "^11.0.0",
+        "@semantic-release/npm": "^12.0.1",
+        "@semantic-release/release-notes-generator": "^14.0.0",
+        "@types/node": "^20.10.0",
+        "@types/prompts": "^2.4.9",
+        "conventional-changelog-conventionalcommits": "^8.0.0",
+        "semantic-release": "^24.0.0",
+        tsup: "^8.0.1",
+        typescript: "^5.8.3"
+      },
+      dependencies: {
+        chalk: "^5.3.0",
+        clipboardy: "^5.0.1",
+        commander: "^12.0.0",
+        "form-data": "^4.0.5",
+        glob: "^10.3.10",
+        open: "^10.0.0",
+        ora: "^9.0.0",
+        prompts: "^2.4.2",
+        ws: "^8.18.3"
+      },
+      engines: {
+        node: ">=18.0.0"
+      }
+    };
+  }
+});
 
 // src/cli/index.ts
 import { Command } from "commander";
 
 // src/cli/utils/auth.ts
-import http from "http";
 import open from "open";
-
-// src/cli/utils/config.ts
-import fs from "fs";
-import path from "path";
-import os from "os";
-var CONFIG_DIR = path.join(os.homedir(), ".codmir");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-var PROJECT_CONFIG_FILE = ".codmir.json";
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
+import * as readline from "readline";
+function promptForToken() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("\nPaste your authentication token: ", (token) => {
+      rl.close();
+      resolve(token.trim());
+    });
+  });
 }
-function readConfig() {
-  ensureConfigDir();
-  if (!fs.existsSync(CONFIG_FILE)) {
-    return {};
-  }
+async function startOAuthFlow(baseUrl = "https://codmir.com") {
+  const authUrl = `${baseUrl}/cli/auth`;
+  console.log("\u{1F510} Opening browser for authentication...");
+  console.log(`   If browser doesn't open, visit: ${authUrl}`);
+  console.log();
   try {
-    const data = fs.readFileSync(CONFIG_FILE, "utf-8");
-    return JSON.parse(data);
-  } catch (error) {
-    console.error("Error reading config:", error);
-    return {};
-  }
-}
-function writeConfig(config) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-function clearConfig() {
-  if (fs.existsSync(CONFIG_FILE)) {
-    fs.unlinkSync(CONFIG_FILE);
+    await open(authUrl);
+  } catch {
+    console.log("\u26A0\uFE0F  Could not open browser automatically.");
+    console.log(`   Please visit: ${authUrl}`);
+    console.log();
   }
-}
-function readProjectConfig(cwd = process.cwd()) {
-  const configPath = path.join(cwd, PROJECT_CONFIG_FILE);
-  if (!fs.existsSync(configPath)) {
-    return null;
+  console.log("\u{1F4CB} After authenticating in your browser:");
+  console.log("   1. Copy the token displayed");
+  console.log("   2. Return here and paste it below");
+  console.log();
+  const token = await promptForToken();
+  if (!token) {
+    throw new Error("No token provided");
   }
   try {
-    const data = fs.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 = path.join(cwd, PROJECT_CONFIG_FILE);
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  const gitignorePath = path.join(cwd, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignore = fs.readFileSync(gitignorePath, "utf-8");
-    if (!gitignore.includes(PROJECT_CONFIG_FILE)) {
-      fs.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 = http.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 userResponse = await fetch(`${baseUrl}/api/user/profile`, {
+      headers: {
+        "X-API-Key": token
       }
     });
-    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}`);
-      open(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);
-  });
+    if (!userResponse.ok) {
+      throw new Error("Invalid token or authentication failed");
+    }
+    const response = await userResponse.json();
+    const user = response.data || response;
+    return {
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name
+      }
+    };
+  } catch (error) {
+    throw new Error(
+      error instanceof Error ? error.message : "Failed to validate token"
+    );
+  }
 }
 async function authenticateWithToken(token, baseUrl = "https://codmir.com") {
   const response = await fetch(`${baseUrl}/api/user/profile`, {
@@ -180,7 +193,8 @@ async function authenticateWithToken(token, baseUrl = "https://codmir.com") {
   if (!response.ok) {
     throw new Error("Invalid token");
   }
-  const user = await response.json();
+  const responseData = await response.json();
+  const user = responseData.data || responseData;
   return {
     token,
     user: {
@@ -215,11 +229,16 @@ async function loginCommand(options) {
   console.log(chalk.dim("   Authenticate to start using codmir CLI\n"));
   try {
     let authResult;
+    const baseUrl = getBaseUrl();
+    if (baseUrl !== "https://codmir.com") {
+      console.log(chalk.dim(`   Connecting to: ${baseUrl}
+`));
+    }
     if (options.token) {
       console.log(chalk.dim("   Authenticating with provided token..."));
-      authResult = await authenticateWithToken(options.token);
+      authResult = await authenticateWithToken(options.token, baseUrl);
     } else {
-      authResult = await startOAuthFlow();
+      authResult = await startOAuthFlow(baseUrl);
     }
     saveAuth(authResult);
     console.log(chalk.green("\n\u2705 Successfully logged in!"));
@@ -232,24 +251,124 @@ async function loginCommand(options) {
   }
 }
 
-// src/cli/commands/link.ts
+// src/cli/commands/logout.ts
 import chalk2 from "chalk";
+async function logoutCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk2.yellow("\u26A0\uFE0F  Not logged in"));
+    return;
+  }
+  const config = readConfig();
+  clearConfig();
+  console.log(chalk2.green("\u2705 Successfully logged out"));
+  if (config.email) {
+    console.log(chalk2.dim("   Goodbye,"), chalk2.bold(config.email));
+  }
+}
+
+// src/cli/commands/whoami.ts
+import chalk3 from "chalk";
+async function whoamiCommand() {
+  if (!isAuthenticated()) {
+    console.error(chalk3.red("\u274C Not authenticated"));
+    console.log(chalk3.dim("   Run"), chalk3.cyan("codmir login"), chalk3.dim("first"));
+    process.exit(1);
+  }
+  const config = readConfig();
+  console.log(chalk3.bold("\n\u{1F464} Current User\n"));
+  console.log(chalk3.dim("   Name:"), chalk3.bold(config.name || "N/A"));
+  console.log(chalk3.dim("   Email:"), chalk3.bold(config.email || "N/A"));
+  console.log(chalk3.dim("   User ID:"), chalk3.dim(config.userId || "N/A"));
+  if (config.lastLogin) {
+    const lastLogin = new Date(config.lastLogin);
+    console.log(chalk3.dim("   Last Login:"), chalk3.dim(lastLogin.toLocaleString()));
+  }
+}
+
+// src/cli/commands/link.ts
 import prompts from "prompts";
+import chalk4 from "chalk";
+
+// src/cli/utils/machine-id.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var MACHINE_ID_FILE = path.join(os.homedir(), ".codmir", "machine-id");
+function getMachineId() {
+  ensureConfigDir();
+  if (fs.existsSync(MACHINE_ID_FILE)) {
+    try {
+      return fs.readFileSync(MACHINE_ID_FILE, "utf-8").trim();
+    } catch (error) {
+      console.error("Error reading machine ID:", error);
+    }
+  }
+  const machineId = crypto.randomBytes(16).toString("hex");
+  try {
+    fs.writeFileSync(MACHINE_ID_FILE, machineId);
+  } catch (error) {
+    console.error("Error saving machine ID:", error);
+  }
+  return machineId;
+}
+function getMachineInfo() {
+  return {
+    machineId: getMachineId(),
+    hostname: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    nodeVersion: process.version,
+    cliVersion: getPackageVersion()
+  };
+}
+function getPackageVersion() {
+  try {
+    const pkg = require_package();
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+}
+async function registerMachine(projectId, token, baseUrl) {
+  const machineInfo = getMachineInfo();
+  try {
+    const response = await fetch(`${baseUrl}/api/cli/register`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": token
+      },
+      body: JSON.stringify({
+        projectId,
+        ...machineInfo,
+        workingDirectory: process.cwd()
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to register machine: ${response.statusText}`);
+    }
+  } catch (error) {
+    console.error("[codmir] Failed to register machine:", error);
+  }
+}
+
+// src/cli/commands/link.ts
 async function linkCommand(options) {
   const token = getToken();
   if (!token) {
-    console.error(chalk2.red("\u274C Not authenticated"));
-    console.log(chalk2.dim("   Run"), chalk2.cyan("codmir login"), chalk2.dim("first"));
+    console.error(chalk4.red("\u274C Not authenticated"));
+    console.log(chalk4.dim("   Run"), chalk4.cyan("codmir login"), chalk4.dim("first"));
     process.exit(1);
   }
-  console.log(chalk2.bold("\n\u{1F517} codmir link"));
-  console.log(chalk2.dim("   Link this directory to a codmir project\n"));
+  console.log(chalk4.bold("\n\u{1F517} codmir link"));
+  console.log(chalk4.dim("   Link this directory to a codmir project\n"));
   const existing = readProjectConfig();
   if (existing) {
-    console.log(chalk2.yellow("\u26A0\uFE0F  This directory is already linked to:"));
-    console.log(chalk2.dim("   Project ID:"), chalk2.bold(existing.projectId));
+    console.log(chalk4.yellow("\u26A0\uFE0F  This directory is already linked to:"));
+    console.log(chalk4.dim("   Project ID:"), chalk4.bold(existing.projectId));
     if (existing.projectName) {
-      console.log(chalk2.dim("   Project:"), chalk2.bold(existing.projectName));
+      console.log(chalk4.dim("   Project:"), chalk4.bold(existing.projectName));
     }
     const { overwrite } = await prompts({
       type: "confirm",
@@ -258,31 +377,33 @@ async function linkCommand(options) {
       initial: false
     });
     if (!overwrite) {
-      console.log(chalk2.dim("   Cancelled"));
+      console.log(chalk4.dim("   Cancelled"));
       return;
     }
   }
   try {
+    const baseUrl = getBaseUrl();
     const client = new CodmirClient({
       apiKey: token,
-      baseUrl: process.env.CODMIR_API_URL || "https://codmir.com"
+      baseUrl
     });
     let projectId = options.project;
     let orgId = options.org;
-    console.log(chalk2.dim("   Fetching your projects...\n"));
-    const response = await fetch(`${process.env.CODMIR_API_URL || "https://codmir.com"}/api/projects`, {
+    console.log(chalk4.dim("   Fetching your projects...\n"));
+    const response = await fetch(`${baseUrl}/api/projects`, {
       headers: {
-        "Authorization": `Bearer ${token}`
+        "X-API-Key": token
       }
     });
     if (!response.ok) {
       throw new Error("Failed to fetch projects");
     }
-    const projects = await response.json();
+    const responseData = await response.json();
+    const projects = responseData.data || responseData;
     if (!projectId) {
       if (projects.length === 0) {
-        console.log(chalk2.yellow("\u26A0\uFE0F  You don't have any projects yet"));
-        console.log(chalk2.dim("   Create a project at"), chalk2.cyan("https://codmir.com"));
+        console.log(chalk4.yellow("\u26A0\uFE0F  You don't have any projects yet"));
+        console.log(chalk4.dim("   Create a project at"), chalk4.cyan("https://codmir.com"));
         process.exit(1);
       }
       const { selectedProject } = await prompts({
@@ -296,14 +417,14 @@ async function linkCommand(options) {
         }))
       });
       if (!selectedProject) {
-        console.log(chalk2.dim("   Cancelled"));
+        console.log(chalk4.dim("   Cancelled"));
         return;
       }
       projectId = selectedProject;
     }
     const project = projects.find((p) => p.id === projectId);
     if (!project) {
-      console.error(chalk2.red("\u274C Project not found"));
+      console.error(chalk4.red("\u274C Project not found"));
       process.exit(1);
     }
     writeProjectConfig({
@@ -311,51 +432,35 @@ async function linkCommand(options) {
       organizationId: project.organizationId || orgId,
       projectName: project.name
     });
-    console.log(chalk2.green("\n\u2705 Successfully linked!"));
-    console.log(chalk2.dim("   Project:"), chalk2.bold(project.name));
-    console.log(chalk2.dim("   ID:"), chalk2.bold(project.id));
-    console.log(chalk2.dim("\n   Configuration saved to"), chalk2.cyan(".codmir.json"));
-    console.log(chalk2.dim("   You can now use the codmir package in your project"));
+    console.log(chalk4.green("\n\u2705 Successfully linked!"));
+    console.log(chalk4.dim("   Project:"), chalk4.bold(project.name));
+    console.log(chalk4.dim("   ID:"), chalk4.bold(project.id));
+    console.log(chalk4.dim("\n   Configuration saved to"), chalk4.cyan(".codmir.json"));
+    console.log(chalk4.dim("   You can now use the codmir package in your project"));
+    await registerMachine(project.id, token, baseUrl);
+    console.log();
+    const { analyze } = await prompts({
+      type: "confirm",
+      name: "analyze",
+      message: "Analyze codebase now? (Recommended)",
+      initial: true
+    });
+    if (analyze) {
+      console.log();
+      const { analyzeCommand: analyzeCommand2 } = await import("../analyze-LULBI4ZC.mjs");
+      await analyzeCommand2({ mode: "local" });
+    } else {
+      console.log();
+      console.log(chalk4.dim("   You can analyze later with:"), chalk4.cyan("codmir analyze"));
+      console.log();
+    }
   } catch (error) {
-    console.error(chalk2.red("\n\u274C Link failed:"), error instanceof Error ? error.message : "Unknown error");
+    console.log(chalk4.red("\n\u274C Failed to link project"));
+    console.log(chalk4.dim(error.message));
     process.exit(1);
   }
 }
 
-// src/cli/commands/whoami.ts
-import chalk3 from "chalk";
-async function whoamiCommand() {
-  if (!isAuthenticated()) {
-    console.error(chalk3.red("\u274C Not authenticated"));
-    console.log(chalk3.dim("   Run"), chalk3.cyan("codmir login"), chalk3.dim("first"));
-    process.exit(1);
-  }
-  const config = readConfig();
-  console.log(chalk3.bold("\n\u{1F464} Current User\n"));
-  console.log(chalk3.dim("   Name:"), chalk3.bold(config.name || "N/A"));
-  console.log(chalk3.dim("   Email:"), chalk3.bold(config.email || "N/A"));
-  console.log(chalk3.dim("   User ID:"), chalk3.dim(config.userId || "N/A"));
-  if (config.lastLogin) {
-    const lastLogin = new Date(config.lastLogin);
-    console.log(chalk3.dim("   Last Login:"), chalk3.dim(lastLogin.toLocaleString()));
-  }
-}
-
-// src/cli/commands/logout.ts
-import chalk4 from "chalk";
-async function logoutCommand() {
-  if (!isAuthenticated()) {
-    console.log(chalk4.yellow("\u26A0\uFE0F  Not logged in"));
-    return;
-  }
-  const config = readConfig();
-  clearConfig();
-  console.log(chalk4.green("\u2705 Successfully logged out"));
-  if (config.email) {
-    console.log(chalk4.dim("   Goodbye,"), chalk4.bold(config.email));
-  }
-}
-
 // src/cli/commands/init.ts
 import chalk5 from "chalk";
 import fs2 from "fs";
@@ -435,15 +540,17 @@ async function projectsCommand() {
   }
   console.log(chalk6.bold("\n\u{1F4C1} Your Projects\n"));
   try {
-    const response = await fetch(`${process.env.CODMIR_API_URL || "https://codmir.com"}/api/projects`, {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/api/projects`, {
       headers: {
-        "Authorization": `Bearer ${token}`
+        "X-API-Key": token
       }
     });
     if (!response.ok) {
       throw new Error("Failed to fetch projects");
     }
-    const projects = await response.json();
+    const responseData = await response.json();
+    const projects = responseData.data || responseData;
     if (projects.length === 0) {
       console.log(chalk6.yellow("   No projects found"));
       console.log(chalk6.dim("   Create one at"), chalk6.cyan("https://codmir.com"));
@@ -464,6 +571,856 @@ async function projectsCommand() {
   }
 }
 
+// src/cli/commands/assistant.ts
+import chalk7 from "chalk";
+import ora from "ora";
+import prompts2 from "prompts";
+import clipboardy from "clipboardy";
+import fs3 from "fs";
+import path3 from "path";
+import FormData from "form-data";
+async function assistantCommand(query, options = {}) {
+  const token = getToken();
+  if (!token) {
+    console.error(chalk7.red("\u274C Not authenticated"));
+    console.log(chalk7.dim("   Run"), chalk7.cyan("codmir login"), chalk7.dim("first"));
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const conversationHistory = [];
+  const context = getExecutionContext();
+  if (context.isLinkedProject) {
+    console.log(chalk7.dim(`   \u{1F4C1} Project: ${context.projectConfig?.projectName || context.projectConfig?.projectId}`));
+    console.log(chalk7.dim(`   \u{1F517} Mode: ${chalk7.cyan("local")} (linked project)
+`));
+  } else {
+    console.log(chalk7.dim(`   \u{1F310} Mode: ${chalk7.yellow("global")}
+`));
+  }
+  conversationHistory.push({
+    role: "system",
+    content: `You are codmir, an AI assistant for developers. You help with:
+- Code questions and debugging
+- Project setup and configuration  
+- Best practices and patterns
+- Task automation
+
+Be concise, practical, and code-focused. Use lowercase "codmir" for the brand.`
+  });
+  console.log(chalk7.bold("\n\u{1F916} codmir"));
+  console.log(chalk7.dim("   AI assistant for developers\n"));
+  if (query) {
+    await handleQuery(query, conversationHistory, baseUrl, token, options);
+    return;
+  }
+  console.log(chalk7.dim("   Type your question or"), chalk7.cyan("exit"), chalk7.dim("to quit"));
+  console.log(chalk7.dim("   \u{1F4CB} Tip: Copy images to clipboard before asking for automatic upload"));
+  console.log(chalk7.dim('   Example: "How do I setup authentication?"\n'));
+  while (true) {
+    const { userInput } = await prompts2({
+      type: "text",
+      name: "userInput",
+      message: chalk7.cyan("codmir"),
+      validate: (value) => value.length > 0 || "Please enter a question"
+    });
+    if (!userInput || userInput.toLowerCase() === "exit" || userInput.toLowerCase() === "quit") {
+      console.log(chalk7.dim("\n   Goodbye! \u{1F44B}\n"));
+      break;
+    }
+    await handleQuery(userInput, conversationHistory, baseUrl, token, options);
+  }
+}
+async function handleQuery(query, conversationHistory, baseUrl, token, options) {
+  let imagePaths;
+  const hasClipboardImage = await checkClipboardForImage();
+  if (hasClipboardImage) {
+    const { attachImage } = await prompts2({
+      type: "confirm",
+      name: "attachImage",
+      message: chalk7.cyan("\u{1F4CB} Image detected in clipboard. Attach to message?"),
+      initial: true
+    });
+    if (attachImage) {
+      const imagePath = await saveClipboardImage();
+      if (imagePath) {
+        imagePaths = [imagePath];
+        console.log(chalk7.green("   \u2713 Image attached from clipboard\n"));
+      }
+    }
+  }
+  conversationHistory.push({
+    role: "user",
+    content: query,
+    images: imagePaths
+  });
+  const spinner = ora({
+    text: chalk7.dim("Thinking..."),
+    color: "cyan",
+    spinner: {
+      interval: 80,
+      frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+    }
+  }).start();
+  try {
+    let response;
+    if (imagePaths && imagePaths.length > 0) {
+      const formData = new FormData();
+      formData.append("query", query);
+      formData.append("model", options.model || "gpt-4-turbo-preview");
+      if (options.project) formData.append("project", options.project);
+      if (options.context) formData.append("includeContext", "true");
+      formData.append("messages", JSON.stringify(conversationHistory));
+      for (const imagePath of imagePaths) {
+        formData.append("images", fs3.createReadStream(imagePath));
+      }
+      response = await fetch(`${baseUrl}/api/assistant/chat`, {
+        method: "POST",
+        headers: {
+          "X-API-Key": token,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+    } else {
+      response = await fetch(`${baseUrl}/api/assistant/chat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": token
+        },
+        body: JSON.stringify({
+          messages: conversationHistory,
+          model: options.model || "gpt-4-turbo-preview",
+          project: options.project,
+          includeContext: options.context
+        })
+      });
+    }
+    spinner.stop();
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const assistantMessage = data.message || data.content || "Sorry, I couldn't process that.";
+    conversationHistory.push({
+      role: "assistant",
+      content: assistantMessage
+    });
+    console.log("\n" + renderResponse(assistantMessage) + "\n");
+  } catch (error) {
+    spinner.stop();
+    console.error(chalk7.red("\n\u274C Error:"), error instanceof Error ? error.message : "Unknown error");
+    console.log(chalk7.dim("   Try again or check your connection\n"));
+  }
+}
+function renderResponse(message) {
+  const indicator = getIndicator();
+  const lines = message.split("\n");
+  let output = "";
+  lines.forEach((line, index) => {
+    if (index === 0) {
+      output += `${indicator} ${chalk7.white(line)}
+`;
+    } else {
+      output += `   ${chalk7.white(line)}
+`;
+    }
+  });
+  return output;
+}
+function getIndicator() {
+  const isDark = isTerminalDark();
+  if (isDark) {
+    return chalk7.whiteBright("\u25CF");
+  } else {
+    return chalk7.black("\u25CF");
+  }
+}
+function isTerminalDark() {
+  const colorScheme = process.env.COLORFGBG;
+  if (colorScheme) {
+    const parts = colorScheme.split(";");
+    const bg = parseInt(parts[1] || "0");
+    return bg < 8;
+  }
+  return true;
+}
+async function quickQueryCommand(query, options = {}) {
+  const conversationHistory = [{
+    role: "system",
+    content: "You are codmir, a concise AI assistant for developers. Give short, practical answers."
+  }];
+  const token = getToken();
+  if (!token) {
+    console.error(chalk7.red("\u274C Not authenticated"));
+    process.exit(1);
+  }
+  await handleQuery(query, conversationHistory, getBaseUrl(), token, options);
+}
+async function checkClipboardForImage() {
+  try {
+    const clipboardContent = await clipboardy.read();
+    return clipboardContent.startsWith("data:image/") || clipboardContent.match(/\.(png|jpg|jpeg|gif|webp)$/i) !== null;
+  } catch {
+    return false;
+  }
+}
+async function saveClipboardImage() {
+  try {
+    const clipboardContent = await clipboardy.read();
+    if (clipboardContent.startsWith("data:image/")) {
+      const matches = clipboardContent.match(/^data:image\/(\w+);base64,(.+)$/);
+      if (!matches) return null;
+      const ext = matches[1];
+      const base64Data = matches[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const tmpPath = path3.join("/tmp", `codmir-assistant-${Date.now()}.${ext}`);
+      fs3.writeFileSync(tmpPath, buffer);
+      return tmpPath;
+    }
+    if (fs3.existsSync(clipboardContent)) {
+      return clipboardContent;
+    }
+    return null;
+  } catch (error) {
+    console.error(chalk7.dim("   Failed to save clipboard image"));
+    return null;
+  }
+}
+
+// src/cli/commands/ticket.ts
+import chalk8 from "chalk";
+import prompts3 from "prompts";
+import clipboardy2 from "clipboardy";
+import fs4 from "fs";
+import path4 from "path";
+import FormData2 from "form-data";
+async function createTicketCommand() {
+  const token = getToken();
+  if (!token) {
+    console.error(chalk8.red("\u274C Not authenticated"));
+    console.log(chalk8.dim("   Run"), chalk8.cyan("codmir login"), chalk8.dim("first"));
+    process.exit(1);
+  }
+  console.log(chalk8.bold("\n\u{1F3AB} Create Ticket\n"));
+  try {
+    const linkedProject = getProjectConfig();
+    let selectedProject = null;
+    let selectedOrg = null;
+    if (linkedProject) {
+      const { useLinked } = await prompts3({
+        type: "confirm",
+        name: "useLinked",
+        message: `Use linked project: ${chalk8.cyan(linkedProject.name)}?`,
+        initial: true
+      });
+      if (useLinked) {
+        selectedProject = linkedProject;
+      }
+    }
+    if (!selectedProject) {
+      const selection = await navigateAndSelectProject(token);
+      if (!selection) {
+        console.log(chalk8.yellow("\n\u26A0\uFE0F  Cancelled"));
+        return;
+      }
+      selectedProject = selection.project;
+      selectedOrg = selection.organization;
+    }
+    console.log(chalk8.green("\n\u2713 Project:"), chalk8.cyan(selectedProject.name));
+    const ticketData = await collectTicketDetails();
+    if (!ticketData) {
+      console.log(chalk8.yellow("\n\u26A0\uFE0F  Cancelled"));
+      return;
+    }
+    const hasClipboardImage = await checkClipboardForImage2();
+    if (hasClipboardImage) {
+      const { attachImage } = await prompts3({
+        type: "confirm",
+        name: "attachImage",
+        message: chalk8.cyan("\u{1F4CB} Image detected in clipboard. Attach to ticket?"),
+        initial: true
+      });
+      if (attachImage) {
+        const imagePath = await saveClipboardImage2();
+        if (imagePath) {
+          ticketData.images = [imagePath];
+          console.log(chalk8.green("\u2713 Image attached"));
+        }
+      }
+    }
+    await createTicket(token, selectedProject.id, ticketData);
+  } catch (error) {
+    console.error(chalk8.red("\n\u274C Error:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function navigateAndSelectProject(token) {
+  const baseUrl = getBaseUrl();
+  console.log(chalk8.dim("\n   Loading organizations..."));
+  const orgsResponse = await fetch(`${baseUrl}/api/user/organizations`, {
+    headers: { "X-API-Key": token }
+  });
+  if (!orgsResponse.ok) {
+    throw new Error("Failed to fetch organizations");
+  }
+  const { organizations } = await orgsResponse.json();
+  if (!organizations || organizations.length === 0) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  No organizations found"));
+    return null;
+  }
+  console.log(chalk8.bold("\n\u{1F579}\uFE0F  Select Organization"));
+  console.log(chalk8.dim("   Use \u2191\u2193 arrows to navigate, Enter to select\n"));
+  const { orgIndex } = await prompts3({
+    type: "select",
+    name: "orgIndex",
+    message: chalk8.cyan("Organization"),
+    choices: organizations.map((org, index) => ({
+      title: `${getJoystickIndicator(index)} ${org.name}`,
+      value: index,
+      description: org.slug
+    })),
+    initial: 0
+  });
+  if (orgIndex === void 0) return null;
+  const selectedOrg = organizations[orgIndex];
+  console.log(chalk8.dim("\n   Loading projects..."));
+  const projectsResponse = await fetch(
+    `${baseUrl}/api/organizations/${selectedOrg.id}/projects`,
+    { headers: { "X-API-Key": token } }
+  );
+  if (!projectsResponse.ok) {
+    throw new Error("Failed to fetch projects");
+  }
+  const projectsData = await projectsResponse.json();
+  const projects = projectsData.data || projectsData;
+  if (!projects || projects.length === 0) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  No projects found in this organization"));
+    return null;
+  }
+  console.log(chalk8.bold("\n\u{1F579}\uFE0F  Select Project"));
+  console.log(chalk8.dim("   Use \u2191\u2193 arrows to navigate, Enter to select\n"));
+  const { projectIndex } = await prompts3({
+    type: "select",
+    name: "projectIndex",
+    message: chalk8.cyan("Project"),
+    choices: projects.map((project, index) => ({
+      title: `${getJoystickIndicator(index)} ${project.name}`,
+      value: index,
+      description: project.key
+    })),
+    initial: 0
+  });
+  if (projectIndex === void 0) return null;
+  return {
+    organization: selectedOrg,
+    project: projects[projectIndex]
+  };
+}
+function getJoystickIndicator(index) {
+  const indicators = ["\u25B8", "\u25B9", "\u25B8", "\u25B9"];
+  return chalk8.cyan(indicators[index % indicators.length]);
+}
+async function collectTicketDetails() {
+  console.log(chalk8.bold("\n\u{1F4DD} Ticket Details\n"));
+  const responses = await prompts3([
+    {
+      type: "text",
+      name: "title",
+      message: chalk8.cyan("Title"),
+      validate: (value) => value.length > 0 || "Title is required"
+    },
+    {
+      type: "text",
+      name: "description",
+      message: chalk8.cyan("Description"),
+      initial: ""
+    },
+    {
+      type: "select",
+      name: "type",
+      message: chalk8.cyan("Type"),
+      choices: [
+        { title: "\u{1F41B} Bug", value: "BUG" },
+        { title: "\u2728 Feature", value: "FEATURE" },
+        { title: "\u{1F4CB} Task", value: "TASK" },
+        { title: "\u{1F527} Improvement", value: "IMPROVEMENT" }
+      ],
+      initial: 0
+    },
+    {
+      type: "select",
+      name: "priority",
+      message: chalk8.cyan("Priority"),
+      choices: [
+        { title: "\u{1F7E2} Low", value: "LOW" },
+        { title: "\u{1F7E1} Medium", value: "MEDIUM" },
+        { title: "\u{1F7E0} High", value: "HIGH" },
+        { title: "\u{1F534} Critical", value: "CRITICAL" }
+      ],
+      initial: 1
+    }
+  ]);
+  if (!responses.title) return null;
+  return responses;
+}
+async function checkClipboardForImage2() {
+  try {
+    const clipboardContent = await clipboardy2.read();
+    return clipboardContent.startsWith("data:image/") || clipboardContent.match(/\.(png|jpg|jpeg|gif|webp)$/i) !== null;
+  } catch {
+    return false;
+  }
+}
+async function saveClipboardImage2() {
+  try {
+    const clipboardContent = await clipboardy2.read();
+    if (clipboardContent.startsWith("data:image/")) {
+      const matches = clipboardContent.match(/^data:image\/(\w+);base64,(.+)$/);
+      if (!matches) return null;
+      const ext = matches[1];
+      const base64Data = matches[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const tmpPath = path4.join("/tmp", `codmir-ticket-${Date.now()}.${ext}`);
+      fs4.writeFileSync(tmpPath, buffer);
+      return tmpPath;
+    }
+    if (fs4.existsSync(clipboardContent)) {
+      return clipboardContent;
+    }
+    return null;
+  } catch (error) {
+    console.error(chalk8.dim("   Failed to save clipboard image"));
+    return null;
+  }
+}
+async function createTicket(token, projectId, ticketData) {
+  const baseUrl = getBaseUrl();
+  console.log(chalk8.dim("\n   Creating ticket..."));
+  try {
+    let response;
+    if (ticketData.images && ticketData.images.length > 0) {
+      const formData = new FormData2();
+      formData.append("title", ticketData.title);
+      if (ticketData.description) formData.append("description", ticketData.description);
+      if (ticketData.type) formData.append("type", ticketData.type);
+      if (ticketData.priority) formData.append("priority", ticketData.priority);
+      for (const imagePath of ticketData.images) {
+        formData.append("images", fs4.createReadStream(imagePath));
+      }
+      response = await fetch(`${baseUrl}/api/project/${projectId}/tickets`, {
+        method: "POST",
+        headers: {
+          "X-API-Key": token,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+    } else {
+      response = await fetch(`${baseUrl}/api/project/${projectId}/tickets`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": token
+        },
+        body: JSON.stringify(ticketData)
+      });
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to create ticket: ${error}`);
+    }
+    const ticket = await response.json();
+    const ticketData_response = ticket.data || ticket;
+    console.log(chalk8.green("\n\u2705 Ticket created successfully!\n"));
+    console.log(chalk8.bold("  Ticket:"), chalk8.cyan(`#${ticketData_response.key || ticketData_response.id}`));
+    console.log(chalk8.bold("  Title:"), ticketData_response.title);
+    console.log(chalk8.bold("  Type:"), getTypeEmoji(ticketData_response.type), ticketData_response.type);
+    console.log(chalk8.bold("  Priority:"), getPriorityEmoji(ticketData_response.priority), ticketData_response.priority);
+    if (ticketData.images && ticketData.images.length > 0) {
+      console.log(chalk8.bold("  Attachments:"), chalk8.green(`${ticketData.images.length} image(s)`));
+    }
+    console.log();
+  } catch (error) {
+    throw error;
+  }
+}
+function getTypeEmoji(type) {
+  const emojis = {
+    BUG: "\u{1F41B}",
+    FEATURE: "\u2728",
+    TASK: "\u{1F4CB}",
+    IMPROVEMENT: "\u{1F527}"
+  };
+  return emojis[type] || "\u{1F4CB}";
+}
+function getPriorityEmoji(priority) {
+  const emojis = {
+    LOW: "\u{1F7E2}",
+    MEDIUM: "\u{1F7E1}",
+    HIGH: "\u{1F7E0}",
+    CRITICAL: "\u{1F534}"
+  };
+  return emojis[priority] || "\u{1F7E1}";
+}
+
+// src/cli/commands/council.ts
+import chalk9 from "chalk";
+import ora2 from "ora";
+import prompts4 from "prompts";
+import WebSocket from "ws";
+var ROLE_ICONS = {
+  architect: "\u{1F3D7}\uFE0F ",
+  security: "\u{1F512}",
+  implementer: "\u{1F4BB}",
+  reviewer: "\u{1F50D}"
+};
+var ROLE_COLORS = {
+  architect: chalk9.blue,
+  security: chalk9.red,
+  implementer: chalk9.green,
+  reviewer: chalk9.yellow
+};
+async function councilCommand(task, options = {}) {
+  try {
+    printHeader();
+    if (!task) {
+      const response = await prompts4({
+        type: "text",
+        name: "task",
+        message: chalk9.cyan("\u{1F916} What would you like the council to build?"),
+        validate: (value) => value.length > 0 || "Task cannot be empty"
+      });
+      if (!response.task) {
+        console.log(chalk9.yellow("\nCouncil session cancelled."));
+        process.exit(0);
+      }
+      task = response.task;
+    }
+    console.log("");
+    const token = getToken();
+    const baseUrl = getBaseUrl();
+    if (!token) {
+      console.log(chalk9.red("\u274C Not authenticated. Please run: codmir login"));
+      process.exit(1);
+    }
+    const mode = options.local ? "local" : "lambda";
+    const apiUrl = baseUrl.replace("http", "ws") + "/council";
+    console.log(chalk9.gray(`Mode: ${mode === "lambda" ? "AWS Lambda (Serverless)" : "Local LAN Cluster"}`));
+    console.log("");
+    const ws = new WebSocket(apiUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    let sessionId = null;
+    let currentSpinner = null;
+    let roundResponses = [];
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        type: "create-session",
+        problem: task,
+        mode,
+        options: {
+          initialMembers: parseInt(options.members || "2"),
+          timeout: parseInt(options.timeout || "300") * 1e3
+        }
+      }));
+    });
+    ws.on("message", (data) => {
+      const message = JSON.parse(data.toString());
+      handleCouncilMessage(message, {
+        currentSpinner,
+        roundResponses,
+        onSpinnerUpdate: (spinner) => {
+          currentSpinner = spinner;
+        },
+        onExit: () => process.exit(0)
+      });
+    });
+    ws.on("error", (error) => {
+      if (currentSpinner) currentSpinner.fail();
+      console.log(chalk9.red(`
+\u274C Connection error: ${error.message}`));
+      process.exit(1);
+    });
+    ws.on("close", () => {
+      if (currentSpinner) currentSpinner.stop();
+    });
+  } catch (error) {
+    console.log(chalk9.red(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+function printHeader() {
+  console.log("");
+  console.log(chalk9.blue.bold("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(chalk9.blue.bold("\u2551               Claude Council - AI Collaboration            \u2551"));
+  console.log(chalk9.blue.bold('\u2551         "Preventing wasted engineering time"              \u2551'));
+  console.log(chalk9.blue.bold("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log("");
+}
+function handleCouncilMessage(message, context) {
+  const { currentSpinner, roundResponses, onSpinnerUpdate, onExit } = context;
+  switch (message.type) {
+    case "session-created":
+      console.log(chalk9.yellow("\u{1F3AD} Assembling Claude Council..."));
+      console.log("");
+      break;
+    case "spawning-member":
+      const spinner = ora2({
+        text: `Spawning ${message.role} in Docker container on ${message.location || "Lambda"}...`,
+        color: "cyan"
+      }).start();
+      onSpinnerUpdate(spinner);
+      break;
+    case "member-ready":
+      if (currentSpinner) {
+        currentSpinner.succeed(
+          chalk9.green(`\u2713 ${capitalize(message.role)} ready (${message.memberId})`)
+        );
+      }
+      break;
+    case "all-members-ready":
+      console.log("");
+      console.log(chalk9.cyan("\u{1F4AC} Council Session Started"));
+      console.log(chalk9.gray(`   Session ID: ${message.sessionId}`));
+      console.log(chalk9.gray(`   Members: ${message.memberCount}`));
+      console.log("");
+      break;
+    case "round-start":
+      printRoundHeader(message.round);
+      roundResponses.length = 0;
+      break;
+    case "member-thinking":
+      const thinkSpinner = ora2({
+        text: `${ROLE_ICONS[message.role]} ${capitalize(message.role)} is analyzing...`,
+        color: "yellow"
+      }).start();
+      onSpinnerUpdate(thinkSpinner);
+      break;
+    case "member-response":
+      if (currentSpinner) currentSpinner.stop();
+      const roleColor = ROLE_COLORS[message.role] || chalk9.white;
+      const icon = ROLE_ICONS[message.role] || "\u{1F916}";
+      console.log("");
+      console.log(roleColor.bold(`${icon} ${capitalize(message.role)}:`));
+      const formatted = formatResponse(message.content);
+      console.log(chalk9.gray(`   ${formatted}`));
+      console.log("");
+      roundResponses.push(message);
+      break;
+    case "round-complete":
+      const agreementCount = message.agreements || 0;
+      const totalMembers = message.totalMembers || roundResponses.length;
+      const agreementPercent = Math.round(agreementCount / totalMembers * 100);
+      console.log(chalk9.gray(`   Agreement: ${agreementCount}/${totalMembers} (${agreementPercent}%)`));
+      console.log("");
+      break;
+    case "consensus-reached":
+      console.log(chalk9.green.bold("\n\u2705 CONSENSUS REACHED!"));
+      console.log(chalk9.gray(`   Rounds: ${message.rounds}`));
+      console.log(chalk9.gray(`   Time: ${message.time}s`));
+      console.log("");
+      break;
+    case "spawning-additional-member":
+      console.log(chalk9.yellow(`
+\u26A0\uFE0F  Discussion needs more input. Spawning ${message.role}...`));
+      break;
+    case "generating-solution":
+      const genSpinner = ora2({
+        text: "Synthesizing final solution from council discussion...",
+        color: "green"
+      }).start();
+      onSpinnerUpdate(genSpinner);
+      break;
+    case "solution-ready":
+      if (currentSpinner) currentSpinner.succeed("Solution generated");
+      console.log("");
+      console.log(chalk9.blue.bold("\u2500".repeat(65)));
+      console.log(chalk9.blue.bold("\u{1F4CB} Solution"));
+      console.log(chalk9.blue.bold("\u2500".repeat(65)));
+      console.log("");
+      console.log(message.solution);
+      console.log("");
+      if (message.files && message.files.length > 0) {
+        console.log(chalk9.cyan("\u{1F4C1} Files created:"));
+        message.files.forEach((file) => {
+          console.log(chalk9.gray(`   \u251C\u2500 ${file}`));
+        });
+        console.log("");
+      }
+      break;
+    case "stats":
+      printStats(message.stats);
+      break;
+    case "cleanup-start":
+      console.log(chalk9.yellow("\u{1F9F9} Cleaning up council members..."));
+      break;
+    case "member-destroyed":
+      console.log(chalk9.gray(`   \u251C\u2500 Destroying ${message.role}... \u2713`));
+      break;
+    case "session-complete":
+      console.log("");
+      console.log(chalk9.green.bold("\u2728 Council session complete!"));
+      console.log("");
+      onExit();
+      break;
+    case "timeout":
+      console.log(chalk9.yellow("\n\u23F1\uFE0F  Discussion timeout reached"));
+      console.log(chalk9.gray("   The council needs your input to continue."));
+      break;
+    case "error":
+      if (currentSpinner) currentSpinner.fail();
+      console.log(chalk9.red(`
+\u274C Error: ${message.error}`));
+      onExit();
+      break;
+  }
+}
+function printRoundHeader(round) {
+  console.log(chalk9.cyan("\u2500".repeat(65)));
+  console.log(chalk9.cyan(`Round ${round} - Council Discussion`));
+  console.log(chalk9.cyan("\u2500".repeat(65)));
+}
+function formatResponse(content) {
+  const maxLength = 300;
+  if (content.length > maxLength) {
+    return content.substring(0, maxLength) + "...";
+  }
+  return content;
+}
+function printStats(stats) {
+  console.log(chalk9.blue.bold("\u2500".repeat(65)));
+  console.log(chalk9.blue.bold("\u{1F4CA} Session Statistics"));
+  console.log(chalk9.blue.bold("\u2500".repeat(65)));
+  console.log("");
+  console.log(chalk9.gray(`   Council members: ${stats.members || 0}`));
+  console.log(chalk9.gray(`   Discussion rounds: ${stats.rounds || 0}`));
+  console.log(chalk9.gray(`   Total time: ${stats.time || 0}s`));
+  console.log(chalk9.gray(`   API cost: $${(stats.cost || 0).toFixed(2)}`));
+  console.log(chalk9.gray(`   Lines of code: ${stats.linesOfCode || 0}`));
+  console.log("");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/cli/commands/usage.ts
+import chalk10 from "chalk";
+import prompts5 from "prompts";
+async function usageCommand(options = {}) {
+  const token = getToken();
+  if (!token) {
+    console.error(chalk10.red("\u274C Not authenticated"));
+    console.log(chalk10.dim("   Run"), chalk10.cyan("codmir login"), chalk10.dim("first"));
+    process.exit(1);
+  }
+  console.log(chalk10.bold("\n\u{1F4CA} API Usage & Billing\n"));
+  const baseUrl = getBaseUrl();
+  const month = options.month || (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+  try {
+    const response = await fetch(`${baseUrl}/api/keys`, {
+      headers: { "X-API-Key": token }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch API keys: ${response.status}`);
+    }
+    const { keys } = await response.json();
+    if (keys.length === 0) {
+      console.log(chalk10.yellow("\u26A0\uFE0F  No API keys found"));
+      console.log(chalk10.dim("   Create one at:"), chalk10.cyan("https://codmir.com/settings/api-keys"));
+      return;
+    }
+    console.log(chalk10.bold(`\u{1F4C5} Month: ${month}
+`));
+    let totalRequests = 0;
+    let totalAICalls = 0;
+    let totalTokens = 0;
+    let totalCostCents = 0;
+    for (const key of keys) {
+      const usage = key.monthlyUsage[0];
+      const costDollars = usage ? (usage.totalCostCents / 100).toFixed(2) : "0.00";
+      const tokenCount = Number(usage?.totalTokens || 0);
+      totalRequests += usage?.totalRequests || 0;
+      totalAICalls += usage?.totalAICalls || 0;
+      totalTokens += tokenCount;
+      totalCostCents += usage?.totalCostCents || 0;
+      console.log(chalk10.cyan.bold(`\u{1F511} ${key.name}`));
+      console.log(chalk10.dim(`   Key: ${key.keyPrefix}...`));
+      console.log(chalk10.dim(`   Scope: ${key.scope}`));
+      console.log();
+      console.log(chalk10.bold("   Usage:"));
+      console.log(chalk10.dim(`     Total Requests:  ${(usage?.totalRequests || 0).toLocaleString()}`));
+      console.log(chalk10.dim(`     AI Calls:        ${(usage?.totalAICalls || 0).toLocaleString()}`));
+      console.log(chalk10.dim(`     Tokens Used:     ${tokenCount.toLocaleString()}`));
+      const costColor = getCostColor(usage?.totalCostCents || 0);
+      console.log(chalk10.bold("   Cost:"));
+      console.log(costColor(`     This Month:      $${costDollars}`));
+      if (key.lastUsedAt) {
+        const lastUsed = new Date(key.lastUsedAt);
+        const daysAgo = Math.floor((Date.now() - lastUsed.getTime()) / (1e3 * 60 * 60 * 24));
+        console.log(chalk10.dim(`     Last Used:       ${lastUsed.toLocaleDateString()} (${daysAgo} days ago)`));
+      } else {
+        console.log(chalk10.dim("     Last Used:       Never"));
+      }
+      if (options.detailed && usage) {
+        console.log();
+        console.log(chalk10.bold("   Provider Breakdown:"));
+        if (usage.openaiTokens > 0) {
+          console.log(chalk10.dim(`     OpenAI:          ${Number(usage.openaiTokens).toLocaleString()} tokens ($${(usage.openaiCostCents / 100).toFixed(2)})`));
+        }
+        if (usage.anthropicTokens > 0) {
+          console.log(chalk10.dim(`     Anthropic:       ${Number(usage.anthropicTokens).toLocaleString()} tokens ($${(usage.anthropicCostCents / 100).toFixed(2)})`));
+        }
+        if (usage.localTokens > 0) {
+          console.log(chalk10.dim(`     Local:           ${Number(usage.localTokens).toLocaleString()} tokens (free)`));
+        }
+        if (usage.totalAnalyses > 0) {
+          console.log();
+          console.log(chalk10.bold("   Codebase Analysis:"));
+          console.log(chalk10.dim(`     Total Analyses:  ${usage.totalAnalyses}`));
+          console.log(chalk10.dim(`     Local:           ${usage.localAnalyses}`));
+          console.log(chalk10.dim(`     Deep (Railway):  ${usage.deepAnalyses} ($${(usage.railwayCostCents / 100).toFixed(2)})`));
+          console.log(chalk10.dim(`     Files Processed: ${Number(usage.filesProcessed).toLocaleString()}`));
+          console.log(chalk10.dim(`     Lines Processed: ${Number(usage.linesProcessed).toLocaleString()}`));
+        }
+      }
+      console.log();
+      console.log(chalk10.dim("   \u2500".repeat(50)));
+      console.log();
+    }
+    console.log(chalk10.bold.cyan("\u{1F4C8} Summary\n"));
+    console.log(chalk10.dim(`   Total Requests:  ${totalRequests.toLocaleString()}`));
+    console.log(chalk10.dim(`   AI Calls:        ${totalAICalls.toLocaleString()}`));
+    console.log(chalk10.dim(`   Tokens Used:     ${totalTokens.toLocaleString()}`));
+    console.log();
+    console.log(chalk10.bold.green(`   Total Cost:      $${(totalCostCents / 100).toFixed(2)}`));
+    console.log();
+    if (totalCostCents > 5e3) {
+      console.log(chalk10.yellow("   \u26A0\uFE0F  High usage detected this month"));
+      console.log(chalk10.dim("   Consider optimizing AI calls or using local mode"));
+      console.log();
+    }
+    if (!options.detailed && keys.length > 0) {
+      console.log(chalk10.dim("   \u{1F4A1} Tip: Use"), chalk10.cyan("--detailed"), chalk10.dim("for provider breakdown"));
+    }
+    console.log(chalk10.dim("   \u{1F4C5} View other months:"), chalk10.cyan("codmir usage --month 2025-01"));
+    console.log();
+  } catch (error) {
+    console.error(chalk10.red("\n\u274C Failed to get usage stats"));
+    console.error(chalk10.dim("   Error:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+function getCostColor(costCents) {
+  if (costCents === 0) return chalk10.dim;
+  if (costCents < 100) return chalk10.green;
+  if (costCents < 1e3) return chalk10.yellow;
+  return chalk10.red;
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("codmir").description("codmir CLI - the AI that prevents wasted engineering time").version("0.1.0");
@@ -472,7 +1429,21 @@ program.command("link").description("Link current directory to a codmir project"
 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.command("projects").alias("ls").description("List all your projects").action(projectsCommand);
+program.command("ticket").alias("create").description("\u{1F3AB} Create a new ticket with interactive navigation").action(createTicketCommand);
+program.command("codmir [query...]").alias("ai").description("\u{1F916} AI assistant for developers").option("-p, --project <id>", "Include project context").option("-c, --context", "Include current directory context").option("-m, --model <name>", "AI model to use (default: gpt-4-turbo-preview)").action((query, options) => {
+  const queryString = query ? query.join(" ") : void 0;
+  assistantCommand(queryString, options);
+});
+program.command("ask <query...>").description("Quick AI query without interactive mode").option("-p, --project <id>", "Include project context").action((query, options) => {
+  quickQueryCommand(query.join(" "), options);
+});
+program.command("analyze").description("\u{1F50D} Analyze codebase and generate knowledge base").option("--full", "Run full deep analysis").option("--force", "Force re-analysis even if knowledge base exists").option("--mode <mode>", "Analysis mode: local or railway").action(analyzeCommand);
+program.command("usage").description("\u{1F4CA} View API usage and billing stats").option("--month <YYYY-MM>", "Month to view (default: current month)").option("--detailed", "Show detailed provider breakdown").action(usageCommand);
+program.command("council [task...]").description("\u{1F3AD} Assemble a council of Claude AI agents to collaborate on complex tasks").option("-m, --members <count>", "Number of initial council members (2-4)", "2").option("-t, --timeout <seconds>", "Max discussion time in seconds", "300").option("--local", "Run on local LAN cluster instead of Lambda").action((task, options) => {
+  const taskString = task ? task.join(" ") : void 0;
+  councilCommand(taskString, options);
+});
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();