codmir 0.3.2 → 0.4.0

package/dist/cli/index.js

@@ -6,6 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,20 +33,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli/index.ts
-var import_commander = require("commander");
-
-// src/cli/utils/auth.ts
-var import_open = __toESM(require("open"));
-var readline = __toESM(require("readline"));
-
 // 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 });
@@ -99,8 +96,836 @@ function isAuthenticated() {
   const token = getToken();
   return !!token;
 }
+function getBaseUrl() {
+  if (process.env.CODMIR_API_URL) {
+    return process.env.CODMIR_API_URL.replace(/\/$/, "");
+  }
+  const config = readConfig();
+  if (config.baseUrl) {
+    return config.baseUrl.replace(/\/$/, "");
+  }
+  return "https://codmir.com";
+}
+function getProjectConfig() {
+  return readProjectConfig();
+}
+function getExecutionContext() {
+  const projectConfig = readProjectConfig();
+  const isLinkedProject = projectConfig !== null;
+  return {
+    mode: isLinkedProject ? "local" : "global",
+    isLinkedProject,
+    projectConfig: projectConfig || void 0,
+    workingDirectory: process.cwd()
+  };
+}
+var import_fs, import_path, import_os, CONFIG_DIR, CONFIG_FILE, PROJECT_CONFIG_FILE;
+var init_config = __esm({
+  "src/cli/utils/config.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_os = __toESM(require("os"));
+    CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".codmir");
+    CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+    PROJECT_CONFIG_FILE = ".codmir.json";
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "codmir",
+      version: "0.4.0",
+      description: "Official codmir SDK - AI that prevents wasted engineering time. CLI, SDK, voice assistant, codebase analysis, 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"
+        },
+        "./voice-agent": {
+          types: "./dist/voice-agent/index.d.ts",
+          require: "./dist/voice-agent/index.js",
+          import: "./dist/voice-agent/index.mjs"
+        },
+        "./voice-daemon": {
+          types: "./dist/voice-daemon/index.d.ts",
+          require: "./dist/voice-daemon/index.js",
+          import: "./dist/voice-daemon/index.mjs"
+        }
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "runkit-example.js"
+      ],
+      scripts: {
+        build: "tsup src/index.ts src/cli/index.ts src/voice-agent/index.ts src/voice-daemon/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",
+        "voice-assistant",
+        "speech-recognition",
+        "voice-daemon",
+        "wake-word"
+      ],
+      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",
+        "@types/ws": "^8.18.1",
+        "@types/blessed": "^0.1.25",
+        "conventional-changelog-conventionalcommits": "^8.0.0",
+        "semantic-release": "^24.0.0",
+        tsup: "^8.0.1",
+        typescript: "^5.8.3"
+      },
+      dependencies: {
+        blessed: "^0.1.81",
+        "blessed-contrib": "^4.11.0",
+        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/utils/codebase-analyzer/local.ts
+async function analyzeLocal(projectPath) {
+  const startTime = Date.now();
+  const [structure, techStack, entryPoints, documentation, metadata] = await Promise.all([
+    buildFileTree(projectPath),
+    detectTechStack(projectPath),
+    findEntryPoints(projectPath),
+    extractDocumentation(projectPath),
+    collectMetadata(projectPath)
+  ]);
+  const analysis = {
+    structure,
+    techStack,
+    entryPoints,
+    documentation,
+    metadata,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const duration = Date.now() - startTime;
+  console.log(`Analysis complete in ${duration}ms`);
+  return analysis;
+}
+async function buildFileTree(projectPath) {
+  const stats = import_fs3.default.statSync(projectPath);
+  const name = import_path3.default.basename(projectPath);
+  if (!stats.isDirectory()) {
+    return {
+      name,
+      path: projectPath,
+      type: "file",
+      size: stats.size,
+      extension: import_path3.default.extname(projectPath)
+    };
+  }
+  const children = [];
+  const entries = import_fs3.default.readdirSync(projectPath);
+  for (const entry of entries) {
+    if (shouldIgnore(entry)) continue;
+    const fullPath = import_path3.default.join(projectPath, entry);
+    try {
+      const childNode = await buildFileTree(fullPath);
+      children.push(childNode);
+    } catch (error) {
+      continue;
+    }
+  }
+  return {
+    name,
+    path: projectPath,
+    type: "directory",
+    children: children.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "directory" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    })
+  };
+}
+async function detectTechStack(projectPath) {
+  const techStack = {
+    languages: {},
+    frameworks: [],
+    libraries: [],
+    tools: [],
+    packageManager: null
+  };
+  if (import_fs3.default.existsSync(import_path3.default.join(projectPath, "pnpm-lock.yaml"))) {
+    techStack.packageManager = "pnpm";
+  } else if (import_fs3.default.existsSync(import_path3.default.join(projectPath, "yarn.lock"))) {
+    techStack.packageManager = "yarn";
+  } else if (import_fs3.default.existsSync(import_path3.default.join(projectPath, "package-lock.json"))) {
+    techStack.packageManager = "npm";
+  } else if (import_fs3.default.existsSync(import_path3.default.join(projectPath, "bun.lockb"))) {
+    techStack.packageManager = "bun";
+  }
+  const files = await (0, import_glob.glob)("**/*", {
+    cwd: projectPath,
+    ignore: IGNORE_PATTERNS,
+    nodir: true
+  });
+  const languageCounts = {};
+  let totalCodeFiles = 0;
+  for (const file of files) {
+    const ext = import_path3.default.extname(file);
+    const language = LANGUAGE_EXTENSIONS[ext];
+    if (language) {
+      languageCounts[language] = (languageCounts[language] || 0) + 1;
+      totalCodeFiles++;
+    }
+  }
+  for (const [language, count] of Object.entries(languageCounts)) {
+    techStack.languages[language] = parseFloat(
+      (count / totalCodeFiles * 100).toFixed(1)
+    );
+  }
+  const packageJsonPath = import_path3.default.join(projectPath, "package.json");
+  if (import_fs3.default.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(import_fs3.default.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (dependencies["next"]) techStack.frameworks.push("Next.js");
+    if (dependencies["react"]) techStack.frameworks.push("React");
+    if (dependencies["vue"]) techStack.frameworks.push("Vue");
+    if (dependencies["svelte"]) techStack.frameworks.push("Svelte");
+    if (dependencies["express"]) techStack.frameworks.push("Express");
+    if (dependencies["fastify"]) techStack.frameworks.push("Fastify");
+    if (dependencies["nestjs"]) techStack.frameworks.push("NestJS");
+    if (dependencies["@remix-run/react"]) techStack.frameworks.push("Remix");
+    if (dependencies["gatsby"]) techStack.frameworks.push("Gatsby");
+    if (dependencies["nuxt"]) techStack.frameworks.push("Nuxt");
+    if (dependencies["prisma"]) techStack.libraries.push("Prisma");
+    if (dependencies["@tanstack/react-query"]) techStack.libraries.push("TanStack Query");
+    if (dependencies["tailwindcss"]) techStack.libraries.push("Tailwind CSS");
+    if (dependencies["shadcn/ui"]) techStack.libraries.push("shadcn/ui");
+    if (dependencies["zod"]) techStack.libraries.push("Zod");
+    if (dependencies["react-hook-form"]) techStack.libraries.push("React Hook Form");
+    if (dependencies["typescript"]) techStack.tools.push("TypeScript");
+    if (dependencies["eslint"]) techStack.tools.push("ESLint");
+    if (dependencies["prettier"]) techStack.tools.push("Prettier");
+    if (dependencies["jest"]) techStack.tools.push("Jest");
+    if (dependencies["vitest"]) techStack.tools.push("Vitest");
+    if (dependencies["playwright"]) techStack.tools.push("Playwright");
+  }
+  return techStack;
+}
+async function findEntryPoints(projectPath) {
+  const entryPoints = [];
+  const packageJsonPath = import_path3.default.join(projectPath, "package.json");
+  if (import_fs3.default.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(import_fs3.default.readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.scripts) {
+      for (const [name, script] of Object.entries(packageJson.scripts)) {
+        entryPoints.push({
+          type: "script",
+          name,
+          path: "package.json",
+          description: script
+        });
+      }
+    }
+    if (packageJson.main) {
+      entryPoints.push({
+        type: "main",
+        name: "main",
+        path: packageJson.main,
+        description: "Main entry point"
+      });
+    }
+  }
+  const commonEntries = [
+    "src/index.ts",
+    "src/index.js",
+    "src/main.ts",
+    "src/main.js",
+    "src/app/page.tsx",
+    "src/app/layout.tsx",
+    "app/page.tsx",
+    "app/layout.tsx",
+    "pages/index.tsx",
+    "pages/index.js",
+    "pages/_app.tsx",
+    "pages/_app.js"
+  ];
+  for (const entry of commonEntries) {
+    const fullPath = import_path3.default.join(projectPath, entry);
+    if (import_fs3.default.existsSync(fullPath)) {
+      entryPoints.push({
+        type: entry.includes("page") ? "page" : "main",
+        name: import_path3.default.basename(entry),
+        path: entry,
+        description: getEntryDescription(entry)
+      });
+    }
+  }
+  return entryPoints;
+}
+async function extractDocumentation(projectPath) {
+  const documentation = [];
+  const docFiles = [
+    { pattern: "README.md", type: "readme" },
+    { pattern: "CHANGELOG.md", type: "changelog" },
+    { pattern: "CONTRIBUTING.md", type: "contributing" },
+    { pattern: "LICENSE", type: "license" },
+    { pattern: "LICENSE.md", type: "license" },
+    { pattern: "docs/**/*.md", type: "other" }
+  ];
+  for (const { pattern, type } of docFiles) {
+    const files = await (0, import_glob.glob)(pattern, {
+      cwd: projectPath,
+      nodir: true
+    });
+    for (const file of files) {
+      const fullPath = import_path3.default.join(projectPath, file);
+      const content = import_fs3.default.readFileSync(fullPath, "utf-8");
+      documentation.push({
+        type,
+        path: file,
+        title: extractTitle(content),
+        content: content.substring(0, 1e3)
+        // First 1000 chars
+      });
+    }
+  }
+  return documentation;
+}
+async function collectMetadata(projectPath) {
+  const metadata = {
+    name: import_path3.default.basename(projectPath),
+    totalFiles: 0,
+    totalLines: 0
+  };
+  const packageJsonPath = import_path3.default.join(projectPath, "package.json");
+  if (import_fs3.default.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(import_fs3.default.readFileSync(packageJsonPath, "utf-8"));
+    metadata.name = packageJson.name || metadata.name;
+    metadata.version = packageJson.version;
+    metadata.description = packageJson.description;
+    metadata.author = packageJson.author;
+    metadata.license = packageJson.license;
+    metadata.scripts = packageJson.scripts;
+    if (packageJson.repository) {
+      metadata.repository = typeof packageJson.repository === "string" ? packageJson.repository : packageJson.repository.url;
+    }
+  }
+  const files = await (0, import_glob.glob)("**/*", {
+    cwd: projectPath,
+    ignore: IGNORE_PATTERNS,
+    nodir: true
+  });
+  metadata.totalFiles = files.length;
+  for (const file of files) {
+    const ext = import_path3.default.extname(file);
+    if (LANGUAGE_EXTENSIONS[ext]) {
+      const fullPath = import_path3.default.join(projectPath, file);
+      const content = import_fs3.default.readFileSync(fullPath, "utf-8");
+      metadata.totalLines += content.split("\n").length;
+    }
+  }
+  const gitPath = import_path3.default.join(projectPath, ".git");
+  if (import_fs3.default.existsSync(gitPath)) {
+    try {
+      const headPath = import_path3.default.join(gitPath, "HEAD");
+      const head = import_fs3.default.readFileSync(headPath, "utf-8").trim();
+      metadata.gitBranch = head.replace("ref: refs/heads/", "");
+    } catch {
+    }
+  }
+  return metadata;
+}
+function shouldIgnore(name) {
+  const ignoreList = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+    ".cache",
+    "tmp",
+    ".turbo",
+    ".vercel",
+    ".DS_Store"
+  ];
+  return ignoreList.includes(name) || name.startsWith(".");
+}
+function getEntryDescription(entryPath) {
+  if (entryPath.includes("layout")) return "Root layout component";
+  if (entryPath.includes("page")) return "Page component";
+  if (entryPath.includes("_app")) return "App component";
+  if (entryPath.includes("index")) return "Main entry point";
+  return "Entry file";
+}
+function extractTitle(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      return line.substring(2).trim();
+    }
+  }
+  return void 0;
+}
+var import_fs3, import_path3, import_glob, IGNORE_PATTERNS, LANGUAGE_EXTENSIONS;
+var init_local = __esm({
+  "src/cli/utils/codebase-analyzer/local.ts"() {
+    "use strict";
+    import_fs3 = __toESM(require("fs"));
+    import_path3 = __toESM(require("path"));
+    import_glob = require("glob");
+    IGNORE_PATTERNS = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/coverage/**",
+      "**/.cache/**",
+      "**/tmp/**",
+      "**/.turbo/**",
+      "**/.vercel/**"
+    ];
+    LANGUAGE_EXTENSIONS = {
+      ".ts": "TypeScript",
+      ".tsx": "TypeScript",
+      ".js": "JavaScript",
+      ".jsx": "JavaScript",
+      ".py": "Python",
+      ".rb": "Ruby",
+      ".go": "Go",
+      ".rs": "Rust",
+      ".java": "Java",
+      ".kt": "Kotlin",
+      ".swift": "Swift",
+      ".php": "PHP",
+      ".cs": "C#",
+      ".cpp": "C++",
+      ".c": "C",
+      ".css": "CSS",
+      ".scss": "SCSS",
+      ".sass": "Sass",
+      ".html": "HTML",
+      ".vue": "Vue",
+      ".svelte": "Svelte",
+      ".sql": "SQL",
+      ".sh": "Shell",
+      ".yaml": "YAML",
+      ".yml": "YAML",
+      ".json": "JSON",
+      ".md": "Markdown"
+    };
+  }
+});
+
+// src/cli/utils/knowledge-base/storage.ts
+function getKnowledgeBaseDir(projectPath) {
+  return import_path4.default.join(projectPath, KNOWLEDGE_BASE_DIR);
+}
+function ensureKnowledgeBaseDir(projectPath) {
+  const kbDir = getKnowledgeBaseDir(projectPath);
+  if (!import_fs4.default.existsSync(kbDir)) {
+    import_fs4.default.mkdirSync(kbDir, { recursive: true });
+  }
+}
+function saveKnowledgeBase(projectPath, knowledgeBase) {
+  ensureKnowledgeBaseDir(projectPath);
+  const kbDir = getKnowledgeBaseDir(projectPath);
+  const indexPath = import_path4.default.join(kbDir, INDEX_FILE);
+  import_fs4.default.writeFileSync(indexPath, JSON.stringify(knowledgeBase, null, 2));
+  if (knowledgeBase.localAnalysis) {
+    saveComponent(kbDir, "local-analysis.json", knowledgeBase.localAnalysis);
+  }
+}
+function loadKnowledgeBase(projectPath) {
+  const indexPath = import_path4.default.join(projectPath, KNOWLEDGE_BASE_DIR, INDEX_FILE);
+  if (!import_fs4.default.existsSync(indexPath)) {
+    return null;
+  }
+  try {
+    const content = import_fs4.default.readFileSync(indexPath, "utf-8");
+    const knowledgeBase = JSON.parse(content);
+    const kbDir = getKnowledgeBaseDir(projectPath);
+    if (knowledgeBase.analysisType === "local") {
+      const localAnalysisPath = import_path4.default.join(kbDir, "local-analysis.json");
+      if (import_fs4.default.existsSync(localAnalysisPath)) {
+        knowledgeBase.localAnalysis = JSON.parse(
+          import_fs4.default.readFileSync(localAnalysisPath, "utf-8")
+        );
+      }
+    }
+    return knowledgeBase;
+  } catch (error) {
+    console.error("Error loading knowledge base:", error);
+    return null;
+  }
+}
+function hasKnowledgeBase(projectPath) {
+  const indexPath = import_path4.default.join(projectPath, KNOWLEDGE_BASE_DIR, INDEX_FILE);
+  return import_fs4.default.existsSync(indexPath);
+}
+function getKnowledgeBaseStats(projectPath) {
+  const kb = loadKnowledgeBase(projectPath);
+  if (!kb) {
+    return null;
+  }
+  return {
+    version: kb.version,
+    analyzedAt: kb.analyzedAt,
+    analysisType: kb.analysisType,
+    totalFiles: kb.localAnalysis?.metadata.totalFiles || 0,
+    totalLines: kb.localAnalysis?.metadata.totalLines || 0,
+    languages: kb.localAnalysis?.techStack.languages || {},
+    frameworks: kb.localAnalysis?.techStack.frameworks || []
+  };
+}
+function saveComponent(kbDir, filename, data) {
+  const filePath = import_path4.default.join(kbDir, filename);
+  import_fs4.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+function initializeKnowledgeBase(projectPath, projectId, projectName, localAnalysis) {
+  const knowledgeBase = {
+    version: "1.0.0",
+    projectId,
+    projectName,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    analysisType: "local",
+    localAnalysis,
+    queries: {}
+  };
+  saveKnowledgeBase(projectPath, knowledgeBase);
+  return knowledgeBase;
+}
+var import_fs4, import_path4, KNOWLEDGE_BASE_DIR, INDEX_FILE;
+var init_storage = __esm({
+  "src/cli/utils/knowledge-base/storage.ts"() {
+    "use strict";
+    import_fs4 = __toESM(require("fs"));
+    import_path4 = __toESM(require("path"));
+    KNOWLEDGE_BASE_DIR = ".codmir/knowledge";
+    INDEX_FILE = "index.json";
+  }
+});
+
+// src/cli/commands/analyze.ts
+var analyze_exports = {};
+__export(analyze_exports, {
+  analyzeCommand: () => analyzeCommand
+});
+async function analyzeCommand(options = {}) {
+  console.log(import_chalk4.default.bold("\n\u{1F50D} Codebase Analysis\n"));
+  const projectConfig = getProjectConfig();
+  if (!projectConfig) {
+    console.error(import_chalk4.default.red("\u274C Project not linked"));
+    console.log(import_chalk4.default.dim("   Run"), import_chalk4.default.cyan("codmir link"), import_chalk4.default.dim("first"));
+    process.exit(1);
+  }
+  const projectPath = process.cwd();
+  const existingKB = hasKnowledgeBase(projectPath);
+  if (existingKB && !options.force) {
+    const stats = getKnowledgeBaseStats(projectPath);
+    console.log(import_chalk4.default.yellow("\u26A0\uFE0F  Knowledge base already exists"));
+    console.log(import_chalk4.default.dim(`   Last analyzed: ${new Date(stats.analyzedAt).toLocaleString()}`));
+    console.log(import_chalk4.default.dim(`   Files: ${stats.totalFiles}, Lines: ${stats.totalLines}`));
+    const { reanalyze } = await (0, import_prompts.default)({
+      type: "confirm",
+      name: "reanalyze",
+      message: "Re-analyze codebase?",
+      initial: false
+    });
+    if (!reanalyze) {
+      console.log(import_chalk4.default.dim("\n   Use"), import_chalk4.default.cyan("--force"), import_chalk4.default.dim("to force re-analysis"));
+      return;
+    }
+  }
+  let analysisMode = options.mode || "local";
+  if (!options.mode) {
+    const { mode } = await (0, import_prompts.default)({
+      type: "select",
+      name: "mode",
+      message: "Choose analysis mode",
+      choices: [
+        {
+          title: "\u{1F4BB} Local (Quick)",
+          value: "local",
+          description: "Fast structural analysis (1-5 seconds)"
+        },
+        {
+          title: "\u{1F682} Railway (Deep)",
+          value: "railway",
+          description: "Comprehensive analysis with embeddings (~2 minutes)"
+        }
+      ],
+      initial: 0
+    });
+    analysisMode = mode;
+  }
+  if (analysisMode === "local") {
+    await runLocalAnalysis(projectPath, projectConfig.projectId, projectConfig.projectName);
+  } else {
+    await runRailwayAnalysis(projectPath, projectConfig.projectId);
+  }
+}
+async function runLocalAnalysis(projectPath, projectId, projectName) {
+  const spinner = (0, import_ora.default)({
+    text: import_chalk4.default.dim("Analyzing project structure..."),
+    color: "cyan"
+  }).start();
+  try {
+    const analysis = await analyzeLocal(projectPath);
+    spinner.text = import_chalk4.default.dim("Saving knowledge base...");
+    initializeKnowledgeBase(projectPath, projectId, projectName, analysis);
+    spinner.succeed(import_chalk4.default.green("Analysis complete!"));
+    console.log();
+    console.log(import_chalk4.default.bold("\u{1F4CA} Results:"));
+    console.log();
+    console.log(import_chalk4.default.dim("   Project:"), import_chalk4.default.cyan(projectName));
+    console.log(import_chalk4.default.dim("   Files:"), import_chalk4.default.white(analysis.metadata.totalFiles));
+    console.log(import_chalk4.default.dim("   Lines:"), import_chalk4.default.white(analysis.metadata.totalLines));
+    console.log();
+    if (Object.keys(analysis.techStack.languages).length > 0) {
+      console.log(import_chalk4.default.bold("\u{1F5E3}\uFE0F  Languages:"));
+      for (const [lang, percent] of Object.entries(analysis.techStack.languages)) {
+        const bar = createProgressBar(percent, 20);
+        console.log(`   ${import_chalk4.default.cyan(lang.padEnd(15))} ${bar} ${percent}%`);
+      }
+      console.log();
+    }
+    if (analysis.techStack.frameworks.length > 0) {
+      console.log(import_chalk4.default.bold("\u26A1 Frameworks:"));
+      analysis.techStack.frameworks.forEach((fw) => {
+        console.log(`   \u2022 ${import_chalk4.default.green(fw)}`);
+      });
+      console.log();
+    }
+    if (analysis.entryPoints.length > 0) {
+      console.log(import_chalk4.default.bold("\u{1F680} Entry Points:"));
+      analysis.entryPoints.slice(0, 5).forEach((ep) => {
+        console.log(`   \u2022 ${import_chalk4.default.yellow(ep.name)} ${import_chalk4.default.dim(`(${ep.path})`)}`);
+      });
+      if (analysis.entryPoints.length > 5) {
+        console.log(import_chalk4.default.dim(`   ... and ${analysis.entryPoints.length - 5} more`));
+      }
+      console.log();
+    }
+    if (analysis.documentation.length > 0) {
+      console.log(import_chalk4.default.bold("\u{1F4DA} Documentation:"));
+      analysis.documentation.forEach((doc) => {
+        const icon = getDocIcon(doc.type);
+        console.log(`   ${icon} ${import_chalk4.default.cyan(doc.path)}`);
+      });
+      console.log();
+    }
+    console.log(import_chalk4.default.dim("   Knowledge base saved to:"), import_chalk4.default.cyan(".codmir/knowledge/"));
+    console.log();
+    console.log(import_chalk4.default.dim("   Try:"), import_chalk4.default.cyan('codmir ai --context "Explain the project structure"'));
+    console.log();
+  } catch (error) {
+    spinner.fail(import_chalk4.default.red("Analysis failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function runRailwayAnalysis(projectPath, projectId) {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk4.default.red("\u274C Not authenticated"));
+    console.log(import_chalk4.default.dim("   Run"), import_chalk4.default.cyan("codmir login"), import_chalk4.default.dim("first"));
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const gitRemote = await getGitRemote(projectPath);
+  if (!gitRemote) {
+    console.error(import_chalk4.default.red("\u274C No git remote found"));
+    console.log(import_chalk4.default.dim("   Project must be a git repository with remote"));
+    process.exit(1);
+  }
+  console.log(import_chalk4.default.dim("   Repository:"), import_chalk4.default.cyan(gitRemote));
+  console.log();
+  const spinner = (0, import_ora.default)({
+    text: import_chalk4.default.dim("Starting Railway analysis..."),
+    color: "cyan"
+  }).start();
+  try {
+    const response = await fetch(`${baseUrl}/api/analysis/deep`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": token
+      },
+      body: JSON.stringify({
+        projectId,
+        repoUrl: gitRemote,
+        branch: await getGitBranch(projectPath)
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    const { jobId, estimatedTime } = await response.json();
+    spinner.text = import_chalk4.default.dim(`Analysis in progress (${estimatedTime})...`);
+    await pollAnalysisStatus(baseUrl, token, jobId, spinner);
+    spinner.succeed(import_chalk4.default.green("Deep analysis complete!"));
+    console.log();
+    console.log(import_chalk4.default.dim("   Knowledge base synced from Railway"));
+    console.log(import_chalk4.default.dim("   Includes:"));
+    console.log(import_chalk4.default.dim("     \u2022 Full AST parsing"));
+    console.log(import_chalk4.default.dim("     \u2022 Code embeddings"));
+    console.log(import_chalk4.default.dim("     \u2022 Best practices report"));
+    console.log(import_chalk4.default.dim("     \u2022 Generated documentation"));
+    console.log();
+  } catch (error) {
+    spinner.fail(import_chalk4.default.red("Railway analysis failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function pollAnalysisStatus(baseUrl, token, jobId, spinner) {
+  const maxAttempts = 120;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    const response = await fetch(`${baseUrl}/api/analysis/deep/${jobId}`, {
+      headers: { "X-API-Key": token }
+    });
+    const { status, progress } = await response.json();
+    spinner.text = import_chalk4.default.dim(`${status}... ${progress || ""}%`);
+    if (status === "complete") {
+      return;
+    }
+    if (status === "failed") {
+      throw new Error("Analysis failed on Railway");
+    }
+    attempts++;
+  }
+  throw new Error("Analysis timeout");
+}
+async function getGitRemote(projectPath) {
+  try {
+    const { execSync } = require("child_process");
+    const remote = execSync("git config --get remote.origin.url", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    return remote;
+  } catch {
+    return null;
+  }
+}
+async function getGitBranch(projectPath) {
+  try {
+    const { execSync } = require("child_process");
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    }).trim();
+    return branch;
+  } catch {
+    return "main";
+  }
+}
+function createProgressBar(percent, width) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return import_chalk4.default.cyan("\u2588".repeat(filled)) + import_chalk4.default.dim("\u2591".repeat(empty));
+}
+function getDocIcon(type) {
+  const icons = {
+    readme: "\u{1F4D6}",
+    changelog: "\u{1F4DD}",
+    contributing: "\u{1F91D}",
+    license: "\u2696\uFE0F",
+    other: "\u{1F4C4}"
+  };
+  return icons[type] || "\u{1F4C4}";
+}
+var import_chalk4, import_ora, import_prompts;
+var init_analyze = __esm({
+  "src/cli/commands/analyze.ts"() {
+    "use strict";
+    import_chalk4 = __toESM(require("chalk"));
+    import_ora = __toESM(require("ora"));
+    import_prompts = __toESM(require("prompts"));
+    init_config();
+    init_local();
+    init_storage();
+  }
+});
+
+// src/cli/index.ts
+var import_commander = require("commander");
 
 // src/cli/utils/auth.ts
+var import_open = __toESM(require("open"));
+var readline = __toESM(require("readline"));
+init_config();
 function promptForToken() {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
@@ -142,7 +967,8 @@ async function startOAuthFlow(baseUrl = "https://codmir.com") {
     if (!userResponse.ok) {
       throw new Error("Invalid token or authentication failed");
     }
-    const user = await userResponse.json();
+    const response = await userResponse.json();
+    const user = response.data || response;
     return {
       token,
       user: {
@@ -166,7 +992,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: {
@@ -189,6 +1016,7 @@ function saveAuth(authResult) {
 }
 
 // src/cli/commands/login.ts
+init_config();
 var import_chalk = __toESM(require("chalk"));
 async function loginCommand(options) {
   if (isAuthenticated()) {
@@ -201,11 +1029,16 @@ async function loginCommand(options) {
   console.log(import_chalk.default.dim("   Authenticate to start using codmir CLI\n"));
   try {
     let authResult;
+    const baseUrl = getBaseUrl();
+    if (baseUrl !== "https://codmir.com") {
+      console.log(import_chalk.default.dim(`   Connecting to: ${baseUrl}
+`));
+    }
     if (options.token) {
       console.log(import_chalk.default.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(import_chalk.default.green("\n\u2705 Successfully logged in!"));
@@ -218,6 +1051,42 @@ async function loginCommand(options) {
   }
 }
 
+// src/cli/commands/logout.ts
+init_config();
+var import_chalk2 = __toESM(require("chalk"));
+async function logoutCommand() {
+  if (!isAuthenticated()) {
+    console.log(import_chalk2.default.yellow("\u26A0\uFE0F  Not logged in"));
+    return;
+  }
+  const config = readConfig();
+  clearConfig();
+  console.log(import_chalk2.default.green("\u2705 Successfully logged out"));
+  if (config.email) {
+    console.log(import_chalk2.default.dim("   Goodbye,"), import_chalk2.default.bold(config.email));
+  }
+}
+
+// src/cli/commands/whoami.ts
+init_config();
+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/client.ts
 var CodmirClient = class {
   constructor(config) {
@@ -229,12 +1098,13 @@ var CodmirClient = class {
     };
     this.tickets = new TicketsAPI(this.config);
     this.testCases = new TestCasesAPI(this.config);
+    this.testing = new TestingAPI(this.config);
   }
   /**
    * Make an HTTP request to the codmir API
    */
-  async request(method, path3, body) {
-    const url = `${this.config.baseUrl}${path3}`;
+  async request(method, path8, body) {
+    const url = `${this.config.baseUrl}${path8}`;
     const headers = {
       "Content-Type": "application/json",
       ...this.config.headers
@@ -291,8 +1161,8 @@ var TicketsAPI = class {
   constructor(config) {
     this.config = config;
   }
-  async request(method, path3, body) {
-    const url = `${this.config.baseUrl}${path3}`;
+  async request(method, path8, body) {
+    const url = `${this.config.baseUrl}${path8}`;
     const headers = {
       "Content-Type": "application/json",
       ...this.config.headers
@@ -371,8 +1241,8 @@ var TestCasesAPI = class {
   constructor(config) {
     this.config = config;
   }
-  async request(method, path3, body) {
-    const url = `${this.config.baseUrl}${path3}`;
+  async request(method, path8, body) {
+    const url = `${this.config.baseUrl}${path8}`;
     const headers = {
       "Content-Type": "application/json",
       ...this.config.headers
@@ -487,61 +1357,200 @@ var TestCasesAPI = class {
     );
   }
 };
-
-// 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);
+var TestingAPI = class {
+  constructor(config) {
+    this.config = config;
   }
-  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;
+  async request(method, path8, body) {
+    const url = `${this.config.baseUrl}${path8}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
     }
-  }
-  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 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;
     }
-    const projects = await response.json();
+  }
+  async submitTestRun(payload) {
+    return this.request("POST", "/api/testing/test-runs", payload);
+  }
+  async listTestRuns(projectId, options) {
+    const params = new URLSearchParams({ projectId });
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.suite) params.set("suite", options.suite);
+    const response = await this.request(
+      "GET",
+      `/api/testing/test-runs?${params.toString()}`
+    );
+    return response.runs || [];
+  }
+  async requestCoverageInsight(payload) {
+    return this.request("POST", "/api/testing/coverage-insight", payload);
+  }
+  async listCoverageInsights(projectId, limit = 5) {
+    const params = new URLSearchParams({ projectId, limit: String(limit) });
+    const response = await this.request(
+      "GET",
+      `/api/testing/coverage-insight?${params.toString()}`
+    );
+    return response.reports || [];
+  }
+};
+
+// src/cli/commands/link.ts
+var import_prompts2 = __toESM(require("prompts"));
+var import_chalk5 = __toESM(require("chalk"));
+init_config();
+
+// src/cli/utils/machine-id.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var import_crypto = __toESM(require("crypto"));
+init_config();
+var MACHINE_ID_FILE = import_path2.default.join(import_os2.default.homedir(), ".codmir", "machine-id");
+function getMachineId() {
+  ensureConfigDir();
+  if (import_fs2.default.existsSync(MACHINE_ID_FILE)) {
+    try {
+      return import_fs2.default.readFileSync(MACHINE_ID_FILE, "utf-8").trim();
+    } catch (error) {
+      console.error("Error reading machine ID:", error);
+    }
+  }
+  const machineId = import_crypto.default.randomBytes(16).toString("hex");
+  try {
+    import_fs2.default.writeFileSync(MACHINE_ID_FILE, machineId);
+  } catch (error) {
+    console.error("Error saving machine ID:", error);
+  }
+  return machineId;
+}
+function getMachineInfo() {
+  return {
+    machineId: getMachineId(),
+    hostname: import_os2.default.hostname(),
+    platform: import_os2.default.platform(),
+    arch: import_os2.default.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(import_chalk5.default.red("\u274C Not authenticated"));
+    console.log(import_chalk5.default.dim("   Run"), import_chalk5.default.cyan("codmir login"), import_chalk5.default.dim("first"));
+    process.exit(1);
+  }
+  console.log(import_chalk5.default.bold("\n\u{1F517} codmir link"));
+  console.log(import_chalk5.default.dim("   Link this directory to a codmir project\n"));
+  const existing = readProjectConfig();
+  if (existing) {
+    console.log(import_chalk5.default.yellow("\u26A0\uFE0F  This directory is already linked to:"));
+    console.log(import_chalk5.default.dim("   Project ID:"), import_chalk5.default.bold(existing.projectId));
+    if (existing.projectName) {
+      console.log(import_chalk5.default.dim("   Project:"), import_chalk5.default.bold(existing.projectName));
+    }
+    const { overwrite } = await (0, import_prompts2.default)({
+      type: "confirm",
+      name: "overwrite",
+      message: "Do you want to overwrite this configuration?",
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(import_chalk5.default.dim("   Cancelled"));
+      return;
+    }
+  }
+  try {
+    const baseUrl = getBaseUrl();
+    const client = new CodmirClient({
+      apiKey: token,
+      baseUrl
+    });
+    let projectId = options.project;
+    let orgId = options.org;
+    console.log(import_chalk5.default.dim("   Fetching your projects...\n"));
+    const response = await fetch(`${baseUrl}/api/projects`, {
+      headers: {
+        "X-API-Key": token
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch projects");
+    }
+    const responseData = await response.json();
+    const projects = responseData.data || responseData;
     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"));
+        console.log(import_chalk5.default.yellow("\u26A0\uFE0F  You don't have any projects yet"));
+        console.log(import_chalk5.default.dim("   Create a project at"), import_chalk5.default.cyan("https://codmir.com"));
         process.exit(1);
       }
-      const { selectedProject } = await (0, import_prompts.default)({
+      const { selectedProject } = await (0, import_prompts2.default)({
         type: "select",
         name: "selectedProject",
         message: "Select a project to link:",
@@ -552,14 +1561,14 @@ async function linkCommand(options) {
         }))
       });
       if (!selectedProject) {
-        console.log(import_chalk2.default.dim("   Cancelled"));
+        console.log(import_chalk5.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"));
+      console.error(import_chalk5.default.red("\u274C Project not found"));
       process.exit(1);
     }
     writeProjectConfig({
@@ -567,67 +1576,52 @@ async function linkCommand(options) {
       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"));
+    console.log(import_chalk5.default.green("\n\u2705 Successfully linked!"));
+    console.log(import_chalk5.default.dim("   Project:"), import_chalk5.default.bold(project.name));
+    console.log(import_chalk5.default.dim("   ID:"), import_chalk5.default.bold(project.id));
+    console.log(import_chalk5.default.dim("\n   Configuration saved to"), import_chalk5.default.cyan(".codmir.json"));
+    console.log(import_chalk5.default.dim("   You can now use the codmir package in your project"));
+    await registerMachine(project.id, token, baseUrl);
+    console.log();
+    const { analyze } = await (0, import_prompts2.default)({
+      type: "confirm",
+      name: "analyze",
+      message: "Analyze codebase now? (Recommended)",
+      initial: true
+    });
+    if (analyze) {
+      console.log();
+      const { analyzeCommand: analyzeCommand2 } = await Promise.resolve().then(() => (init_analyze(), analyze_exports));
+      await analyzeCommand2({ mode: "local" });
+    } else {
+      console.log();
+      console.log(import_chalk5.default.dim("   You can analyze later with:"), import_chalk5.default.cyan("codmir analyze"));
+      console.log();
+    }
   } 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"));
+    console.log(import_chalk5.default.red("\n\u274C Failed to link project"));
+    console.log(import_chalk5.default.dim(error.message));
     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"));
+init_config();
+var import_chalk6 = __toESM(require("chalk"));
+var import_fs5 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
 async function initCommand() {
-  console.log(import_chalk5.default.bold("\n\u{1F389} Initialize codmir\n"));
+  console.log(import_chalk6.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"));
+    console.log(import_chalk6.default.yellow("\u26A0\uFE0F  Project not linked"));
+    console.log(import_chalk6.default.dim("   Run"), import_chalk6.default.cyan("codmir link"), import_chalk6.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"));
+  console.log(import_chalk6.default.dim("   Project:"), import_chalk6.default.bold(config.projectName || config.projectId));
+  const exampleFile = import_path5.default.join(process.cwd(), "codmir.example.ts");
+  if (import_fs5.default.existsSync(exampleFile)) {
+    console.log(import_chalk6.default.yellow("\n\u26A0\uFE0F  codmir.example.ts already exists"));
   } else {
     const example = `import { CodmirClient } from 'codmir';
 
@@ -669,56 +1663,920 @@ async function createTestCase() {
 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"));
+    import_fs5.default.writeFileSync(exampleFile, example);
+    console.log(import_chalk6.default.green("\n\u2705 Created"), import_chalk6.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"));
+  console.log(import_chalk6.default.bold("\n\u{1F4DA} Next Steps:\n"));
+  console.log(import_chalk6.default.dim("   1."), "Install the package:", import_chalk6.default.cyan("npm install codmir"));
+  console.log(import_chalk6.default.dim("   2."), "Get your API token from:", import_chalk6.default.cyan("https://codmir.com/settings/tokens"));
+  console.log(import_chalk6.default.dim("   3."), "Set environment variable:", import_chalk6.default.cyan("CODMIR_API_KEY=your-token"));
+  console.log(import_chalk6.default.dim("   4."), "Check", import_chalk6.default.cyan("codmir.example.ts"), "for usage examples");
+  console.log(import_chalk6.default.dim("\n   \u{1F4D6} Documentation:"), import_chalk6.default.cyan("https://codmir.com/docs"));
 }
 
 // src/cli/commands/projects.ts
-var import_chalk6 = __toESM(require("chalk"));
+init_config();
+var import_chalk7 = __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"));
+    console.error(import_chalk7.default.red("\u274C Not authenticated"));
+    console.log(import_chalk7.default.dim("   Run"), import_chalk7.default.cyan("codmir login"), import_chalk7.default.dim("first"));
     process.exit(1);
   }
-  console.log(import_chalk6.default.bold("\n\u{1F4C1} Your Projects\n"));
+  console.log(import_chalk7.default.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(import_chalk6.default.yellow("   No projects found"));
-      console.log(import_chalk6.default.dim("   Create one at"), import_chalk6.default.cyan("https://codmir.com"));
+      console.log(import_chalk7.default.yellow("   No projects found"));
+      console.log(import_chalk7.default.dim("   Create one at"), import_chalk7.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);
+      console.log(import_chalk7.default.bold(`   ${index + 1}. ${project.name}`), import_chalk7.default.dim(`(${project.key})`));
+      console.log(import_chalk7.default.dim("      ID:"), project.id);
       if (project.description) {
-        console.log(import_chalk6.default.dim("      Description:"), project.description);
+        console.log(import_chalk7.default.dim("      Description:"), project.description);
+      }
+      console.log("");
+    });
+    console.log(import_chalk7.default.dim("   Link a project:"), import_chalk7.default.cyan("codmir link"));
+  } catch (error) {
+    console.error(import_chalk7.default.red("\n\u274C Failed to fetch projects:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/assistant.ts
+var import_chalk8 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+var import_prompts3 = __toESM(require("prompts"));
+var import_clipboardy = __toESM(require("clipboardy"));
+var import_fs6 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_form_data = __toESM(require("form-data"));
+init_config();
+async function assistantCommand(query, options = {}) {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk8.default.red("\u274C Not authenticated"));
+    console.log(import_chalk8.default.dim("   Run"), import_chalk8.default.cyan("codmir login"), import_chalk8.default.dim("first"));
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const conversationHistory = [];
+  const context = getExecutionContext();
+  if (context.isLinkedProject) {
+    console.log(import_chalk8.default.dim(`   \u{1F4C1} Project: ${context.projectConfig?.projectName || context.projectConfig?.projectId}`));
+    console.log(import_chalk8.default.dim(`   \u{1F517} Mode: ${import_chalk8.default.cyan("local")} (linked project)
+`));
+  } else {
+    console.log(import_chalk8.default.dim(`   \u{1F310} Mode: ${import_chalk8.default.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(import_chalk8.default.bold("\n\u{1F916} codmir"));
+  console.log(import_chalk8.default.dim("   AI assistant for developers\n"));
+  if (query) {
+    await handleQuery(query, conversationHistory, baseUrl, token, options);
+    return;
+  }
+  console.log(import_chalk8.default.dim("   Type your question or"), import_chalk8.default.cyan("exit"), import_chalk8.default.dim("to quit"));
+  console.log(import_chalk8.default.dim("   \u{1F4CB} Tip: Copy images to clipboard before asking for automatic upload"));
+  console.log(import_chalk8.default.dim('   Example: "How do I setup authentication?"\n'));
+  while (true) {
+    const { userInput } = await (0, import_prompts3.default)({
+      type: "text",
+      name: "userInput",
+      message: import_chalk8.default.cyan("codmir"),
+      validate: (value) => value.length > 0 || "Please enter a question"
+    });
+    if (!userInput || userInput.toLowerCase() === "exit" || userInput.toLowerCase() === "quit") {
+      console.log(import_chalk8.default.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 (0, import_prompts3.default)({
+      type: "confirm",
+      name: "attachImage",
+      message: import_chalk8.default.cyan("\u{1F4CB} Image detected in clipboard. Attach to message?"),
+      initial: true
+    });
+    if (attachImage) {
+      const imagePath = await saveClipboardImage();
+      if (imagePath) {
+        imagePaths = [imagePath];
+        console.log(import_chalk8.default.green("   \u2713 Image attached from clipboard\n"));
+      }
+    }
+  }
+  conversationHistory.push({
+    role: "user",
+    content: query,
+    images: imagePaths
+  });
+  const spinner = (0, import_ora2.default)({
+    text: import_chalk8.default.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 import_form_data.default();
+      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", import_fs6.default.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(import_chalk8.default.red("\n\u274C Error:"), error instanceof Error ? error.message : "Unknown error");
+    console.log(import_chalk8.default.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} ${import_chalk8.default.white(line)}
+`;
+    } else {
+      output += `   ${import_chalk8.default.white(line)}
+`;
+    }
+  });
+  return output;
+}
+function getIndicator() {
+  const isDark = isTerminalDark();
+  if (isDark) {
+    return import_chalk8.default.whiteBright("\u25CF");
+  } else {
+    return import_chalk8.default.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(import_chalk8.default.red("\u274C Not authenticated"));
+    process.exit(1);
+  }
+  await handleQuery(query, conversationHistory, getBaseUrl(), token, options);
+}
+async function checkClipboardForImage() {
+  try {
+    const clipboardContent = await import_clipboardy.default.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 import_clipboardy.default.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 = import_path6.default.join("/tmp", `codmir-assistant-${Date.now()}.${ext}`);
+      import_fs6.default.writeFileSync(tmpPath, buffer);
+      return tmpPath;
+    }
+    if (import_fs6.default.existsSync(clipboardContent)) {
+      return clipboardContent;
+    }
+    return null;
+  } catch (error) {
+    console.error(import_chalk8.default.dim("   Failed to save clipboard image"));
+    return null;
+  }
+}
+
+// src/cli/commands/ticket.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_prompts4 = __toESM(require("prompts"));
+var import_clipboardy2 = __toESM(require("clipboardy"));
+var import_fs7 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_form_data2 = __toESM(require("form-data"));
+init_config();
+async function createTicketCommand() {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk9.default.red("\u274C Not authenticated"));
+    console.log(import_chalk9.default.dim("   Run"), import_chalk9.default.cyan("codmir login"), import_chalk9.default.dim("first"));
+    process.exit(1);
+  }
+  console.log(import_chalk9.default.bold("\n\u{1F3AB} Create Ticket\n"));
+  try {
+    const linkedProject = getProjectConfig();
+    let selectedProject = null;
+    let selectedOrg = null;
+    if (linkedProject) {
+      const { useLinked } = await (0, import_prompts4.default)({
+        type: "confirm",
+        name: "useLinked",
+        message: `Use linked project: ${import_chalk9.default.cyan(linkedProject.name)}?`,
+        initial: true
+      });
+      if (useLinked) {
+        selectedProject = linkedProject;
       }
+    }
+    if (!selectedProject) {
+      const selection = await navigateAndSelectProject(token);
+      if (!selection) {
+        console.log(import_chalk9.default.yellow("\n\u26A0\uFE0F  Cancelled"));
+        return;
+      }
+      selectedProject = selection.project;
+      selectedOrg = selection.organization;
+    }
+    console.log(import_chalk9.default.green("\n\u2713 Project:"), import_chalk9.default.cyan(selectedProject.name));
+    const ticketData = await collectTicketDetails();
+    if (!ticketData) {
+      console.log(import_chalk9.default.yellow("\n\u26A0\uFE0F  Cancelled"));
+      return;
+    }
+    const hasClipboardImage = await checkClipboardForImage2();
+    if (hasClipboardImage) {
+      const { attachImage } = await (0, import_prompts4.default)({
+        type: "confirm",
+        name: "attachImage",
+        message: import_chalk9.default.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(import_chalk9.default.green("\u2713 Image attached"));
+        }
+      }
+    }
+    await createTicket(token, selectedProject.id, ticketData);
+  } catch (error) {
+    console.error(import_chalk9.default.red("\n\u274C Error:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function navigateAndSelectProject(token) {
+  const baseUrl = getBaseUrl();
+  console.log(import_chalk9.default.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(import_chalk9.default.yellow("\n\u26A0\uFE0F  No organizations found"));
+    return null;
+  }
+  console.log(import_chalk9.default.bold("\n\u{1F579}\uFE0F  Select Organization"));
+  console.log(import_chalk9.default.dim("   Use \u2191\u2193 arrows to navigate, Enter to select\n"));
+  const { orgIndex } = await (0, import_prompts4.default)({
+    type: "select",
+    name: "orgIndex",
+    message: import_chalk9.default.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(import_chalk9.default.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(import_chalk9.default.yellow("\n\u26A0\uFE0F  No projects found in this organization"));
+    return null;
+  }
+  console.log(import_chalk9.default.bold("\n\u{1F579}\uFE0F  Select Project"));
+  console.log(import_chalk9.default.dim("   Use \u2191\u2193 arrows to navigate, Enter to select\n"));
+  const { projectIndex } = await (0, import_prompts4.default)({
+    type: "select",
+    name: "projectIndex",
+    message: import_chalk9.default.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 import_chalk9.default.cyan(indicators[index % indicators.length]);
+}
+async function collectTicketDetails() {
+  console.log(import_chalk9.default.bold("\n\u{1F4DD} Ticket Details\n"));
+  const responses = await (0, import_prompts4.default)([
+    {
+      type: "text",
+      name: "title",
+      message: import_chalk9.default.cyan("Title"),
+      validate: (value) => value.length > 0 || "Title is required"
+    },
+    {
+      type: "text",
+      name: "description",
+      message: import_chalk9.default.cyan("Description"),
+      initial: ""
+    },
+    {
+      type: "select",
+      name: "type",
+      message: import_chalk9.default.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: import_chalk9.default.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 import_clipboardy2.default.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 import_clipboardy2.default.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 = import_path7.default.join("/tmp", `codmir-ticket-${Date.now()}.${ext}`);
+      import_fs7.default.writeFileSync(tmpPath, buffer);
+      return tmpPath;
+    }
+    if (import_fs7.default.existsSync(clipboardContent)) {
+      return clipboardContent;
+    }
+    return null;
+  } catch (error) {
+    console.error(import_chalk9.default.dim("   Failed to save clipboard image"));
+    return null;
+  }
+}
+async function createTicket(token, projectId, ticketData) {
+  const baseUrl = getBaseUrl();
+  console.log(import_chalk9.default.dim("\n   Creating ticket..."));
+  try {
+    let response;
+    if (ticketData.images && ticketData.images.length > 0) {
+      const formData = new import_form_data2.default();
+      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", import_fs7.default.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(import_chalk9.default.green("\n\u2705 Ticket created successfully!\n"));
+    console.log(import_chalk9.default.bold("  Ticket:"), import_chalk9.default.cyan(`#${ticketData_response.key || ticketData_response.id}`));
+    console.log(import_chalk9.default.bold("  Title:"), ticketData_response.title);
+    console.log(import_chalk9.default.bold("  Type:"), getTypeEmoji(ticketData_response.type), ticketData_response.type);
+    console.log(import_chalk9.default.bold("  Priority:"), getPriorityEmoji(ticketData_response.priority), ticketData_response.priority);
+    if (ticketData.images && ticketData.images.length > 0) {
+      console.log(import_chalk9.default.bold("  Attachments:"), import_chalk9.default.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
+var import_chalk10 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_prompts5 = __toESM(require("prompts"));
+var import_ws = __toESM(require("ws"));
+init_config();
+var ROLE_ICONS = {
+  architect: "\u{1F3D7}\uFE0F ",
+  security: "\u{1F512}",
+  implementer: "\u{1F4BB}",
+  reviewer: "\u{1F50D}"
+};
+var ROLE_COLORS = {
+  architect: import_chalk10.default.blue,
+  security: import_chalk10.default.red,
+  implementer: import_chalk10.default.green,
+  reviewer: import_chalk10.default.yellow
+};
+async function councilCommand(task, options = {}) {
+  try {
+    printHeader();
+    if (!task) {
+      const response = await (0, import_prompts5.default)({
+        type: "text",
+        name: "task",
+        message: import_chalk10.default.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(import_chalk10.default.yellow("\nCouncil session cancelled."));
+        process.exit(0);
+      }
+      task = response.task;
+    }
+    console.log("");
+    const token = getToken();
+    const baseUrl = getBaseUrl();
+    if (!token) {
+      console.log(import_chalk10.default.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(import_chalk10.default.gray(`Mode: ${mode === "lambda" ? "AWS Lambda (Serverless)" : "Local LAN Cluster"}`));
+    console.log("");
+    const ws = new import_ws.default(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(import_chalk10.default.red(`
+\u274C Connection error: ${error.message}`));
+      process.exit(1);
+    });
+    ws.on("close", () => {
+      if (currentSpinner) currentSpinner.stop();
+    });
+  } catch (error) {
+    console.log(import_chalk10.default.red(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    process.exit(1);
+  }
+}
+function printHeader() {
+  console.log("");
+  console.log(import_chalk10.default.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(import_chalk10.default.blue.bold("\u2551               Claude Council - AI Collaboration            \u2551"));
+  console.log(import_chalk10.default.blue.bold('\u2551         "Preventing wasted engineering time"              \u2551'));
+  console.log(import_chalk10.default.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(import_chalk10.default.yellow("\u{1F3AD} Assembling Claude Council..."));
+      console.log("");
+      break;
+    case "spawning-member":
+      const spinner = (0, import_ora3.default)({
+        text: `Spawning ${message.role} in Docker container on ${message.location || "Lambda"}...`,
+        color: "cyan"
+      }).start();
+      onSpinnerUpdate(spinner);
+      break;
+    case "member-ready":
+      if (currentSpinner) {
+        currentSpinner.succeed(
+          import_chalk10.default.green(`\u2713 ${capitalize(message.role)} ready (${message.memberId})`)
+        );
+      }
+      break;
+    case "all-members-ready":
       console.log("");
+      console.log(import_chalk10.default.cyan("\u{1F4AC} Council Session Started"));
+      console.log(import_chalk10.default.gray(`   Session ID: ${message.sessionId}`));
+      console.log(import_chalk10.default.gray(`   Members: ${message.memberCount}`));
+      console.log("");
+      break;
+    case "round-start":
+      printRoundHeader(message.round ?? 0);
+      roundResponses.length = 0;
+      break;
+    case "member-thinking": {
+      const role = message.role ?? "architect";
+      const thinkSpinner = (0, import_ora3.default)({
+        text: `${ROLE_ICONS[role]} ${capitalize(role)} is analyzing...`,
+        color: "yellow"
+      }).start();
+      onSpinnerUpdate(thinkSpinner);
+      break;
+    }
+    case "member-response": {
+      if (currentSpinner) currentSpinner.stop();
+      const role = message.role ?? "architect";
+      const roleColor = ROLE_COLORS[role] || import_chalk10.default.white;
+      const icon = ROLE_ICONS[role] || "\u{1F916}";
+      console.log("");
+      console.log(roleColor.bold(`${icon} ${capitalize(role)}:`));
+      const formatted = formatResponse(typeof message.content === "string" ? message.content : "");
+      console.log(import_chalk10.default.gray(`   ${formatted}`));
+      console.log("");
+      roundResponses.push(message);
+      break;
+    }
+    case "round-complete":
+      const agreementCount = typeof message.agreements === "number" ? message.agreements : 0;
+      const totalMembers = typeof message.totalMembers === "number" ? message.totalMembers : roundResponses.length;
+      const agreementPercent = Math.round(agreementCount / totalMembers * 100);
+      console.log(import_chalk10.default.gray(`   Agreement: ${agreementCount}/${totalMembers} (${agreementPercent}%)`));
+      console.log("");
+      break;
+    case "consensus-reached":
+      console.log(import_chalk10.default.green.bold("\n\u2705 CONSENSUS REACHED!"));
+      console.log(import_chalk10.default.gray(`   Rounds: ${message.rounds}`));
+      console.log(import_chalk10.default.gray(`   Time: ${message.time}s`));
+      console.log("");
+      break;
+    case "spawning-additional-member":
+      console.log(import_chalk10.default.yellow(`
+\u26A0\uFE0F  Discussion needs more input. Spawning ${message.role}...`));
+      break;
+    case "generating-solution":
+      const genSpinner = (0, import_ora3.default)({
+        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(import_chalk10.default.blue.bold("\u2500".repeat(65)));
+      console.log(import_chalk10.default.blue.bold("\u{1F4CB} Solution"));
+      console.log(import_chalk10.default.blue.bold("\u2500".repeat(65)));
+      console.log("");
+      console.log(message.solution);
+      console.log("");
+      if (message.files && message.files.length > 0) {
+        console.log(import_chalk10.default.cyan("\u{1F4C1} Files created:"));
+        message.files.forEach((file) => {
+          console.log(import_chalk10.default.gray(`   \u251C\u2500 ${file}`));
+        });
+        console.log("");
+      }
+      break;
+    case "stats":
+      printStats(message.stats);
+      break;
+    case "cleanup-start":
+      console.log(import_chalk10.default.yellow("\u{1F9F9} Cleaning up council members..."));
+      break;
+    case "member-destroyed":
+      console.log(import_chalk10.default.gray(`   \u251C\u2500 Destroying ${message.role}... \u2713`));
+      break;
+    case "session-complete":
+      console.log("");
+      console.log(import_chalk10.default.green.bold("\u2728 Council session complete!"));
+      console.log("");
+      onExit();
+      break;
+    case "timeout":
+      console.log(import_chalk10.default.yellow("\n\u23F1\uFE0F  Discussion timeout reached"));
+      console.log(import_chalk10.default.gray("   The council needs your input to continue."));
+      break;
+    case "error":
+      if (currentSpinner) currentSpinner.fail();
+      console.log(import_chalk10.default.red(`
+\u274C Error: ${message.error}`));
+      onExit();
+      break;
+  }
+}
+function printRoundHeader(round) {
+  console.log(import_chalk10.default.cyan("\u2500".repeat(65)));
+  console.log(import_chalk10.default.cyan(`Round ${round} - Council Discussion`));
+  console.log(import_chalk10.default.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(import_chalk10.default.blue.bold("\u2500".repeat(65)));
+  console.log(import_chalk10.default.blue.bold("\u{1F4CA} Session Statistics"));
+  console.log(import_chalk10.default.blue.bold("\u2500".repeat(65)));
+  console.log("");
+  console.log(import_chalk10.default.gray(`   Council members: ${stats.members || 0}`));
+  console.log(import_chalk10.default.gray(`   Discussion rounds: ${stats.rounds || 0}`));
+  console.log(import_chalk10.default.gray(`   Total time: ${stats.time || 0}s`));
+  console.log(import_chalk10.default.gray(`   API cost: $${(stats.cost || 0).toFixed(2)}`));
+  console.log(import_chalk10.default.gray(`   Lines of code: ${stats.linesOfCode || 0}`));
+  console.log("");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/cli/index.ts
+init_analyze();
+
+// src/cli/commands/usage.ts
+var import_chalk11 = __toESM(require("chalk"));
+var import_prompts6 = __toESM(require("prompts"));
+init_config();
+async function usageCommand(options = {}) {
+  const token = getToken();
+  if (!token) {
+    console.error(import_chalk11.default.red("\u274C Not authenticated"));
+    console.log(import_chalk11.default.dim("   Run"), import_chalk11.default.cyan("codmir login"), import_chalk11.default.dim("first"));
+    process.exit(1);
+  }
+  console.log(import_chalk11.default.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 }
     });
-    console.log(import_chalk6.default.dim("   Link a project:"), import_chalk6.default.cyan("codmir link"));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch API keys: ${response.status}`);
+    }
+    const { keys } = await response.json();
+    if (keys.length === 0) {
+      console.log(import_chalk11.default.yellow("\u26A0\uFE0F  No API keys found"));
+      console.log(import_chalk11.default.dim("   Create one at:"), import_chalk11.default.cyan("https://codmir.com/settings/api-keys"));
+      return;
+    }
+    console.log(import_chalk11.default.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(import_chalk11.default.cyan.bold(`\u{1F511} ${key.name}`));
+      console.log(import_chalk11.default.dim(`   Key: ${key.keyPrefix}...`));
+      console.log(import_chalk11.default.dim(`   Scope: ${key.scope}`));
+      console.log();
+      console.log(import_chalk11.default.bold("   Usage:"));
+      console.log(import_chalk11.default.dim(`     Total Requests:  ${(usage?.totalRequests || 0).toLocaleString()}`));
+      console.log(import_chalk11.default.dim(`     AI Calls:        ${(usage?.totalAICalls || 0).toLocaleString()}`));
+      console.log(import_chalk11.default.dim(`     Tokens Used:     ${tokenCount.toLocaleString()}`));
+      const costColor = getCostColor(usage?.totalCostCents || 0);
+      console.log(import_chalk11.default.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(import_chalk11.default.dim(`     Last Used:       ${lastUsed.toLocaleDateString()} (${daysAgo} days ago)`));
+      } else {
+        console.log(import_chalk11.default.dim("     Last Used:       Never"));
+      }
+      if (options.detailed && usage) {
+        console.log();
+        console.log(import_chalk11.default.bold("   Provider Breakdown:"));
+        if (usage.openaiTokens > 0) {
+          console.log(import_chalk11.default.dim(`     OpenAI:          ${Number(usage.openaiTokens).toLocaleString()} tokens ($${(usage.openaiCostCents / 100).toFixed(2)})`));
+        }
+        if (usage.anthropicTokens > 0) {
+          console.log(import_chalk11.default.dim(`     Anthropic:       ${Number(usage.anthropicTokens).toLocaleString()} tokens ($${(usage.anthropicCostCents / 100).toFixed(2)})`));
+        }
+        if (usage.localTokens > 0) {
+          console.log(import_chalk11.default.dim(`     Local:           ${Number(usage.localTokens).toLocaleString()} tokens (free)`));
+        }
+        if (usage.totalAnalyses > 0) {
+          console.log();
+          console.log(import_chalk11.default.bold("   Codebase Analysis:"));
+          console.log(import_chalk11.default.dim(`     Total Analyses:  ${usage.totalAnalyses}`));
+          console.log(import_chalk11.default.dim(`     Local:           ${usage.localAnalyses}`));
+          console.log(import_chalk11.default.dim(`     Deep (Railway):  ${usage.deepAnalyses} ($${(usage.railwayCostCents / 100).toFixed(2)})`));
+          console.log(import_chalk11.default.dim(`     Files Processed: ${Number(usage.filesProcessed).toLocaleString()}`));
+          console.log(import_chalk11.default.dim(`     Lines Processed: ${Number(usage.linesProcessed).toLocaleString()}`));
+        }
+      }
+      console.log();
+      console.log(import_chalk11.default.dim("   \u2500".repeat(50)));
+      console.log();
+    }
+    console.log(import_chalk11.default.bold.cyan("\u{1F4C8} Summary\n"));
+    console.log(import_chalk11.default.dim(`   Total Requests:  ${totalRequests.toLocaleString()}`));
+    console.log(import_chalk11.default.dim(`   AI Calls:        ${totalAICalls.toLocaleString()}`));
+    console.log(import_chalk11.default.dim(`   Tokens Used:     ${totalTokens.toLocaleString()}`));
+    console.log();
+    console.log(import_chalk11.default.bold.green(`   Total Cost:      $${(totalCostCents / 100).toFixed(2)}`));
+    console.log();
+    if (totalCostCents > 5e3) {
+      console.log(import_chalk11.default.yellow("   \u26A0\uFE0F  High usage detected this month"));
+      console.log(import_chalk11.default.dim("   Consider optimizing AI calls or using local mode"));
+      console.log();
+    }
+    if (!options.detailed && keys.length > 0) {
+      console.log(import_chalk11.default.dim("   \u{1F4A1} Tip: Use"), import_chalk11.default.cyan("--detailed"), import_chalk11.default.dim("for provider breakdown"));
+    }
+    console.log(import_chalk11.default.dim("   \u{1F4C5} View other months:"), import_chalk11.default.cyan("codmir usage --month 2025-01"));
+    console.log();
   } catch (error) {
-    console.error(import_chalk6.default.red("\n\u274C Failed to fetch projects:"), error instanceof Error ? error.message : "Unknown error");
+    console.error(import_chalk11.default.red("\n\u274C Failed to get usage stats"));
+    console.error(import_chalk11.default.dim("   Error:"), error instanceof Error ? error.message : "Unknown error");
     process.exit(1);
   }
 }
+function getCostColor(costCents) {
+  if (costCents === 0) return import_chalk11.default.dim;
+  if (costCents < 100) return import_chalk11.default.green;
+  if (costCents < 1e3) return import_chalk11.default.yellow;
+  return import_chalk11.default.red;
+}
 
 // src/cli/index.ts
 var program = new import_commander.Command();
@@ -728,7 +2586,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();