codmir 0.3.2 → 0.4.0

package/dist/chunk-ASGAT3Z5.mjs

@@ -0,0 +1,756 @@
+import {
+  __require
+} from "./chunk-EBO3CZXG.mjs";
+
+// src/cli/commands/analyze.ts
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/cli/utils/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".codmir");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var PROJECT_CONFIG_FILE = ".codmir.json";
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    console.error("Error reading config:", error);
+    return {};
+  }
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function clearConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}
+function readProjectConfig(cwd = process.cwd()) {
+  const configPath = path.join(cwd, PROJECT_CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const data = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    console.error("Error reading project config:", error);
+    return null;
+  }
+}
+function writeProjectConfig(config, cwd = process.cwd()) {
+  const configPath = path.join(cwd, PROJECT_CONFIG_FILE);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  const gitignorePath = path.join(cwd, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+    if (!gitignore.includes(PROJECT_CONFIG_FILE)) {
+      fs.appendFileSync(gitignorePath, `
+# codmir
+${PROJECT_CONFIG_FILE}
+`);
+    }
+  }
+}
+function getToken() {
+  const config = readConfig();
+  return config.token || null;
+}
+function isAuthenticated() {
+  const token = getToken();
+  return !!token;
+}
+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()
+  };
+}
+
+// src/cli/utils/codebase-analyzer/local.ts
+import fs2 from "fs";
+import path2 from "path";
+import { glob } from "glob";
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.cache/**",
+  "**/tmp/**",
+  "**/.turbo/**",
+  "**/.vercel/**"
+];
+var 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"
+};
+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 = fs2.statSync(projectPath);
+  const name = path2.basename(projectPath);
+  if (!stats.isDirectory()) {
+    return {
+      name,
+      path: projectPath,
+      type: "file",
+      size: stats.size,
+      extension: path2.extname(projectPath)
+    };
+  }
+  const children = [];
+  const entries = fs2.readdirSync(projectPath);
+  for (const entry of entries) {
+    if (shouldIgnore(entry)) continue;
+    const fullPath = path2.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 (fs2.existsSync(path2.join(projectPath, "pnpm-lock.yaml"))) {
+    techStack.packageManager = "pnpm";
+  } else if (fs2.existsSync(path2.join(projectPath, "yarn.lock"))) {
+    techStack.packageManager = "yarn";
+  } else if (fs2.existsSync(path2.join(projectPath, "package-lock.json"))) {
+    techStack.packageManager = "npm";
+  } else if (fs2.existsSync(path2.join(projectPath, "bun.lockb"))) {
+    techStack.packageManager = "bun";
+  }
+  const files = await glob("**/*", {
+    cwd: projectPath,
+    ignore: IGNORE_PATTERNS,
+    nodir: true
+  });
+  const languageCounts = {};
+  let totalCodeFiles = 0;
+  for (const file of files) {
+    const ext = path2.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 = path2.join(projectPath, "package.json");
+  if (fs2.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs2.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 = path2.join(projectPath, "package.json");
+  if (fs2.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs2.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 = path2.join(projectPath, entry);
+    if (fs2.existsSync(fullPath)) {
+      entryPoints.push({
+        type: entry.includes("page") ? "page" : "main",
+        name: path2.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 glob(pattern, {
+      cwd: projectPath,
+      nodir: true
+    });
+    for (const file of files) {
+      const fullPath = path2.join(projectPath, file);
+      const content = fs2.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: path2.basename(projectPath),
+    totalFiles: 0,
+    totalLines: 0
+  };
+  const packageJsonPath = path2.join(projectPath, "package.json");
+  if (fs2.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs2.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 glob("**/*", {
+    cwd: projectPath,
+    ignore: IGNORE_PATTERNS,
+    nodir: true
+  });
+  metadata.totalFiles = files.length;
+  for (const file of files) {
+    const ext = path2.extname(file);
+    if (LANGUAGE_EXTENSIONS[ext]) {
+      const fullPath = path2.join(projectPath, file);
+      const content = fs2.readFileSync(fullPath, "utf-8");
+      metadata.totalLines += content.split("\n").length;
+    }
+  }
+  const gitPath = path2.join(projectPath, ".git");
+  if (fs2.existsSync(gitPath)) {
+    try {
+      const headPath = path2.join(gitPath, "HEAD");
+      const head = fs2.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;
+}
+
+// src/cli/utils/knowledge-base/storage.ts
+import fs3 from "fs";
+import path3 from "path";
+var KNOWLEDGE_BASE_DIR = ".codmir/knowledge";
+var INDEX_FILE = "index.json";
+function getKnowledgeBaseDir(projectPath) {
+  return path3.join(projectPath, KNOWLEDGE_BASE_DIR);
+}
+function ensureKnowledgeBaseDir(projectPath) {
+  const kbDir = getKnowledgeBaseDir(projectPath);
+  if (!fs3.existsSync(kbDir)) {
+    fs3.mkdirSync(kbDir, { recursive: true });
+  }
+}
+function saveKnowledgeBase(projectPath, knowledgeBase) {
+  ensureKnowledgeBaseDir(projectPath);
+  const kbDir = getKnowledgeBaseDir(projectPath);
+  const indexPath = path3.join(kbDir, INDEX_FILE);
+  fs3.writeFileSync(indexPath, JSON.stringify(knowledgeBase, null, 2));
+  if (knowledgeBase.localAnalysis) {
+    saveComponent(kbDir, "local-analysis.json", knowledgeBase.localAnalysis);
+  }
+}
+function loadKnowledgeBase(projectPath) {
+  const indexPath = path3.join(projectPath, KNOWLEDGE_BASE_DIR, INDEX_FILE);
+  if (!fs3.existsSync(indexPath)) {
+    return null;
+  }
+  try {
+    const content = fs3.readFileSync(indexPath, "utf-8");
+    const knowledgeBase = JSON.parse(content);
+    const kbDir = getKnowledgeBaseDir(projectPath);
+    if (knowledgeBase.analysisType === "local") {
+      const localAnalysisPath = path3.join(kbDir, "local-analysis.json");
+      if (fs3.existsSync(localAnalysisPath)) {
+        knowledgeBase.localAnalysis = JSON.parse(
+          fs3.readFileSync(localAnalysisPath, "utf-8")
+        );
+      }
+    }
+    return knowledgeBase;
+  } catch (error) {
+    console.error("Error loading knowledge base:", error);
+    return null;
+  }
+}
+function hasKnowledgeBase(projectPath) {
+  const indexPath = path3.join(projectPath, KNOWLEDGE_BASE_DIR, INDEX_FILE);
+  return fs3.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 = path3.join(kbDir, filename);
+  fs3.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;
+}
+
+// src/cli/commands/analyze.ts
+async function analyzeCommand(options = {}) {
+  console.log(chalk.bold("\n\u{1F50D} Codebase Analysis\n"));
+  const projectConfig = getProjectConfig();
+  if (!projectConfig) {
+    console.error(chalk.red("\u274C Project not linked"));
+    console.log(chalk.dim("   Run"), chalk.cyan("codmir link"), chalk.dim("first"));
+    process.exit(1);
+  }
+  const projectPath = process.cwd();
+  const existingKB = hasKnowledgeBase(projectPath);
+  if (existingKB && !options.force) {
+    const stats = getKnowledgeBaseStats(projectPath);
+    console.log(chalk.yellow("\u26A0\uFE0F  Knowledge base already exists"));
+    console.log(chalk.dim(`   Last analyzed: ${new Date(stats.analyzedAt).toLocaleString()}`));
+    console.log(chalk.dim(`   Files: ${stats.totalFiles}, Lines: ${stats.totalLines}`));
+    const { reanalyze } = await prompts({
+      type: "confirm",
+      name: "reanalyze",
+      message: "Re-analyze codebase?",
+      initial: false
+    });
+    if (!reanalyze) {
+      console.log(chalk.dim("\n   Use"), chalk.cyan("--force"), chalk.dim("to force re-analysis"));
+      return;
+    }
+  }
+  let analysisMode = options.mode || "local";
+  if (!options.mode) {
+    const { mode } = await prompts({
+      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 = ora({
+    text: chalk.dim("Analyzing project structure..."),
+    color: "cyan"
+  }).start();
+  try {
+    const analysis = await analyzeLocal(projectPath);
+    spinner.text = chalk.dim("Saving knowledge base...");
+    initializeKnowledgeBase(projectPath, projectId, projectName, analysis);
+    spinner.succeed(chalk.green("Analysis complete!"));
+    console.log();
+    console.log(chalk.bold("\u{1F4CA} Results:"));
+    console.log();
+    console.log(chalk.dim("   Project:"), chalk.cyan(projectName));
+    console.log(chalk.dim("   Files:"), chalk.white(analysis.metadata.totalFiles));
+    console.log(chalk.dim("   Lines:"), chalk.white(analysis.metadata.totalLines));
+    console.log();
+    if (Object.keys(analysis.techStack.languages).length > 0) {
+      console.log(chalk.bold("\u{1F5E3}\uFE0F  Languages:"));
+      for (const [lang, percent] of Object.entries(analysis.techStack.languages)) {
+        const bar = createProgressBar(percent, 20);
+        console.log(`   ${chalk.cyan(lang.padEnd(15))} ${bar} ${percent}%`);
+      }
+      console.log();
+    }
+    if (analysis.techStack.frameworks.length > 0) {
+      console.log(chalk.bold("\u26A1 Frameworks:"));
+      analysis.techStack.frameworks.forEach((fw) => {
+        console.log(`   \u2022 ${chalk.green(fw)}`);
+      });
+      console.log();
+    }
+    if (analysis.entryPoints.length > 0) {
+      console.log(chalk.bold("\u{1F680} Entry Points:"));
+      analysis.entryPoints.slice(0, 5).forEach((ep) => {
+        console.log(`   \u2022 ${chalk.yellow(ep.name)} ${chalk.dim(`(${ep.path})`)}`);
+      });
+      if (analysis.entryPoints.length > 5) {
+        console.log(chalk.dim(`   ... and ${analysis.entryPoints.length - 5} more`));
+      }
+      console.log();
+    }
+    if (analysis.documentation.length > 0) {
+      console.log(chalk.bold("\u{1F4DA} Documentation:"));
+      analysis.documentation.forEach((doc) => {
+        const icon = getDocIcon(doc.type);
+        console.log(`   ${icon} ${chalk.cyan(doc.path)}`);
+      });
+      console.log();
+    }
+    console.log(chalk.dim("   Knowledge base saved to:"), chalk.cyan(".codmir/knowledge/"));
+    console.log();
+    console.log(chalk.dim("   Try:"), chalk.cyan('codmir ai --context "Explain the project structure"'));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red("Analysis failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function runRailwayAnalysis(projectPath, projectId) {
+  const token = getToken();
+  if (!token) {
+    console.error(chalk.red("\u274C Not authenticated"));
+    console.log(chalk.dim("   Run"), chalk.cyan("codmir login"), chalk.dim("first"));
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const gitRemote = await getGitRemote(projectPath);
+  if (!gitRemote) {
+    console.error(chalk.red("\u274C No git remote found"));
+    console.log(chalk.dim("   Project must be a git repository with remote"));
+    process.exit(1);
+  }
+  console.log(chalk.dim("   Repository:"), chalk.cyan(gitRemote));
+  console.log();
+  const spinner = ora({
+    text: chalk.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 = chalk.dim(`Analysis in progress (${estimatedTime})...`);
+    await pollAnalysisStatus(baseUrl, token, jobId, spinner);
+    spinner.succeed(chalk.green("Deep analysis complete!"));
+    console.log();
+    console.log(chalk.dim("   Knowledge base synced from Railway"));
+    console.log(chalk.dim("   Includes:"));
+    console.log(chalk.dim("     \u2022 Full AST parsing"));
+    console.log(chalk.dim("     \u2022 Code embeddings"));
+    console.log(chalk.dim("     \u2022 Best practices report"));
+    console.log(chalk.dim("     \u2022 Generated documentation"));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.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 = chalk.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 chalk.cyan("\u2588".repeat(filled)) + chalk.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}";
+}
+
+export {
+  ensureConfigDir,
+  readConfig,
+  writeConfig,
+  clearConfig,
+  readProjectConfig,
+  writeProjectConfig,
+  getToken,
+  isAuthenticated,
+  getBaseUrl,
+  getProjectConfig,
+  getExecutionContext,
+  analyzeCommand
+};