@makeitvisible/cli 0.1.0

package/dist/bin/index.js

@@ -0,0 +1,1588 @@
+#!/usr/bin/env node
+import { Command, program } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import OpenAI from 'openai';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, relative, basename } from 'path';
+import { glob } from 'glob';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function git(command) {
+  try {
+    return execSync(`git ${command}`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer for large diffs
+    }).trim();
+  } catch (error) {
+    throw new Error(`Git command failed: git ${command}`);
+  }
+}
+function revisionExists(revision) {
+  try {
+    git(`rev-parse --verify ${revision}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDefaultRange() {
+  if (revisionExists("HEAD~1")) {
+    return "HEAD~1..HEAD";
+  }
+  if (revisionExists("HEAD")) {
+    const emptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+    return `${emptyTree}..HEAD`;
+  }
+  throw new Error("No commits found in repository");
+}
+function getChangedFiles(range) {
+  const output = git(`diff --numstat ${range}`);
+  if (!output) return [];
+  return output.split("\n").map((line) => {
+    const [additions, deletions, path] = line.split("	");
+    return {
+      path,
+      additions: parseInt(additions, 10) || 0,
+      deletions: parseInt(deletions, 10) || 0,
+      status: "modified"
+    };
+  });
+}
+function getCommits(range) {
+  const output = git(`log --format="%H|%an|%ai|%s" ${range}`);
+  if (!output) return [];
+  return output.split("\n").map((line) => {
+    const [hash, author, date, message] = line.split("|");
+    return { hash, author, date, message };
+  });
+}
+function getDiffContent(range) {
+  return git(`diff ${range}`);
+}
+function detectBreakingChanges(commits, diffContent) {
+  const breakingPatterns = [
+    /BREAKING CHANGE/i,
+    /\bbreaking\b/i,
+    /\!:/,
+    /removed/i,
+    /deprecated/i
+  ];
+  for (const commit of commits) {
+    if (breakingPatterns.some((pattern) => pattern.test(commit.message))) {
+      return true;
+    }
+  }
+  const lines = diffContent.split("\n");
+  const removedExports = lines.filter(
+    (line) => line.startsWith("-") && /export\s+(default\s+)?(function|class|const|interface|type)/.test(line)
+  );
+  return removedExports.length > 0;
+}
+function extractKeywords(files, diffContent) {
+  const keywords = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parts = file.path.split("/");
+    for (const part of parts) {
+      if (!["src", "lib", "dist", "index", "node_modules"].includes(part)) {
+        const words = part.replace(/\.(ts|tsx|js|jsx|json|md|css|scss)$/, "").split(/[-_.]/).filter((w) => w.length > 2);
+        words.forEach((w) => keywords.add(w.toLowerCase()));
+      }
+    }
+  }
+  const codePatterns = [
+    /(?:function|class|interface|type|const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)/g,
+    /export\s+(?:default\s+)?(?:function|class|const)\s+([A-Za-z_][A-Za-z0-9_]*)/g
+  ];
+  for (const pattern of codePatterns) {
+    let match;
+    while ((match = pattern.exec(diffContent)) !== null) {
+      if (match[1] && match[1].length > 2) {
+        keywords.add(match[1].toLowerCase());
+      }
+    }
+  }
+  return Array.from(keywords).slice(0, 20);
+}
+function generateTitle(commits, files) {
+  if (commits.length === 1) {
+    return commits[0].message;
+  }
+  if (commits.length > 1) {
+    const messages = commits.map((c) => c.message);
+    const firstWords = messages.map((m) => m.split(" ").slice(0, 3).join(" "));
+    return `Changes across ${commits.length} commits: ${firstWords[0]}...`;
+  }
+  const extensions = [...new Set(files.map((f) => f.path.split(".").pop()))];
+  return `Code changes in ${files.length} files (${extensions.join(", ")})`;
+}
+function generateDescription(commits, files, breakingChanges) {
+  const parts = [];
+  if (commits.length > 0) {
+    parts.push(`This change includes ${commits.length} commit(s).`);
+  }
+  const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
+  const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
+  parts.push(`Modified ${files.length} file(s) with +${totalAdditions}/-${totalDeletions} lines.`);
+  if (breakingChanges) {
+    parts.push("\u26A0\uFE0F This change may contain breaking changes.");
+  }
+  return parts.join(" ");
+}
+function generateGuidelines(commits, files, breakingChanges) {
+  const guidelines = [];
+  const hasFeature = commits.some((c) => /feat|feature|add|new/i.test(c.message));
+  const hasFix = commits.some((c) => /fix|bug|patch|issue/i.test(c.message));
+  const hasRefactor = commits.some((c) => /refactor|clean|improve/i.test(c.message));
+  if (hasFeature) {
+    guidelines.push("Highlight the new capability and its user-facing benefits.");
+  }
+  if (hasFix) {
+    guidelines.push("Explain what was broken and how it's now fixed.");
+  }
+  if (hasRefactor) {
+    guidelines.push("Note the improvements without exposing internal complexity.");
+  }
+  if (breakingChanges) {
+    guidelines.push("Clearly communicate the breaking change and migration steps.");
+    guidelines.push("Provide a timeline for deprecation if applicable.");
+  }
+  const hasAPI = files.some((f) => /api|route|endpoint/i.test(f.path));
+  const hasUI = files.some((f) => /component|page|view|ui/i.test(f.path));
+  const hasConfig = files.some((f) => /config|env|setting/i.test(f.path));
+  if (hasAPI) {
+    guidelines.push("Document any API changes with request/response examples.");
+  }
+  if (hasUI) {
+    guidelines.push("Consider including screenshots or visual demos.");
+  }
+  if (hasConfig) {
+    guidelines.push("List any new configuration options or environment variables.");
+  }
+  return guidelines.length > 0 ? guidelines : ["Focus on the value delivered to users.", "Keep technical details accessible."];
+}
+async function analyzeDiff(range) {
+  try {
+    git("rev-parse --git-dir");
+  } catch {
+    throw new Error("Not in a git repository");
+  }
+  let effectiveRange = range;
+  if (range === "HEAD~1..HEAD") {
+    try {
+      effectiveRange = getDefaultRange();
+    } catch (error) {
+      throw new Error(
+        `Could not determine diff range: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  } else {
+    const [start] = range.split("..");
+    if (!revisionExists(start)) {
+      throw new Error(`Invalid revision: ${start}`);
+    }
+  }
+  const files = getChangedFiles(effectiveRange);
+  if (files.length === 0) {
+    throw new Error(`No changes found in range: ${effectiveRange}`);
+  }
+  const commits = getCommits(effectiveRange);
+  const diffContent = getDiffContent(effectiveRange);
+  const breakingChanges = detectBreakingChanges(commits, diffContent);
+  const keywords = extractKeywords(files, diffContent);
+  const title = generateTitle(commits, files);
+  const description = generateDescription(commits, files, breakingChanges);
+  const guidelines = generateGuidelines(commits, files, breakingChanges);
+  let repoUrl = "";
+  try {
+    repoUrl = git("config --get remote.origin.url").replace(/\.git$/, "");
+  } catch {
+  }
+  const source = {
+    type: "commit",
+    reference: effectiveRange,
+    url: repoUrl ? `${repoUrl}/compare/${effectiveRange.replace("..", "...")}` : void 0
+  };
+  const context = {
+    summary: description,
+    technicalDetails: commits.map((c) => `${c.hash.slice(0, 7)}: ${c.message}`),
+    affectedComponents: files.map((f) => f.path),
+    breakingChanges,
+    keywords
+  };
+  return {
+    title,
+    description,
+    source,
+    context,
+    guidelines
+  };
+}
+async function analyzePR(options) {
+  try {
+    git("rev-parse --git-dir");
+  } catch {
+    throw new Error("Not in a git repository");
+  }
+  let prTitle = "";
+  let prBody = "";
+  let prNumber = options.number;
+  let prUrl = options.url;
+  if (prUrl) {
+    const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+    if (match) {
+      prNumber = parseInt(match[3], 10);
+    }
+  }
+  if (prNumber) {
+    try {
+      const prInfo = git(`gh pr view ${prNumber} --json title,body,headRefName,baseRefName`);
+      const parsed = JSON.parse(prInfo);
+      prTitle = parsed.title || "";
+      prBody = parsed.body || "";
+      const baseRef = parsed.baseRefName || "main";
+      const headRef = parsed.headRefName || "HEAD";
+      try {
+        git(`fetch origin ${baseRef}`);
+      } catch {
+      }
+      const range2 = `origin/${baseRef}...${headRef}`;
+      const result2 = await analyzeDiff(range2);
+      result2.title = prTitle || result2.title;
+      result2.description = prBody ? `${prBody.slice(0, 200)}${prBody.length > 200 ? "..." : ""}` : result2.description;
+      result2.source = {
+        type: "pr",
+        reference: `#${prNumber}`,
+        url: prUrl || `${git("config --get remote.origin.url").replace(/\.git$/, "")}/pull/${prNumber}`
+      };
+      return result2;
+    } catch {
+    }
+  }
+  const currentBranch = git("rev-parse --abbrev-ref HEAD");
+  let baseBranch = "main";
+  try {
+    git("rev-parse --verify main");
+  } catch {
+    try {
+      git("rev-parse --verify master");
+      baseBranch = "master";
+    } catch {
+      throw new Error("Could not find base branch (main or master)");
+    }
+  }
+  const range = `${baseBranch}...${currentBranch}`;
+  const result = await analyzeDiff(range);
+  result.source = {
+    type: "pr",
+    reference: prNumber ? `#${prNumber}` : currentBranch,
+    url: prUrl
+  };
+  return result;
+}
+
+// src/agent/tools/definitions.ts
+var AGENT_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "search_files",
+      description: "Search for files by name pattern or content. Use this to find files related to a feature, component, or concept. Returns file paths that match.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query - can be a filename pattern (e.g., '*expense*', '*.schema.ts') or keywords to search in file content"
+          },
+          searchIn: {
+            type: "string",
+            enum: ["filename", "content", "both"],
+            description: "Where to search: filename only, file content only, or both"
+          },
+          fileTypes: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional file extensions to filter (e.g., ['.ts', '.tsx']). If not provided, searches all code files."
+          },
+          directory: {
+            type: "string",
+            description: "Optional subdirectory to search in (relative to project root). If not provided, searches entire project."
+          }
+        },
+        required: ["query", "searchIn"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read the contents of a specific file. Use this after finding a relevant file to understand its implementation, imports, exports, and logic.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file (relative to project root)"
+          },
+          startLine: {
+            type: "number",
+            description: "Optional start line number (1-indexed) to read from"
+          },
+          endLine: {
+            type: "number",
+            description: "Optional end line number (1-indexed) to read to"
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "find_references",
+      description: "Find where a symbol (function, component, class, type, constant) is used/imported across the codebase. Critical for understanding how something is triggered or consumed.",
+      parameters: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "The symbol name to find references for (e.g., 'CreateExpenseModal', 'useAuth', 'ExpenseSchema')"
+          },
+          type: {
+            type: "string",
+            enum: ["import", "usage", "all"],
+            description: "Type of references: 'import' finds import statements, 'usage' finds actual usage, 'all' finds both"
+          }
+        },
+        required: ["symbol", "type"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "find_definition",
+      description: "Find where a symbol is defined/exported. Use this to find the source definition of a type, function, or component.",
+      parameters: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "The symbol name to find the definition of"
+          }
+        },
+        required: ["symbol"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_directory",
+      description: "List files and subdirectories in a directory. Use this to explore the project structure and understand how code is organized.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Directory path relative to project root. Use '.' or empty string for root."
+          },
+          recursive: {
+            type: "boolean",
+            description: "If true, lists all files recursively (up to 3 levels deep). If false, only immediate children."
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_file_structure",
+      description: "Analyze a file and extract its structure: imports, exports, functions, classes, types, and their relationships. Use this to quickly understand what a file provides and depends on.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file to analyze"
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "search_types",
+      description: "Search for TypeScript/JavaScript type definitions, interfaces, schemas (Zod, Yup), or prop types. Useful for understanding data structures.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query for types (e.g., 'Expense', 'CreditCard', 'FormData')"
+          },
+          kind: {
+            type: "string",
+            enum: ["interface", "type", "schema", "all"],
+            description: "What kind of type definition to search for"
+          }
+        },
+        required: ["query", "kind"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "complete_investigation",
+      description: "Call this when you have gathered enough information to create a comprehensive artifact. Provide your findings structured for documentation generation.",
+      parameters: {
+        type: "object",
+        properties: {
+          title: {
+            type: "string",
+            description: "A clear, descriptive title for the feature/topic"
+          },
+          summary: {
+            type: "string",
+            description: "A 2-3 sentence summary explaining what this feature does from a user perspective"
+          },
+          entryPoints: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                file: { type: "string" },
+                component: { type: "string" },
+                description: { type: "string" }
+              }
+            },
+            description: "The main entry points/components for this feature (e.g., the modal, page, or button that triggers it)"
+          },
+          dataFlow: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                step: { type: "number" },
+                description: { type: "string" },
+                files: { type: "array", items: { type: "string" } }
+              }
+            },
+            description: "Step-by-step data flow explaining how the feature works"
+          },
+          keyFiles: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                path: { type: "string" },
+                purpose: { type: "string" },
+                keyExports: { type: "array", items: { type: "string" } }
+              }
+            },
+            description: "The most important files for this feature"
+          },
+          dataStructures: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                file: { type: "string" },
+                fields: { type: "array", items: { type: "string" } },
+                description: { type: "string" }
+              }
+            },
+            description: "Key data structures (types, interfaces, schemas) used"
+          },
+          usageExamples: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                description: { type: "string" },
+                file: { type: "string" },
+                codeSnippet: { type: "string" }
+              }
+            },
+            description: "Examples of how this feature is used in the codebase"
+          },
+          relatedFeatures: {
+            type: "array",
+            items: { type: "string" },
+            description: "Other features or components that relate to this one"
+          },
+          technicalNotes: {
+            type: "array",
+            items: { type: "string" },
+            description: "Important technical details, edge cases, or implementation notes"
+          }
+        },
+        required: [
+          "title",
+          "summary",
+          "entryPoints",
+          "dataFlow",
+          "keyFiles",
+          "dataStructures"
+        ]
+      }
+    }
+  }
+];
+var CODE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".rb",
+  ".json",
+  ".yaml",
+  ".yml"
+];
+var IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv"
+];
+async function searchFiles(ctx, args) {
+  const { query, searchIn, fileTypes, directory } = args;
+  const searchRoot = directory ? join(ctx.projectRoot, directory) : ctx.projectRoot;
+  if (!existsSync(searchRoot)) {
+    return { success: false, error: `Directory not found: ${directory}` };
+  }
+  const results = [];
+  const lowerQuery = query.toLowerCase();
+  const extensions = fileTypes?.length ? fileTypes : CODE_EXTENSIONS;
+  const patterns = extensions.map((ext) => `**/*${ext}`);
+  try {
+    for (const pattern of patterns) {
+      const files = await glob(pattern, {
+        cwd: searchRoot,
+        ignore: IGNORED_DIRS.map((d) => `**/${d}/**`),
+        nodir: true,
+        absolute: false
+      });
+      for (const file of files) {
+        const fullPath = join(searchRoot, file);
+        const relativePath = relative(ctx.projectRoot, fullPath);
+        if (searchIn === "filename" || searchIn === "both") {
+          const fileName = basename(file).toLowerCase();
+          if (fileName.includes(lowerQuery) || matchGlob(fileName, query)) {
+            if (!results.find((r) => r.path === relativePath)) {
+              results.push({ path: relativePath });
+            }
+            continue;
+          }
+        }
+        if (searchIn === "content" || searchIn === "both") {
+          try {
+            const content = readFileSync(fullPath, "utf-8");
+            const lines = content.split("\n");
+            const matches = [];
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].toLowerCase().includes(lowerQuery)) {
+                matches.push(`L${i + 1}: ${lines[i].trim().slice(0, 100)}`);
+                if (matches.length >= 5) break;
+              }
+            }
+            if (matches.length > 0) {
+              results.push({ path: relativePath, matches });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    results.sort((a, b) => {
+      if (!a.matches && b.matches) return -1;
+      if (a.matches && !b.matches) return 1;
+      if (a.matches && b.matches) return b.matches.length - a.matches.length;
+      return 0;
+    });
+    return {
+      success: true,
+      data: {
+        query,
+        totalResults: results.length,
+        results: results.slice(0, 20)
+        // Limit results
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Search failed: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+function matchGlob(filename, pattern) {
+  const regex = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(regex, "i").test(filename);
+}
+async function readFile(ctx, args) {
+  const { path: filePath, startLine, endLine } = args;
+  const fullPath = join(ctx.projectRoot, filePath);
+  if (!existsSync(fullPath)) {
+    return { success: false, error: `File not found: ${filePath}` };
+  }
+  try {
+    const content = readFileSync(fullPath, "utf-8");
+    const lines = content.split("\n");
+    const start = startLine ? Math.max(0, startLine - 1) : 0;
+    const end = endLine ? Math.min(lines.length, endLine) : lines.length;
+    const selectedLines = lines.slice(start, end);
+    const numberedContent = selectedLines.map((line, i) => `${start + i + 1}| ${line}`).join("\n");
+    return {
+      success: true,
+      data: {
+        path: filePath,
+        totalLines: lines.length,
+        linesShown: `${start + 1}-${end}`,
+        content: numberedContent
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to read file: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function findReferences(ctx, args) {
+  const { symbol, type } = args;
+  const results = [];
+  const patterns = [];
+  if (type === "import" || type === "all") {
+    patterns.push(
+      { regex: new RegExp(`import\\s+.*\\b${symbol}\\b.*from`, "g"), type: "import" },
+      { regex: new RegExp(`import\\s+${symbol}\\s+from`, "g"), type: "import" },
+      { regex: new RegExp(`from\\s+['"][^'"]+['"].*\\b${symbol}\\b`, "g"), type: "import" },
+      { regex: new RegExp(`require\\([^)]*${symbol}[^)]*\\)`, "g"), type: "import" }
+    );
+  }
+  if (type === "usage" || type === "all") {
+    patterns.push(
+      { regex: new RegExp(`<${symbol}[\\s/>]`, "g"), type: "usage" },
+      // JSX component
+      { regex: new RegExp(`\\b${symbol}\\s*\\(`, "g"), type: "usage" },
+      // Function call
+      { regex: new RegExp(`:\\s*${symbol}[\\s,;>]`, "g"), type: "usage" },
+      // Type annotation
+      { regex: new RegExp(`extends\\s+${symbol}\\b`, "g"), type: "usage" },
+      // Class extends
+      { regex: new RegExp(`implements\\s+${symbol}\\b`, "g"), type: "usage" }
+      // Interface implements
+    );
+  }
+  try {
+    const files = await glob("**/*.{ts,tsx,js,jsx,vue,svelte}", {
+      cwd: ctx.projectRoot,
+      ignore: IGNORED_DIRS.map((d) => `**/${d}/**`),
+      nodir: true
+    });
+    for (const file of files) {
+      const fullPath = join(ctx.projectRoot, file);
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          for (const pattern of patterns) {
+            if (pattern.regex.test(line)) {
+              pattern.regex.lastIndex = 0;
+              results.push({
+                file,
+                line: i + 1,
+                type: pattern.type,
+                context: line.trim().slice(0, 150)
+              });
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const groupedByFile = results.reduce(
+      (acc, ref) => {
+        if (!acc[ref.file]) acc[ref.file] = [];
+        acc[ref.file].push(ref);
+        return acc;
+      },
+      {}
+    );
+    return {
+      success: true,
+      data: {
+        symbol,
+        totalReferences: results.length,
+        fileCount: Object.keys(groupedByFile).length,
+        references: groupedByFile
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to find references: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function findDefinition(ctx, args) {
+  const { symbol } = args;
+  const definitionPatterns = [
+    new RegExp(`export\\s+(?:default\\s+)?(?:async\\s+)?function\\s+${symbol}\\b`),
+    new RegExp(`export\\s+(?:default\\s+)?class\\s+${symbol}\\b`),
+    new RegExp(`export\\s+(?:const|let|var)\\s+${symbol}\\s*=`),
+    new RegExp(`export\\s+(?:interface|type)\\s+${symbol}\\b`),
+    new RegExp(`(?:const|let|var)\\s+${symbol}\\s*=.*(?:function|=>|class)`),
+    new RegExp(`function\\s+${symbol}\\s*\\(`),
+    new RegExp(`class\\s+${symbol}\\s*(?:extends|implements|\\{)`),
+    new RegExp(`interface\\s+${symbol}\\s*(?:extends|\\{)`),
+    new RegExp(`type\\s+${symbol}\\s*=`),
+    new RegExp(`export\\s*\\{[^}]*\\b${symbol}\\b[^}]*\\}`)
+    // Named export
+  ];
+  const results = [];
+  try {
+    const files = await glob("**/*.{ts,tsx,js,jsx}", {
+      cwd: ctx.projectRoot,
+      ignore: IGNORED_DIRS.map((d) => `**/${d}/**`),
+      nodir: true
+    });
+    for (const file of files) {
+      const fullPath = join(ctx.projectRoot, file);
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          for (const pattern of definitionPatterns) {
+            if (pattern.test(line)) {
+              let defType = "unknown";
+              if (/function/.test(line)) defType = "function";
+              else if (/class/.test(line)) defType = "class";
+              else if (/interface/.test(line)) defType = "interface";
+              else if (/type\s+\w+\s*=/.test(line)) defType = "type";
+              else if (/const|let|var/.test(line)) defType = "variable";
+              else if (/export\s*\{/.test(line)) defType = "re-export";
+              results.push({
+                file,
+                line: i + 1,
+                definitionType: defType,
+                context: lines.slice(i, Math.min(i + 5, lines.length)).join("\n").slice(0, 300)
+              });
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      data: {
+        symbol,
+        definitionsFound: results.length,
+        definitions: results
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to find definition: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function listDirectory(ctx, args) {
+  const { path: dirPath, recursive } = args;
+  const fullPath = dirPath ? join(ctx.projectRoot, dirPath) : ctx.projectRoot;
+  if (!existsSync(fullPath)) {
+    return { success: false, error: `Directory not found: ${dirPath}` };
+  }
+  try {
+    let listDir2 = function(dir, depth) {
+      if (depth > 3) return;
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        if (IGNORED_DIRS.includes(entry) || entry.startsWith(".")) continue;
+        const entryPath = join(dir, entry);
+        const relativePath = relative(ctx.projectRoot, entryPath);
+        try {
+          const entryStat = statSync(entryPath);
+          if (entryStat.isDirectory()) {
+            items.push({ path: relativePath, type: "directory" });
+            if (recursive) {
+              listDir2(entryPath, depth + 1);
+            }
+          } else if (entryStat.isFile()) {
+            items.push({ path: relativePath, type: "file", size: entryStat.size });
+          }
+        } catch {
+        }
+      }
+    };
+    var listDir = listDir2;
+    const stat = statSync(fullPath);
+    if (!stat.isDirectory()) {
+      return { success: false, error: `Not a directory: ${dirPath}` };
+    }
+    const items = [];
+    listDir2(fullPath, 0);
+    items.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.path.localeCompare(b.path);
+    });
+    return {
+      success: true,
+      data: {
+        path: dirPath || ".",
+        totalItems: items.length,
+        items: items.slice(0, 100)
+        // Limit results
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to list directory: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function getFileStructure(ctx, args) {
+  const { path: filePath } = args;
+  const fullPath = join(ctx.projectRoot, filePath);
+  if (!existsSync(fullPath)) {
+    return { success: false, error: `File not found: ${filePath}` };
+  }
+  try {
+    const content = readFileSync(fullPath, "utf-8");
+    const structure = {
+      imports: [],
+      exports: [],
+      functions: [],
+      classes: [],
+      types: [],
+      components: []
+    };
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNum = i + 1;
+      const importMatch = line.match(
+        /import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/
+      );
+      if (importMatch) {
+        const imports = importMatch[1] ? importMatch[1].split(",").map((s) => s.trim().split(" as ")[0]) : [importMatch[2]];
+        structure.imports.push({ from: importMatch[3], imports: imports.filter(Boolean) });
+      }
+      const exportMatch = line.match(
+        /export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type)\s+(\w+)/
+      );
+      if (exportMatch) {
+        structure.exports.push({ name: exportMatch[2], type: exportMatch[1], line: lineNum });
+      }
+      const funcMatch = line.match(
+        /(?:export\s+)?(?:default\s+)?(async\s+)?function\s+(\w+)/
+      );
+      if (funcMatch) {
+        structure.functions.push({
+          name: funcMatch[2],
+          line: lineNum,
+          async: !!funcMatch[1]
+        });
+      }
+      const arrowMatch = line.match(
+        /(?:export\s+)?const\s+(\w+)\s*=\s*(async\s+)?(?:\([^)]*\)|[^=])\s*=>/
+      );
+      if (arrowMatch) {
+        structure.functions.push({
+          name: arrowMatch[1],
+          line: lineNum,
+          async: !!arrowMatch[2]
+        });
+      }
+      const classMatch = line.match(
+        /(?:export\s+)?(?:default\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/
+      );
+      if (classMatch) {
+        structure.classes.push({
+          name: classMatch[1],
+          line: lineNum,
+          extends: classMatch[2]
+        });
+      }
+      const typeMatch = line.match(
+        /(?:export\s+)?(interface|type)\s+(\w+)/
+      );
+      if (typeMatch) {
+        structure.types.push({
+          name: typeMatch[2],
+          line: lineNum,
+          kind: typeMatch[1]
+        });
+      }
+      if (line.match(/(?:export\s+)?(?:default\s+)?(?:const|function)\s+([A-Z]\w+)/) && (content.includes("React") || content.includes("jsx") || filePath.endsWith(".tsx"))) {
+        const compMatch = line.match(/(?:const|function)\s+([A-Z]\w+)/);
+        if (compMatch) {
+          const propsMatch = line.match(/:\s*(?:React\.)?FC<(\w+)>|props:\s*(\w+)/);
+          structure.components.push({
+            name: compMatch[1],
+            line: lineNum,
+            props: propsMatch ? propsMatch[1] || propsMatch[2] : void 0
+          });
+        }
+      }
+    }
+    return {
+      success: true,
+      data: {
+        path: filePath,
+        structure
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to analyze file: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function searchTypes(ctx, args) {
+  const { query, kind } = args;
+  const results = [];
+  const patterns = [];
+  if (kind === "interface" || kind === "all") {
+    patterns.push(new RegExp(`interface\\s+(\\w*${query}\\w*)`, "gi"));
+  }
+  if (kind === "type" || kind === "all") {
+    patterns.push(new RegExp(`type\\s+(\\w*${query}\\w*)\\s*=`, "gi"));
+  }
+  if (kind === "schema" || kind === "all") {
+    patterns.push(new RegExp(`(?:const|export\\s+const)\\s+(\\w*${query}\\w*Schema)\\s*=`, "gi"));
+    patterns.push(new RegExp(`z\\.object.*${query}`, "gi"));
+  }
+  try {
+    const files = await glob("**/*.{ts,tsx,js,jsx}", {
+      cwd: ctx.projectRoot,
+      ignore: IGNORED_DIRS.map((d) => `**/${d}/**`),
+      nodir: true
+    });
+    for (const file of files) {
+      const fullPath = join(ctx.projectRoot, file);
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          for (const pattern of patterns) {
+            const match = pattern.exec(line);
+            if (match) {
+              pattern.lastIndex = 0;
+              const preview = lines.slice(i, Math.min(i + 10, lines.length)).join("\n").slice(0, 400);
+              let detectedKind = "type";
+              if (/interface/.test(line)) detectedKind = "interface";
+              else if (/Schema/.test(line) || /z\./.test(line)) detectedKind = "schema";
+              results.push({
+                name: match[1] || query,
+                file,
+                line: i + 1,
+                kind: detectedKind,
+                preview
+              });
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      data: {
+        query,
+        kind,
+        totalResults: results.length,
+        results: results.slice(0, 15)
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to search types: ${error instanceof Error ? error.message : error}`
+    };
+  }
+}
+async function executeTool(toolName, args, ctx) {
+  switch (toolName) {
+    case "search_files":
+      return searchFiles(ctx, args);
+    case "read_file":
+      return readFile(ctx, args);
+    case "find_references":
+      return findReferences(ctx, args);
+    case "find_definition":
+      return findDefinition(ctx, args);
+    case "list_directory":
+      return listDirectory(ctx, args);
+    case "get_file_structure":
+      return getFileStructure(ctx, args);
+    case "search_types":
+      return searchTypes(ctx, args);
+    case "complete_investigation":
+      return { success: true, data: args };
+    default:
+      return { success: false, error: `Unknown tool: ${toolName}` };
+  }
+}
+
+// src/agent/detective.ts
+var SYSTEM_PROMPT = `You are "The Detective" - an expert code analyst who explores codebases methodically to understand features and implementations.
+
+Your mission is to investigate a codebase based on a user's query and produce a comprehensive understanding of how a feature works.
+
+## Investigation Strategy
+
+1. **Start Broad**: Begin by searching for files related to the query keywords. Look for obvious matches first.
+
+2. **Follow the Trail**: When you find a relevant file:
+   - Read it to understand what it does
+   - Look at its imports to find dependencies
+   - Find where it's exported/used to understand how it fits in
+
+3. **Find Entry Points**: Always identify HOW a feature is triggered:
+   - Is it a page/route?
+   - Is it a component triggered by user action?
+   - Is it an API endpoint?
+   - Find the "beginning" of the user journey
+
+4. **Trace Data Flow**: Understand:
+   - What data does the feature work with? (types, schemas)
+   - Where does data come from? (API, props, state)
+   - Where does data go? (mutations, API calls, state updates)
+
+5. **Find Usage Examples**: Search for where components/functions are actually used. This shows real-world integration.
+
+6. **Document Technical Details**: Note any important patterns, validations, error handling, or edge cases.
+
+## Tool Usage Tips
+
+- Use \`search_files\` with searchIn="filename" first for broad discovery
+- Use \`search_files\` with searchIn="content" when looking for specific patterns
+- Use \`get_file_structure\` to quickly understand a file's purpose without reading everything
+- Use \`find_references\` to understand how something is used/triggered
+- Use \`find_definition\` when you see an import and need to find the source
+- Use \`search_types\` to find data structures and schemas
+- Use \`read_file\` to examine specific implementation details
+
+## Investigation Rules
+
+1. Be thorough but efficient - don't read every file, use structure analysis first
+2. Always find at least ONE usage example of the main component/function
+3. Always identify the data types/schemas involved
+4. Focus on answering: "If I were a new developer, what would I need to know to work on this?"
+5. When you have enough information, call \`complete_investigation\` with your structured findings
+
+## Output Quality
+
+Your final investigation should enable someone to:
+- Understand what the feature does (user perspective)
+- Know which files to look at
+- Understand the data flow
+- See real usage examples
+- Know about edge cases or important details`;
+var DetectiveAgent = class {
+  openai;
+  context;
+  options;
+  messages;
+  toolCallCount = 0;
+  constructor(options) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Missing OPENAI_API_KEY environment variable.\nSet it to use the Detective agent for code exploration."
+      );
+    }
+    this.openai = new OpenAI({ apiKey });
+    this.context = { projectRoot: options.projectRoot };
+    this.options = {
+      maxIterations: 25,
+      ...options
+    };
+    this.messages = [{ role: "system", content: SYSTEM_PROMPT }];
+  }
+  /**
+   * Run an investigation based on a user query
+   */
+  async investigate(query) {
+    this.messages.push({
+      role: "user",
+      content: `Investigate the following topic in the codebase:
+
+"${query}"
+
+Use the available tools to explore the codebase, understand the feature, and then call complete_investigation with your findings.`
+    });
+    let iterations = 0;
+    const maxIterations = this.options.maxIterations;
+    while (iterations < maxIterations) {
+      iterations++;
+      try {
+        const response = await this.openai.chat.completions.create({
+          model: "gpt-4o",
+          messages: this.messages,
+          tools: AGENT_TOOLS,
+          tool_choice: "auto",
+          temperature: 0.1
+        });
+        const message = response.choices[0].message;
+        this.messages.push(message);
+        if (message.content && this.options.onThinking) {
+          this.options.onThinking(message.content);
+        }
+        if (!message.tool_calls || message.tool_calls.length === 0) {
+          return {
+            success: false,
+            error: "Agent finished without completing investigation",
+            toolCalls: this.toolCallCount
+          };
+        }
+        const toolResults = [];
+        for (const toolCall of message.tool_calls) {
+          const toolName = toolCall.function.name;
+          let args;
+          try {
+            args = JSON.parse(toolCall.function.arguments);
+          } catch {
+            args = {};
+          }
+          this.toolCallCount++;
+          if (this.options.onToolCall) {
+            this.options.onToolCall(toolName, args);
+          }
+          if (toolName === "complete_investigation") {
+            if (this.options.onToolResult) {
+              this.options.onToolResult(toolName, { success: true, data: args });
+            }
+            return {
+              success: true,
+              title: args.title,
+              summary: args.summary,
+              entryPoints: args.entryPoints,
+              dataFlow: args.dataFlow,
+              keyFiles: args.keyFiles,
+              dataStructures: args.dataStructures,
+              usageExamples: args.usageExamples,
+              relatedFeatures: args.relatedFeatures,
+              technicalNotes: args.technicalNotes,
+              toolCalls: this.toolCallCount
+            };
+          }
+          const result = await executeTool(toolName, args, this.context);
+          if (this.options.onToolResult) {
+            this.options.onToolResult(toolName, result);
+          }
+          toolResults.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: JSON.stringify(result)
+          });
+        }
+        this.messages.push(...toolResults);
+      } catch (error) {
+        return {
+          success: false,
+          error: `Agent error: ${error instanceof Error ? error.message : error}`,
+          toolCalls: this.toolCallCount
+        };
+      }
+    }
+    return {
+      success: false,
+      error: `Investigation exceeded maximum iterations (${maxIterations})`,
+      toolCalls: this.toolCallCount
+    };
+  }
+};
+async function investigateFeature(query, options) {
+  const projectRoot = options.projectRoot || getProjectRoot();
+  const agent = new DetectiveAgent({
+    ...options,
+    projectRoot
+  });
+  return agent.investigate(query);
+}
+function getProjectRoot() {
+  try {
+    const { execSync: execSync2 } = __require("child_process");
+    return execSync2("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+// src/api/client.ts
+function getConfig() {
+  const baseUrl = process.env.VISIBLE_API_BASE_URL;
+  const apiKey = process.env.VISIBLE_API_KEY;
+  if (!baseUrl) {
+    throw new Error(
+      "Missing VISIBLE_API_BASE_URL environment variable.\nSet it to your Visible API endpoint (e.g., https://api.visible.dev)"
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      "Missing VISIBLE_API_KEY environment variable.\nGet your API key from the Visible dashboard."
+    );
+  }
+  return { baseUrl: baseUrl.replace(/\/$/, ""), apiKey };
+}
+async function postArtifact(payload) {
+  const { baseUrl, apiKey } = getConfig();
+  const response = await fetch(`${baseUrl}/api/artifacts`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      title: payload.title,
+      description: payload.description,
+      source: payload.source,
+      context: payload.context,
+      guidelines: payload.guidelines
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `API request failed with status ${response.status}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.message) {
+        errorMessage = errorJson.message;
+      } else if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  if (!data.id || !data.url) {
+    throw new Error("Invalid API response: missing id or url");
+  }
+  return {
+    id: data.id,
+    url: data.url
+  };
+}
+
+// src/commands/analyze.ts
+var analyzeCommand = new Command("analyze").description("Analyze code changes and create artifacts").addCommand(createDiffCommand()).addCommand(createPRCommand()).addCommand(createPromptCommand());
+function createDiffCommand() {
+  return new Command("diff").description("Analyze git diff between commits").argument("[range]", "Git commit range (e.g., HEAD~1..HEAD)", "HEAD~1..HEAD").option("--no-post", "Skip posting artifact to API").action(async (range, options) => {
+    const spinner = ora("Analyzing diff...").start();
+    try {
+      const result = await analyzeDiff(range);
+      spinner.succeed("Diff analyzed successfully");
+      console.log(chalk.bold("\nArtifact Summary:"));
+      console.log(chalk.dim("\u2500".repeat(50)));
+      console.log(chalk.cyan("Title:"), result.title);
+      console.log(chalk.cyan("Description:"), result.description);
+      console.log(chalk.cyan("Files changed:"), result.context.affectedComponents.length);
+      console.log(chalk.cyan("Breaking changes:"), result.context.breakingChanges ? "Yes" : "No");
+      if (options.post) {
+        spinner.start("Posting artifact to Visible API...");
+        const response = await postArtifact(result);
+        spinner.succeed("Artifact posted successfully");
+        console.log(chalk.green("\n\u2713 Artifact created:"), response.url);
+      } else {
+        console.log(chalk.yellow("\nSkipped posting to API (--no-post)"));
+        console.log(chalk.dim("Artifact payload:"));
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      spinner.fail("Failed to analyze diff");
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+}
+function createPRCommand() {
+  return new Command("pr").description("Analyze a pull request").option("--url <url>", "Pull request URL (e.g., https://github.com/owner/repo/pull/123)").option("--number <number>", "Pull request number (uses current repo)").option("--no-post", "Skip posting artifact to API").action(async (options) => {
+    const spinner = ora("Analyzing pull request...").start();
+    try {
+      if (!options.url && !options.number) {
+        spinner.fail("Missing required option");
+        console.error(chalk.red("Error:"), "Either --url or --number is required");
+        process.exit(1);
+      }
+      const result = await analyzePR({
+        url: options.url,
+        number: options.number ? parseInt(options.number, 10) : void 0
+      });
+      spinner.succeed("Pull request analyzed successfully");
+      console.log(chalk.bold("\nArtifact Summary:"));
+      console.log(chalk.dim("\u2500".repeat(50)));
+      console.log(chalk.cyan("Title:"), result.title);
+      console.log(chalk.cyan("Description:"), result.description);
+      console.log(chalk.cyan("Files changed:"), result.context.affectedComponents.length);
+      console.log(chalk.cyan("Breaking changes:"), result.context.breakingChanges ? "Yes" : "No");
+      if (options.post) {
+        spinner.start("Posting artifact to Visible API...");
+        const response = await postArtifact(result);
+        spinner.succeed("Artifact posted successfully");
+        console.log(chalk.green("\n\u2713 Artifact created:"), response.url);
+      } else {
+        console.log(chalk.yellow("\nSkipped posting to API (--no-post)"));
+        console.log(chalk.dim("Artifact payload:"));
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      spinner.fail("Failed to analyze pull request");
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+}
+function createPromptCommand() {
+  return new Command("prompt").description("Explore codebase with an AI agent").argument("<query>", "Natural language prompt describing what to analyze").option("--no-post", "Skip posting artifact to API").option("-v, --verbose", "Show detailed agent activity").action(async (query, options) => {
+    console.log(chalk.bold("\n\u{1F50D} The Detective is investigating...\n"));
+    console.log(chalk.dim(`Query: "${query}"
+`));
+    let spinner = null;
+    let toolCount = 0;
+    try {
+      const investigation = await investigateFeature(query, {
+        verbose: options.verbose,
+        onToolCall: (toolName, args) => {
+          toolCount++;
+          if (options.verbose) {
+            if (spinner) spinner.stop();
+            console.log(chalk.blue(`
+[${toolCount}] ${toolName}`));
+            console.log(chalk.dim(JSON.stringify(args, null, 2)));
+            spinner = ora(`Running ${toolName}...`).start();
+          } else {
+            if (spinner) {
+              spinner.text = `Investigating... (${toolCount} tool calls) - ${toolName}`;
+            } else {
+              spinner = ora(`Investigating... (${toolCount} tool calls) - ${toolName}`).start();
+            }
+          }
+        },
+        onToolResult: (toolName, result) => {
+          if (options.verbose && spinner) {
+            if (result.success) {
+              spinner.succeed(`${toolName} completed`);
+              const dataStr = JSON.stringify(result.data, null, 2);
+              if (dataStr.length > 500) {
+                console.log(chalk.dim(dataStr.slice(0, 500) + "\n..."));
+              } else {
+                console.log(chalk.dim(dataStr));
+              }
+            } else {
+              spinner.fail(`${toolName} failed: ${result.error}`);
+            }
+            spinner = null;
+          }
+        },
+        onThinking: (thought) => {
+          if (options.verbose) {
+            console.log(chalk.yellow("\n\u{1F4AD} Agent thinking:"));
+            console.log(chalk.dim(thought));
+          }
+        }
+      });
+      if (spinner !== null) {
+        const activeSpinner = spinner;
+        if (investigation.success) {
+          activeSpinner.succeed(`Investigation complete (${investigation.toolCalls} tool calls)`);
+        } else {
+          activeSpinner.fail("Investigation failed");
+        }
+      }
+      if (!investigation.success) {
+        console.error(chalk.red("\nError:"), investigation.error);
+        process.exit(1);
+      }
+      console.log(chalk.bold("\n\u{1F4CB} Investigation Results:"));
+      console.log(chalk.dim("\u2500".repeat(60)));
+      console.log(chalk.cyan("\nTitle:"), investigation.title);
+      console.log(chalk.cyan("Summary:"), investigation.summary);
+      if (investigation.entryPoints && investigation.entryPoints.length > 0) {
+        console.log(chalk.cyan("\nEntry Points:"));
+        for (const ep of investigation.entryPoints) {
+          console.log(chalk.dim(`  \u2022 ${ep.component} (${ep.file})`));
+          console.log(chalk.dim(`    ${ep.description}`));
+        }
+      }
+      if (investigation.dataFlow && investigation.dataFlow.length > 0) {
+        console.log(chalk.cyan("\nData Flow:"));
+        for (const step of investigation.dataFlow) {
+          console.log(chalk.dim(`  ${step.step}. ${step.description}`));
+          if (step.files.length > 0) {
+            console.log(chalk.dim(`     Files: ${step.files.join(", ")}`));
+          }
+        }
+      }
+      if (investigation.keyFiles && investigation.keyFiles.length > 0) {
+        console.log(chalk.cyan("\nKey Files:"));
+        for (const file of investigation.keyFiles) {
+          console.log(chalk.dim(`  \u2022 ${file.path}`));
+          console.log(chalk.dim(`    Purpose: ${file.purpose}`));
+          if (file.keyExports.length > 0) {
+            console.log(chalk.dim(`    Exports: ${file.keyExports.join(", ")}`));
+          }
+        }
+      }
+      if (investigation.dataStructures && investigation.dataStructures.length > 0) {
+        console.log(chalk.cyan("\nData Structures:"));
+        for (const ds of investigation.dataStructures) {
+          console.log(chalk.dim(`  \u2022 ${ds.name} (${ds.file})`));
+          console.log(chalk.dim(`    ${ds.description}`));
+          if (ds.fields.length > 0) {
+            console.log(chalk.dim(`    Fields: ${ds.fields.slice(0, 5).join(", ")}${ds.fields.length > 5 ? "..." : ""}`));
+          }
+        }
+      }
+      if (investigation.usageExamples && investigation.usageExamples.length > 0) {
+        console.log(chalk.cyan("\nUsage Examples:"));
+        for (const example of investigation.usageExamples) {
+          console.log(chalk.dim(`  \u2022 ${example.description} (${example.file})`));
+        }
+      }
+      if (investigation.technicalNotes && investigation.technicalNotes.length > 0) {
+        console.log(chalk.cyan("\nTechnical Notes:"));
+        for (const note of investigation.technicalNotes) {
+          console.log(chalk.dim(`  \u2022 ${note}`));
+        }
+      }
+      const artifact = investigationToArtifact(query, investigation);
+      if (options.post) {
+        const postSpinner = ora("Posting artifact to Visible API...").start();
+        const response = await postArtifact(artifact);
+        postSpinner.succeed("Artifact posted successfully");
+        console.log(chalk.green("\n\u2713 Artifact created:"), response.url);
+      } else {
+        console.log(chalk.yellow("\nSkipped posting to API (--no-post)"));
+        console.log(chalk.dim("\nArtifact payload:"));
+        console.log(JSON.stringify(artifact, null, 2));
+      }
+    } catch (error) {
+      if (spinner) spinner.fail("Investigation failed");
+      console.error(chalk.red("\nError:"), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+}
+function investigationToArtifact(query, investigation) {
+  const source = {
+    type: "code-section",
+    reference: query
+  };
+  const technicalDetails = [];
+  if (investigation.dataFlow) {
+    for (const step of investigation.dataFlow) {
+      technicalDetails.push(`Step ${step.step}: ${step.description}`);
+    }
+  }
+  if (investigation.technicalNotes) {
+    technicalDetails.push(...investigation.technicalNotes);
+  }
+  const affectedComponents = [];
+  if (investigation.keyFiles) {
+    affectedComponents.push(...investigation.keyFiles.map((f) => f.path));
+  }
+  if (investigation.entryPoints) {
+    affectedComponents.push(...investigation.entryPoints.map((e) => e.file));
+  }
+  if (investigation.dataStructures) {
+    affectedComponents.push(...investigation.dataStructures.map((d) => d.file));
+  }
+  if (investigation.usageExamples) {
+    affectedComponents.push(...investigation.usageExamples.map((e) => e.file));
+  }
+  const uniqueComponents = [...new Set(affectedComponents)];
+  const keywords = [];
+  if (investigation.dataStructures) {
+    keywords.push(...investigation.dataStructures.map((d) => d.name.toLowerCase()));
+  }
+  if (investigation.keyFiles) {
+    keywords.push(...investigation.keyFiles.flatMap((f) => f.keyExports.map((e) => e.toLowerCase())));
+  }
+  if (investigation.relatedFeatures) {
+    keywords.push(...investigation.relatedFeatures.map((f) => f.toLowerCase()));
+  }
+  const uniqueKeywords = [...new Set(keywords)].slice(0, 20);
+  const context = {
+    summary: investigation.summary || "",
+    technicalDetails,
+    affectedComponents: uniqueComponents,
+    breakingChanges: false,
+    keywords: uniqueKeywords
+  };
+  const guidelines = [
+    "Explain the feature from the user's perspective first."
+  ];
+  if (investigation.entryPoints && investigation.entryPoints.length > 0) {
+    guidelines.push("Show how users trigger/access this feature.");
+  }
+  if (investigation.dataFlow && investigation.dataFlow.length > 0) {
+    guidelines.push("Walk through the data flow step by step.");
+  }
+  if (investigation.dataStructures && investigation.dataStructures.length > 0) {
+    guidelines.push("Define the key data structures and their fields.");
+  }
+  if (investigation.usageExamples && investigation.usageExamples.length > 0) {
+    guidelines.push("Include code examples showing real usage.");
+  }
+  return {
+    title: investigation.title || `Feature: ${query}`,
+    description: investigation.summary || `Investigation of: ${query}`,
+    source,
+    context,
+    guidelines
+  };
+}
+
+// src/bin/index.ts
+program.name("visible").description("Transform technical changes into audience-friendly materials").version("0.1.0");
+program.addCommand(analyzeCommand);
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map