npm - codmir - Versions diffs - 0.3.1 → 0.3.3 - Mend

codmir 0.3.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/LICENSE +55 -0
package/README.md +219 -14
package/dist/analyze-LULBI4ZC.mjs +7 -0
package/dist/chunk-ASGAT3Z5.mjs +756 -0
package/dist/chunk-EBO3CZXG.mjs +15 -0
package/dist/cli/index.js +1946 -200
package/dist/cli/index.mjs +1192 -221
package/dist/index.mjs +2 -1
package/package.json +27 -8
/package/dist/{chunk-7HVQNURM.mjs → chunk-LXEEBTWT.mjs} +0 -0

package/dist/cli/index.js CHANGED Viewed

@@ -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_http = __toESM(require("http"));
-var import_open = __toESM(require("open"));
 // src/cli/utils/config.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_os = __toESM(require("os"));
-var CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".codmir");
-var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
-var PROJECT_CONFIG_FILE = ".codmir.json";
 function ensureConfigDir() {
   if (!import_fs.default.existsSync(CONFIG_DIR)) {
     import_fs.default.mkdirSync(CONFIG_DIR, { recursive: true });
@@ -99,98 +96,875 @@ 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";
+  }
+});
-// src/cli/utils/auth.ts
-async function startOAuthFlow(baseUrl = "https://codmir.com") {
-  return new Promise((resolve, reject) => {
-    const server = import_http.default.createServer(async (req, res) => {
-      const url = new URL(req.url || "/", `http://localhost:${port}`);
-      if (url.pathname === "/callback") {
-        const token = url.searchParams.get("token");
-        const error = url.searchParams.get("error");
-        if (error) {
-          res.writeHead(200, { "Content-Type": "text/html" });
-          res.end(`
-            <html>
-              <body style="font-family: system-ui; padding: 40px; text-align: center;">
-                <h1>\u274C Authentication Failed</h1>
-                <p>${error}</p>
-                <p>You can close this window.</p>
-              </body>
-            </html>
-          `);
-          server.close();
-          reject(new Error(error));
-          return;
-        }
-        if (!token) {
-          res.writeHead(400, { "Content-Type": "text/html" });
-          res.end(`
-            <html>
-              <body style="font-family: system-ui; padding: 40px; text-align: center;">
-                <h1>\u274C No token received</h1>
-                <p>You can close this window.</p>
-              </body>
-            </html>
-          `);
-          server.close();
-          reject(new Error("No token received"));
-          return;
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "codmir",
+      version: "0.3.3",
+      description: "Official codmir SDK - CLI and SDK for AI-powered development: codebase analysis, task replication, usage tracking, and intelligent automation",
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      bin: {
+        codmir: "dist/cli/index.js"
+      },
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          require: "./dist/index.js",
+          import: "./dist/index.mjs"
         }
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(`
-          <html>
-            <body style="font-family: system-ui; padding: 40px; text-align: center;">
-              <h1>\u2705 Authentication Successful!</h1>
-              <p>You can now close this window and return to your terminal.</p>
-              <script>setTimeout(() => window.close(), 2000);</script>
-            </body>
-          </html>
-        `);
-        try {
-          const userResponse = await fetch(`${baseUrl}/api/user/profile`, {
-            headers: {
-              "Authorization": `Bearer ${token}`
-            }
-          });
-          if (!userResponse.ok) {
-            throw new Error("Failed to fetch user info");
-          }
-          const user = await userResponse.json();
-          server.close();
-          resolve({
-            token,
-            user: {
-              id: user.id,
-              email: user.email,
-              name: user.name
-            }
-          });
-        } catch (error2) {
-          server.close();
-          reject(error2);
-        }
-      } else {
-        res.writeHead(404);
-        res.end("Not found");
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "runkit-example.js"
+      ],
+      scripts: {
+        build: "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts --clean",
+        dev: "tsup src/index.ts src/cli/index.ts --format cjs,esm --dts --watch",
+        prepublishOnly: "pnpm build",
+        test: "jest",
+        "test:login": "node scripts/test/login.mjs",
+        "test:link": "node scripts/test/link.mjs",
+        "test:projects": "node scripts/test/projects.mjs",
+        "test:whoami": "node scripts/test/whoami.mjs",
+        "test:logout": "node scripts/test/logout.mjs",
+        "test:all": "npm run test:logout && npm run test:login && npm run test:whoami && npm run test:projects"
+      },
+      keywords: [
+        "codmir",
+        "sdk",
+        "cli",
+        "ai",
+        "codebase-analysis",
+        "knowledge-base",
+        "task-replication",
+        "usage-tracking",
+        "observability",
+        "project-management",
+        "tickets",
+        "tasks",
+        "automation",
+        "multi-agent",
+        "ai-assistant"
+      ],
+      author: "codmir",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/codmir/codmir.git",
+        directory: "apps/web/packages/codmir-client"
+      },
+      bugs: {
+        url: "https://github.com/codmir/codmir/issues"
+      },
+      homepage: "https://codmir.com",
+      runkit: {
+        example: "runkit-example.js"
+      },
+      devDependencies: {
+        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/commit-analyzer": "^13.0.0",
+        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/github": "^11.0.0",
+        "@semantic-release/npm": "^12.0.1",
+        "@semantic-release/release-notes-generator": "^14.0.0",
+        "@types/node": "^20.10.0",
+        "@types/prompts": "^2.4.9",
+        "conventional-changelog-conventionalcommits": "^8.0.0",
+        "semantic-release": "^24.0.0",
+        tsup: "^8.0.1",
+        typescript: "^5.8.3"
+      },
+      dependencies: {
+        chalk: "^5.3.0",
+        clipboardy: "^5.0.1",
+        commander: "^12.0.0",
+        "form-data": "^4.0.5",
+        glob: "^10.3.10",
+        open: "^10.0.0",
+        ora: "^9.0.0",
+        prompts: "^2.4.2",
+        ws: "^8.18.3"
+      },
+      engines: {
+        node: ">=18.0.0"
       }
+    };
+  }
+});
+// src/cli/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
     });
-    const port = 3333;
-    server.listen(port, () => {
-      const authUrl = `${baseUrl}/cli/auth?port=${port}`;
-      console.log("\u{1F510} Opening browser for authentication...");
-      console.log(`   If browser doesn't open, visit: ${authUrl}`);
-      (0, import_open.default)(authUrl).catch(() => {
-        console.log("\n\u26A0\uFE0F  Could not open browser automatically.");
-        console.log(`   Please visit: ${authUrl}`);
+    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({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("\nPaste your authentication token: ", (token) => {
+      rl.close();
+      resolve(token.trim());
     });
-    setTimeout(() => {
-      server.close();
-      reject(new Error("Authentication timeout"));
-    }, 5 * 60 * 1e3);
   });
 }
+async function startOAuthFlow(baseUrl = "https://codmir.com") {
+  const authUrl = `${baseUrl}/cli/auth`;
+  console.log("\u{1F510} Opening browser for authentication...");
+  console.log(`   If browser doesn't open, visit: ${authUrl}`);
+  console.log();
+  try {
+    await (0, import_open.default)(authUrl);
+  } catch {
+    console.log("\u26A0\uFE0F  Could not open browser automatically.");
+    console.log(`   Please visit: ${authUrl}`);
+    console.log();
+  }
+  console.log("\u{1F4CB} After authenticating in your browser:");
+  console.log("   1. Copy the token displayed");
+  console.log("   2. Return here and paste it below");
+  console.log();
+  const token = await promptForToken();
+  if (!token) {
+    throw new Error("No token provided");
+  }
+  try {
+    const userResponse = await fetch(`${baseUrl}/api/user/profile`, {
+      headers: {
+        "X-API-Key": token
+      }
+    });
+    if (!userResponse.ok) {
+      throw new Error("Invalid token or authentication failed");
+    }
+    const response = await userResponse.json();
+    const user = response.data || response;
+    return {
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name
+      }
+    };
+  } catch (error) {
+    throw new Error(
+      error instanceof Error ? error.message : "Failed to validate token"
+    );
+  }
+}
 async function authenticateWithToken(token, baseUrl = "https://codmir.com") {
   const response = await fetch(`${baseUrl}/api/user/profile`, {
     headers: {
@@ -200,7 +974,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: {
@@ -223,6 +998,7 @@ function saveAuth(authResult) {
 }
 // src/cli/commands/login.ts
+init_config();
 var import_chalk = __toESM(require("chalk"));
 async function loginCommand(options) {
   if (isAuthenticated()) {
@@ -235,11 +1011,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!"));
@@ -252,6 +1033,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) {
@@ -267,8 +1084,8 @@ var CodmirClient = class {
   /**
    * 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
@@ -325,8 +1142,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
@@ -405,8 +1222,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
@@ -523,59 +1340,129 @@ var TestCasesAPI = class {
 };
 // src/cli/commands/link.ts
-var import_chalk2 = __toESM(require("chalk"));
-var import_prompts = __toESM(require("prompts"));
+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_chalk2.default.red("\u274C Not authenticated"));
-    console.log(import_chalk2.default.dim("   Run"), import_chalk2.default.cyan("codmir login"), import_chalk2.default.dim("first"));
+    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_chalk2.default.bold("\n\u{1F517} codmir link"));
-  console.log(import_chalk2.default.dim("   Link this directory to a codmir project\n"));
+  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_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));
+    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_chalk2.default.dim("   Project:"), import_chalk2.default.bold(existing.projectName));
+      console.log(import_chalk5.default.dim("   Project:"), import_chalk5.default.bold(existing.projectName));
     }
-    const { overwrite } = await (0, import_prompts.default)({
+    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_chalk2.default.dim("   Cancelled"));
+      console.log(import_chalk5.default.dim("   Cancelled"));
       return;
     }
   }
   try {
+    const baseUrl = getBaseUrl();
     const client = new CodmirClient({
       apiKey: token,
-      baseUrl: process.env.CODMIR_API_URL || "https://codmir.com"
+      baseUrl
     });
     let projectId = options.project;
     let orgId = options.org;
-    console.log(import_chalk2.default.dim("   Fetching your projects...\n"));
-    const response = await fetch(`${process.env.CODMIR_API_URL || "https://codmir.com"}/api/projects`, {
+    console.log(import_chalk5.default.dim("   Fetching your projects...\n"));
+    const response = await fetch(`${baseUrl}/api/projects`, {
       headers: {
-        "Authorization": `Bearer ${token}`
+        "X-API-Key": token
       }
     });
     if (!response.ok) {
       throw new Error("Failed to fetch projects");
     }
-    const projects = await response.json();
+    const responseData = await response.json();
+    const projects = responseData.data || responseData;
     if (!projectId) {
       if (projects.length === 0) {
-        console.log(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:",
@@ -586,14 +1473,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({
@@ -601,67 +1488,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';
@@ -703,56 +1575,916 @@ 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);
+      roundResponses.length = 0;
+      break;
+    case "member-thinking":
+      const thinkSpinner = (0, import_ora3.default)({
+        text: `${ROLE_ICONS[message.role]} ${capitalize(message.role)} is analyzing...`,
+        color: "yellow"
+      }).start();
+      onSpinnerUpdate(thinkSpinner);
+      break;
+    case "member-response":
+      if (currentSpinner) currentSpinner.stop();
+      const roleColor = ROLE_COLORS[message.role] || import_chalk10.default.white;
+      const icon = ROLE_ICONS[message.role] || "\u{1F916}";
+      console.log("");
+      console.log(roleColor.bold(`${icon} ${capitalize(message.role)}:`));
+      const formatted = formatResponse(message.content);
+      console.log(import_chalk10.default.gray(`   ${formatted}`));
+      console.log("");
+      roundResponses.push(message);
+      break;
+    case "round-complete":
+      const agreementCount = message.agreements || 0;
+      const totalMembers = message.totalMembers || roundResponses.length;
+      const agreementPercent = Math.round(agreementCount / totalMembers * 100);
+      console.log(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();
@@ -762,7 +2494,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();