@poltergeist-ai/cli 0.0.0

package/dist/cli.js

@@ -0,0 +1,1213 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import path4 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import { parseArgs } from "util";
+
+// src/extractors/git.ts
+import path from "path";
+
+// src/utils.ts
+import { execFileSync } from "child_process";
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function runGit(repoPath, args) {
+  return execFileSync("git", ["-C", repoPath, ...args], {
+    encoding: "utf-8",
+    maxBuffer: 50 * 1024 * 1024
+  });
+}
+function log(verbose, tag, msg) {
+  if (verbose) {
+    console.log(`[${tag}] ${msg}`);
+  }
+}
+function increment(record, key, amount = 1) {
+  record[key] = (record[key] ?? 0) + amount;
+}
+function topN(record, n) {
+  return Object.entries(record).sort((a, b) => b[1] - a[1]).slice(0, n);
+}
+
+// src/extractors/git.ts
+var CONVENTIONAL_RE = /^(\w+)(?:\(([^)]+)\))?[!]?:\s/;
+var DOMAIN_RULES = [
+  [/\.(vue|svelte|jsx|tsx|css|scss|sass|less)$/, "frontend"],
+  [/\.(go|rs|py|java|rb|php|cs|ex|exs)$/, "backend"],
+  [/(Dockerfile|\.tf|\.yaml|\.yml)/, "infrastructure"],
+  [/\.(test|spec)\.[^.]+$|__tests__\//, "testing"],
+  [/\.md$/, "documentation"],
+  [/(config|rc\.|\.config\.|tsconfig|vite\.config|eslint|prettier|package\.json)/, "tooling"]
+];
+function inferDomains(filesModified) {
+  const domainCounts = {};
+  for (const [filepath, count] of Object.entries(filesModified)) {
+    for (const [re, domain] of DOMAIN_RULES) {
+      if (re.test(filepath)) {
+        increment(domainCounts, domain, count);
+        break;
+      }
+    }
+  }
+  return topN(domainCounts, 4).filter(([, count]) => count >= 3).map(([domain]) => domain);
+}
+function profileFileTypes(filesModified) {
+  const profile = { tests: 0, configs: 0, components: 0, docs: 0, other: 0 };
+  for (const [filepath, count] of Object.entries(filesModified)) {
+    if (/\.(test|spec)\.[^.]+$|__tests__\//.test(filepath)) {
+      profile.tests += count;
+    } else if (/(config|rc\.|\.config\.|tsconfig|eslint|prettier)/.test(filepath)) {
+      profile.configs += count;
+    } else if (/\.(vue|svelte|jsx|tsx)$/.test(filepath)) {
+      profile.components += count;
+    } else if (/\.md$/.test(filepath)) {
+      profile.docs += count;
+    } else {
+      profile.other += count;
+    }
+  }
+  return profile;
+}
+function extractGitSignals(repoPath, contributor, email, verbose) {
+  const signals = {
+    commitMessages: [],
+    commitBodies: [],
+    filesCreated: [],
+    filesModified: {},
+    extensions: {},
+    namingPatterns: [],
+    commitCount: 0
+  };
+  const authorFilter = `--author=${email ?? contributor}`;
+  try {
+    const output = runGit(repoPath, [
+      "log",
+      authorFilter,
+      "--format=%s%x00%B%x01",
+      "--max-count=200"
+    ]);
+    const entries = output.split("
").filter(Boolean);
+    for (const entry of entries) {
+      const [subject, ...bodyParts] = entry.split("\0");
+      const trimmedSubject = subject.trim();
+      if (trimmedSubject) {
+        signals.commitMessages.push(trimmedSubject);
+        const body = bodyParts.join("\0").trim();
+        if (body && body !== trimmedSubject) {
+          signals.commitBodies.push(body);
+        }
+      }
+    }
+    signals.commitCount = signals.commitMessages.length;
+    log(verbose, "git", `Found ${signals.commitCount} commits`);
+  } catch (e) {
+    console.log(`[git] Warning: could not read commit messages \u2014 ${e}`);
+  }
+  try {
+    const output = runGit(repoPath, [
+      "log",
+      authorFilter,
+      "--diff-filter=A",
+      "--name-only",
+      "--format="
+    ]);
+    signals.filesCreated = output.split("\n").map((l) => l.trim()).filter(Boolean);
+    for (const f of signals.filesCreated) {
+      const ext = path.extname(f);
+      if (ext) increment(signals.extensions, ext);
+    }
+  } catch {
+  }
+  try {
+    const output = runGit(repoPath, [
+      "log",
+      authorFilter,
+      "--name-only",
+      "--format="
+    ]);
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed) increment(signals.filesModified, trimmed);
+    }
+  } catch {
+  }
+  try {
+    const output = runGit(repoPath, [
+      "log",
+      authorFilter,
+      "--max-count=50",
+      "-p",
+      "--no-merges"
+    ]);
+    signals.rawDiffOutput = output;
+    const addedLines = output.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1));
+    const nameRe = /\b(const|function|let|var|def|class)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    for (const line of addedLines) {
+      let match;
+      while ((match = nameRe.exec(line)) !== null) {
+        signals.namingPatterns.push(match[2]);
+      }
+    }
+  } catch {
+  }
+  return signals;
+}
+function summariseGit(signals) {
+  const obs = {};
+  const msgs = signals.commitMessages;
+  if (msgs.length > 0) {
+    const avgLen = msgs.reduce((sum, m) => sum + m.length, 0) / msgs.length;
+    const imperative = msgs.filter(
+      (m) => m[0] === m[0].toUpperCase() && !m.startsWith("fix") && !m.startsWith("add")
+    ).length;
+    obs.commitMessageAvgLength = Math.round(avgLen);
+    obs.commitMessageSample = msgs.slice(0, 5);
+    obs.likelyUsesImperativeMood = imperative > msgs.length * 0.5;
+    const prefixCounts = {};
+    const scopes = /* @__PURE__ */ new Set();
+    let conventionalCount = 0;
+    for (const msg of msgs) {
+      const match = msg.match(CONVENTIONAL_RE);
+      if (match) {
+        conventionalCount++;
+        increment(prefixCounts, match[1].toLowerCase());
+        if (match[2]) scopes.add(match[2]);
+      }
+    }
+    if (conventionalCount > msgs.length * 0.3) {
+      obs.conventionalCommitPrefixes = prefixCounts;
+      if (scopes.size > 0) {
+        obs.commitScopePatterns = [...scopes].slice(0, 10);
+      }
+    }
+  }
+  if (Object.keys(signals.extensions).length > 0) {
+    obs.primaryExtensions = topN(signals.extensions, 5);
+  }
+  if (Object.keys(signals.filesModified).length > 0) {
+    const topFiles = topN(signals.filesModified, 10);
+    const dirs = {};
+    for (const [filepath, count] of topFiles) {
+      const parts = filepath.split(path.sep);
+      if (parts.length > 1) {
+        increment(dirs, parts[0], count);
+      }
+    }
+    obs.primaryDirectories = topN(dirs, 5);
+    obs.inferredDomains = inferDomains(signals.filesModified);
+    obs.fileTypeProfile = profileFileTypes(signals.filesModified);
+  }
+  const names = signals.namingPatterns;
+  if (names.length > 0) {
+    const camel = names.filter((n) => /^[a-z][a-zA-Z]+$/.test(n)).length;
+    const pascal = names.filter((n) => /^[A-Z][a-zA-Z]+$/.test(n)).length;
+    const snake = names.filter((n) => n.includes("_")).length;
+    obs.namingStyle = {
+      camelCase: camel,
+      PascalCase: pascal,
+      snake_case: snake
+    };
+  }
+  return obs;
+}
+
+// src/extractors/code-style.ts
+var LANG_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".vue": "typescript",
+  ".svelte": "typescript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".java": "java",
+  ".php": "php"
+};
+var JS_TS = ["typescript", "javascript"];
+var TS_ONLY = ["typescript"];
+var PATTERN_RULES = [
+  // Imports
+  { category: "import_style", choice: "named_import", pattern: /^import\s+\{/, languages: JS_TS },
+  { category: "import_style", choice: "default_import", pattern: /^import\s+[A-Za-z_$][^\s{]*\s+from/, languages: JS_TS },
+  { category: "import_style", choice: "path_alias", pattern: /from\s+['"][@~]\//, languages: JS_TS },
+  { category: "import_style", choice: "relative_import", pattern: /from\s+['"]\.\.?\//, languages: JS_TS },
+  // Exports
+  { category: "export_style", choice: "named_export", pattern: /^export\s+(?:const|function|class|type|interface|enum)\s/, languages: JS_TS },
+  { category: "export_style", choice: "default_export", pattern: /^export\s+default\b/, languages: JS_TS },
+  { category: "export_style", choice: "re_export", pattern: /^export\s+\{[^}]*\}\s+from/, languages: JS_TS },
+  // Functions
+  { category: "function_style", choice: "arrow_function", pattern: /(?:const|let)\s+\w+\s*=\s*(?:async\s+)?\(/, languages: JS_TS },
+  { category: "function_style", choice: "function_declaration", pattern: /^(?:export\s+)?(?:async\s+)?function\s+\w/, languages: JS_TS },
+  // Async
+  { category: "async_style", choice: "async_await", pattern: /\bawait\s/, languages: [...JS_TS, "python"] },
+  { category: "async_style", choice: "then_chain", pattern: /\.then\s*\(/, languages: JS_TS },
+  // Control flow
+  { category: "control_flow", choice: "early_return", pattern: /^\s+if\s*\(.*\)\s*return\b/, languages: JS_TS },
+  { category: "control_flow", choice: "guard_clause", pattern: /^\s+if\s*\(!/, languages: JS_TS },
+  // Strings
+  { category: "string_style", choice: "template_literal", pattern: /`[^`]*\$\{/, languages: JS_TS },
+  // Modern operators
+  { category: "modern_operators", choice: "optional_chaining", pattern: /\?\.\w/, languages: JS_TS },
+  { category: "modern_operators", choice: "nullish_coalescing", pattern: /\?\?/, languages: JS_TS },
+  { category: "modern_operators", choice: "destructuring", pattern: /(?:const|let|var)\s+[\[{]/, languages: JS_TS },
+  // TypeScript types
+  { category: "type_definition", choice: "interface", pattern: /^(?:export\s+)?interface\s+\w/, languages: TS_ONLY },
+  { category: "type_definition", choice: "type_alias", pattern: /^(?:export\s+)?type\s+\w+\s*=/, languages: TS_ONLY },
+  { category: "enum_vs_union", choice: "enum", pattern: /^(?:export\s+)?(?:const\s+)?enum\s+\w/, languages: TS_ONLY },
+  { category: "enum_vs_union", choice: "union_type", pattern: /type\s+\w+\s*=\s*['"\w]+(?:\s*\|\s*['"\w]+){2,}/, languages: TS_ONLY },
+  { category: "type_features", choice: "as_const", pattern: /\bas\s+const\b/, languages: TS_ONLY },
+  { category: "type_features", choice: "generic_usage", pattern: /<[A-Z]\w*(?:,\s*[A-Z]\w*)*>/, languages: TS_ONLY },
+  { category: "type_features", choice: "explicit_return_type", pattern: /\)\s*:\s*(?:Promise<|void|string|number|boolean|\w+\[\])/, languages: TS_ONLY },
+  // Error handling
+  { category: "error_handling", choice: "try_catch", pattern: /^\s*(?:try\s*\{|\}\s*catch\s*\()/ },
+  { category: "error_handling", choice: "custom_error", pattern: /class\s+\w+Error\s+extends/ },
+  // Testing
+  { category: "test_structure", choice: "describe_it", pattern: /\b(?:describe|it)\s*\(/, languages: JS_TS },
+  { category: "test_structure", choice: "test_fn", pattern: /\btest\s*\(/, languages: JS_TS },
+  { category: "test_assertion", choice: "expect", pattern: /\bexpect\s*\(/, languages: JS_TS },
+  { category: "test_assertion", choice: "assert", pattern: /\bassert\.\w/, languages: [...JS_TS, "python"] },
+  // Architecture
+  { category: "composition_style", choice: "inheritance", pattern: /class\s+\w+\s+extends\s/, languages: JS_TS },
+  { category: "composition_style", choice: "composition", pattern: /\buse[A-Z]\w+\s*\(/, languages: JS_TS },
+  { category: "architecture", choice: "factory_function", pattern: /(?:create|make|build)[A-Z]\w+\s*\(/, languages: JS_TS },
+  { category: "architecture", choice: "event_pattern", pattern: /\.(?:on|emit|addEventListener|subscribe)\s*\(/, languages: JS_TS },
+  // Python-specific
+  { category: "python_style", choice: "type_hints", pattern: /def\s+\w+\(.*:\s*\w+/, languages: ["python"] },
+  { category: "python_style", choice: "list_comprehension", pattern: /\[.*\bfor\b.*\bin\b.*\]/, languages: ["python"] },
+  { category: "python_style", choice: "dataclass", pattern: /@dataclass/, languages: ["python"] },
+  { category: "python_style", choice: "f_string", pattern: /f['"].*\{/, languages: ["python"] }
+];
+var CATEGORY_LABELS = {
+  import_style: "Import Style",
+  export_style: "Export Style",
+  function_style: "Function Style",
+  async_style: "Async Style",
+  control_flow: "Control Flow",
+  string_style: "String Style",
+  modern_operators: "Modern Operators",
+  type_definition: "Type Definition",
+  enum_vs_union: "Enum vs Union",
+  type_features: "TypeScript Features",
+  error_handling: "Error Handling",
+  test_structure: "Test Structure",
+  test_assertion: "Test Assertions",
+  composition_style: "Composition Style",
+  architecture: "Architecture Patterns",
+  python_style: "Python Style"
+};
+var CHOICE_LABELS = {
+  named_import: "named imports",
+  default_import: "default imports",
+  path_alias: "path aliases (@/)",
+  relative_import: "relative imports",
+  named_export: "named exports",
+  default_export: "default exports",
+  re_export: "re-exports",
+  arrow_function: "arrow functions",
+  function_declaration: "function declarations",
+  async_await: "async/await",
+  then_chain: ".then() chains",
+  early_return: "early returns",
+  guard_clause: "guard clauses",
+  template_literal: "template literals",
+  optional_chaining: "optional chaining (?.)",
+  nullish_coalescing: "nullish coalescing (??)",
+  destructuring: "destructuring",
+  interface: "interfaces",
+  type_alias: "type aliases",
+  enum: "enums",
+  union_type: "union types",
+  as_const: "as const assertions",
+  generic_usage: "generics",
+  explicit_return_type: "explicit return types",
+  try_catch: "try/catch",
+  custom_error: "custom error classes",
+  describe_it: "describe/it blocks",
+  test_fn: "test() functions",
+  expect: "expect()",
+  assert: "assert",
+  inheritance: "class inheritance",
+  composition: "composables/hooks",
+  factory_function: "factory functions",
+  event_pattern: "event/pub-sub patterns",
+  type_hints: "type hints",
+  list_comprehension: "list comprehensions",
+  dataclass: "dataclasses",
+  f_string: "f-strings"
+};
+function detectLanguages(diffOutput) {
+  const langCounts = {};
+  const headerRe = /^diff --git a\/(.*?) b\//gm;
+  let match;
+  while ((match = headerRe.exec(diffOutput)) !== null) {
+    const filepath = match[1];
+    const dotIdx = filepath.lastIndexOf(".");
+    if (dotIdx === -1) continue;
+    const ext = filepath.slice(dotIdx);
+    const lang = LANG_MAP[ext];
+    if (lang) increment(langCounts, lang);
+  }
+  return Object.entries(langCounts).sort((a, b) => b[1] - a[1]).map(([lang]) => lang);
+}
+function extractCodeStyleFromDiff(diffOutput) {
+  const signals = {
+    counters: {},
+    detectedLanguages: detectLanguages(diffOutput),
+    totalLinesAnalyzed: 0
+  };
+  if (!diffOutput) return signals;
+  const langSet = new Set(signals.detectedLanguages);
+  const addedLines = diffOutput.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1));
+  signals.totalLinesAnalyzed = addedLines.length;
+  const activeRules = PATTERN_RULES.filter(
+    (rule) => !rule.languages || rule.languages.some((lang) => langSet.has(lang))
+  );
+  for (const line of addedLines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    for (const rule of activeRules) {
+      if (rule.pattern.test(trimmed)) {
+        if (!signals.counters[rule.category]) {
+          signals.counters[rule.category] = {};
+        }
+        increment(signals.counters[rule.category], rule.choice);
+      }
+    }
+  }
+  return signals;
+}
+function summariseCodeStyle(signals) {
+  const observations = [];
+  for (const [category, choices] of Object.entries(signals.counters)) {
+    const entries = Object.entries(choices).sort((a, b) => b[1] - a[1]);
+    const total = entries.reduce((sum, [, c]) => sum + c, 0);
+    if (total < 3) continue;
+    const [topChoice, topCount] = entries[0];
+    if (entries.length === 1) {
+      if (topCount >= 5) {
+        observations.push({
+          category: CATEGORY_LABELS[category] ?? category,
+          observation: `Frequently uses ${CHOICE_LABELS[topChoice] ?? topChoice} (${topCount} occurrences)`,
+          confidence: topCount >= 15 ? "strong" : "moderate"
+        });
+      }
+      continue;
+    }
+    const ratio = topCount / total;
+    if (ratio < 0.6) continue;
+    const confidence = ratio >= 0.8 ? "strong" : "moderate";
+    const pct = Math.round(ratio * 100);
+    const topLabel = CHOICE_LABELS[topChoice] ?? topChoice;
+    const runnerLabel = CHOICE_LABELS[entries[1][0]] ?? entries[1][0];
+    observations.push({
+      category: CATEGORY_LABELS[category] ?? category,
+      observation: `Prefers ${topLabel} over ${runnerLabel} (${pct}% of ${total})`,
+      confidence
+    });
+  }
+  observations.sort((a, b) => {
+    if (a.confidence !== b.confidence) return a.confidence === "strong" ? -1 : 1;
+    return a.category.localeCompare(b.category);
+  });
+  return {
+    observations,
+    primaryLanguage: signals.detectedLanguages[0],
+    totalLinesAnalyzed: signals.totalLinesAnalyzed
+  };
+}
+
+// src/extractors/gitlab.ts
+import { readFileSync } from "fs";
+
+// src/extractors/review-common.ts
+function summariseReview(signals) {
+  const obs = { source: signals.source };
+  const comments = signals.reviewComments;
+  if (comments.length === 0) return obs;
+  obs.totalReviewComments = signals.totalComments;
+  const lengths = signals.commentLengths;
+  obs.avgCommentLength = lengths.length > 0 ? Math.round(lengths.reduce((a, b) => a + b, 0) / lengths.length) : 0;
+  obs.tendsToBeBrief = obs.avgCommentLength < 120;
+  obs.usesSeverityPrefixes = { ...signals.severityPrefixes };
+  obs.questionRatio = Math.round(signals.questionComments / comments.length * 100) / 100;
+  const sorted = [...comments].sort((a, b) => a.length - b.length);
+  const n = sorted.length;
+  const indices = [
+    0,
+    Math.floor(n / 6),
+    Math.floor(n / 3),
+    Math.floor(n / 2),
+    Math.floor(2 * n / 3),
+    Math.floor(5 * n / 6),
+    n - 2,
+    n - 1
+  ];
+  obs.sampleComments = [
+    ...new Set(
+      indices.filter((i) => i >= 0 && i < n).map((i) => sorted[i])
+    )
+  ];
+  return obs;
+}
+
+// src/extractors/gitlab.ts
+function extractGitLabSignals(exportPath, contributor, verbose) {
+  const signals = {
+    reviewComments: [],
+    commentLengths: [],
+    severityPrefixes: {},
+    questionComments: 0,
+    totalComments: 0,
+    source: "gitlab"
+  };
+  let data;
+  try {
+    data = JSON.parse(readFileSync(exportPath, "utf-8"));
+  } catch (e) {
+    console.log(`[gitlab] Could not read export \u2014 ${e}`);
+    return signals;
+  }
+  const comments = [];
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (item && typeof item === "object") {
+        const obj = item;
+        if (Array.isArray(obj.notes)) {
+          comments.push(...obj.notes);
+        } else if (typeof obj.body === "string") {
+          comments.push(obj);
+        }
+      }
+    }
+  }
+  const contributorLower = contributor.toLowerCase();
+  const prefixRe = /^(nit|suggestion|blocking|question|thought|minor|major)[:\s]/i;
+  for (const comment of comments) {
+    const author = comment.author;
+    const authorName = String(author?.name ?? "");
+    if (!authorName.toLowerCase().includes(contributorLower)) continue;
+    const body = String(comment.body ?? "").trim();
+    if (!body) continue;
+    signals.reviewComments.push(body);
+    signals.commentLengths.push(body.length);
+    signals.totalComments += 1;
+    const prefixMatch = body.match(prefixRe);
+    if (prefixMatch) {
+      increment(signals.severityPrefixes, prefixMatch[1].toLowerCase());
+    }
+    if (body.endsWith("?") || body.toLowerCase().startsWith("do we") || body.toLowerCase().startsWith("should we")) {
+      signals.questionComments += 1;
+    }
+  }
+  log(verbose, "gitlab", `Found ${signals.totalComments} comments by ${contributor}`);
+  return signals;
+}
+function summariseGitLab(signals) {
+  return summariseReview(signals);
+}
+
+// src/extractors/github.ts
+var USER_AGENT = "poltergeist-cli/0.1.0";
+function parseGitHubUrl(url) {
+  const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+  if (!match) return null;
+  return { owner: match[1], repo: match[2] };
+}
+var apiCallCount = 0;
+var rateLimited = false;
+async function ghFetch(urlPath, opts) {
+  if (rateLimited) return null;
+  const url = urlPath.startsWith("https://") ? urlPath : `https://api.github.com${urlPath}`;
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": USER_AGENT
+  };
+  if (opts.token) {
+    headers.Authorization = `Bearer ${opts.token}`;
+  }
+  apiCallCount++;
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 403 || res.status === 429) {
+      rateLimited = true;
+      return null;
+    }
+    log(opts.verbose, "github", `API ${res.status} for ${url}`);
+    return null;
+  }
+  const remaining = res.headers.get("X-RateLimit-Remaining");
+  if (remaining && parseInt(remaining) <= 1) {
+    rateLimited = true;
+    console.log("[github] Rate limit exhausted \u2014 stopping API calls");
+  }
+  return res.json();
+}
+async function searchPRsWithComments(owner, repo, contributor, opts) {
+  const query = encodeURIComponent(
+    `repo:${owner}/${repo} commenter:${contributor} type:pr`
+  );
+  const data = await ghFetch(
+    `/search/issues?q=${query}&per_page=100&sort=updated&order=desc`,
+    opts
+  );
+  if (!data?.items) return [];
+  return data.items.map((item) => item.number);
+}
+async function fetchPRComments(owner, repo, prNumber, contributor, opts) {
+  const comments = [];
+  const contributorLower = contributor.toLowerCase();
+  const reviewComments = await ghFetch(
+    `/repos/${owner}/${repo}/pulls/${prNumber}/comments?per_page=100`,
+    opts
+  );
+  if (Array.isArray(reviewComments)) {
+    for (const c of reviewComments) {
+      if (c.user?.login?.toLowerCase() === contributorLower && c.body?.trim()) {
+        comments.push(c.body.trim());
+      }
+    }
+  }
+  if (rateLimited) return comments;
+  const reviews = await ghFetch(
+    `/repos/${owner}/${repo}/pulls/${prNumber}/reviews?per_page=100`,
+    opts
+  );
+  if (Array.isArray(reviews)) {
+    for (const r of reviews) {
+      if (r.user?.login?.toLowerCase() === contributorLower && r.body?.trim()) {
+        comments.push(r.body.trim());
+      }
+    }
+  }
+  return comments;
+}
+async function extractGitHubSignals(owner, repo, contributor, token, verbose) {
+  const signals = {
+    reviewComments: [],
+    commentLengths: [],
+    severityPrefixes: {},
+    questionComments: 0,
+    totalComments: 0,
+    source: "github"
+  };
+  const opts = { token, verbose };
+  apiCallCount = 0;
+  rateLimited = false;
+  const prefixRe = /^(nit|suggestion|blocking|question|thought|minor|major)[:\s]/i;
+  log(verbose, "github", "Searching for PRs with review comments...");
+  const prNumbers = await searchPRsWithComments(owner, repo, contributor, opts);
+  if (prNumbers.length === 0) {
+    console.log(
+      `[github] No PR review comments found for "${contributor}". Make sure --contributor matches the GitHub username.`
+    );
+    return signals;
+  }
+  log(
+    verbose,
+    "github",
+    `Found ${prNumbers.length} PRs with comments by ${contributor}`
+  );
+  const prCap = token ? 50 : 25;
+  const prsToFetch = prNumbers.slice(0, prCap);
+  if (prNumbers.length > prCap) {
+    console.log(
+      `[github] Sampling ${prCap} of ${prNumbers.length} PRs (use --github-token for more)`
+    );
+  }
+  for (const prNumber of prsToFetch) {
+    if (rateLimited) break;
+    const comments = await fetchPRComments(
+      owner,
+      repo,
+      prNumber,
+      contributor,
+      opts
+    );
+    for (const body of comments) {
+      signals.reviewComments.push(body);
+      signals.commentLengths.push(body.length);
+      signals.totalComments += 1;
+      const prefixMatch = body.match(prefixRe);
+      if (prefixMatch) {
+        increment(signals.severityPrefixes, prefixMatch[1].toLowerCase());
+      }
+      if (body.endsWith("?") || body.toLowerCase().startsWith("do we") || body.toLowerCase().startsWith("should we")) {
+        signals.questionComments += 1;
+      }
+    }
+  }
+  log(
+    verbose,
+    "github",
+    `Collected ${signals.totalComments} review comments (${apiCallCount} API calls)`
+  );
+  return signals;
+}
+
+// src/extractors/slack.ts
+import { readFileSync as readFileSync2, readdirSync } from "fs";
+import path2 from "path";
+function extractSlackSignals(exportDir, contributor, verbose) {
+  const signals = {
+    messages: [],
+    technicalMessages: []
+  };
+  const techKeywords = /\b(PR|MR|merge|review|component|composable|API|endpoint|refactor|naming|test|pattern|abstraction|type|interface|performance|bug|breaking)\b/i;
+  const contributorLower = contributor.toLowerCase();
+  let entries;
+  try {
+    entries = readdirSync(exportDir, { recursive: true, encoding: "utf-8" });
+  } catch {
+    return signals;
+  }
+  const jsonFiles = entries.filter((e) => e.endsWith(".json"));
+  for (const relPath of jsonFiles) {
+    const fullPath = path2.join(exportDir, relPath);
+    let messages;
+    try {
+      messages = JSON.parse(readFileSync2(fullPath, "utf-8"));
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(messages)) continue;
+    for (const msg of messages) {
+      if (!msg || typeof msg !== "object") continue;
+      const obj = msg;
+      const username = String(
+        obj.username ?? obj.user_profile?.display_name ?? ""
+      );
+      const text = String(obj.text ?? "").trim();
+      if (!text || !username.toLowerCase().includes(contributorLower)) continue;
+      if (text.length < 20 || text.startsWith(":")) continue;
+      signals.messages.push(text);
+      if (techKeywords.test(text)) {
+        signals.technicalMessages.push(text);
+      }
+    }
+  }
+  log(
+    verbose,
+    "slack",
+    `Found ${signals.messages.length} messages, ${signals.technicalMessages.length} technical`
+  );
+  return signals;
+}
+function summariseSlack(signals) {
+  const obs = {};
+  const tech = signals.technicalMessages;
+  if (tech.length === 0) return obs;
+  obs.technicalMessageCount = tech.length;
+  obs.sampleTechnicalMessages = tech.slice(0, 8);
+  return obs;
+}
+
+// src/extractors/docs.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import path3 from "path";
+function extractDocsSignals(docsDir, contributor, verbose) {
+  const signals = {
+    authoredDocs: [],
+    docExcerpts: []
+  };
+  const contributorLower = contributor.toLowerCase();
+  let entries;
+  try {
+    entries = readdirSync2(docsDir, { recursive: true, encoding: "utf-8" });
+  } catch {
+    return signals;
+  }
+  const mdFiles = entries.filter((e) => e.endsWith(".md"));
+  for (const relPath of mdFiles) {
+    const fullPath = path3.join(docsDir, relPath);
+    let content;
+    try {
+      content = readFileSync3(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const frontmatterMatch = content.slice(0, 500).match(/author[:\s]+(.+)/i);
+    if (frontmatterMatch && frontmatterMatch[1].toLowerCase().includes(contributorLower)) {
+      signals.authoredDocs.push(fullPath);
+      const paras = content.split("\n\n").map((p) => p.trim()).filter((p) => p.length > 100);
+      signals.docExcerpts.push(...paras.slice(0, 3));
+    }
+  }
+  log(verbose, "docs", `Found ${signals.authoredDocs.length} docs attributed to ${contributor}`);
+  return signals;
+}
+
+// src/generator.ts
+function formatPairs(pairs, suffix = "") {
+  return pairs.map(([name, count]) => `${name}${suffix} (${count})`).join(", ");
+}
+function dominantNamingStyle(style) {
+  const total = style.camelCase + style.PascalCase + style.snake_case;
+  if (total < 10) return null;
+  if (style.camelCase / total > 0.7) return "Strongly prefers camelCase";
+  if (style.snake_case / total > 0.7) return "Strongly prefers snake_case";
+  if (style.PascalCase / total > 0.7) return "Strongly prefers PascalCase";
+  return null;
+}
+function buildGhostMarkdown(input) {
+  const { contributor, slug, gitObs, codeStyleObs, reviewObs, slackObs, docsSignals, sourcesUsed } = input;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const domains = gitObs.inferredDomains?.length ? gitObs.inferredDomains.join(", ") : "_[fill in manually]_";
+  const lines = [
+    `# Contributor Soul: ${contributor}`,
+    "",
+    "## Identity",
+    `- **Slug**: ${slug}`,
+    "- **Role**: _[fill in manually]_",
+    `- **Primary domains**: ${domains}`,
+    `- **Soul last updated**: ${today}`,
+    `- **Sources used**: ${sourcesUsed.join(", ")}`,
+    "",
+    "---",
+    "",
+    "## Review Philosophy",
+    "",
+    "### What they care about most (ranked)",
+    "_[Fill in manually after reviewing the data below \u2014 re-order based on review comment patterns]_",
+    "1. Correctness",
+    "2. Naming",
+    "3. Component / module boundaries",
+    "4. Test coverage",
+    "5. Consistency with existing patterns",
+    "",
+    "### What they tend to ignore",
+    "_[Fill in manually]_",
+    "",
+    "### Dealbreakers",
+    "_[Fill in manually]_",
+    "",
+    "### Recurring questions / phrases"
+  ];
+  if (reviewObs.sampleComments && reviewObs.sampleComments.length > 0) {
+    const questions = reviewObs.sampleComments.filter((c) => c.endsWith("?"));
+    if (questions.length > 0) {
+      for (const q of questions.slice(0, 5)) {
+        const truncated = q.length > 150 ? q.slice(0, 150) + "..." : q;
+        lines.push(`- "${truncated}"`);
+      }
+    } else {
+      lines.push("_[Fill in from sample comments below]_");
+    }
+  } else {
+    lines.push("_[Fill in from sample comments below]_");
+  }
+  lines.push("", "---", "", "## Communication Style", "");
+  if (reviewObs.totalReviewComments != null) {
+    lines.push(
+      `- **Total review comments analysed**: ${reviewObs.totalReviewComments}`,
+      `- **Average comment length**: ${reviewObs.avgCommentLength ?? "N/A"} chars`,
+      `- **Tends to be brief**: ${reviewObs.tendsToBeBrief ?? "unknown"}`,
+      `- **Question ratio**: ${reviewObs.questionRatio ?? "N/A"} (proportion of comments phrased as questions)`
+    );
+    if (reviewObs.usesSeverityPrefixes && Object.keys(reviewObs.usesSeverityPrefixes).length > 0) {
+      const prefixes = Object.entries(reviewObs.usesSeverityPrefixes).map(([k, v]) => `${k} (${v})`).join(", ");
+      lines.push(`- **Severity prefixes used**: ${prefixes}`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    "### Tone",
+    "_[Fill in manually \u2014 direct? warm? collaborative? terse?]_",
+    "",
+    "### Severity prefixes they use"
+  );
+  if (reviewObs.usesSeverityPrefixes && Object.keys(reviewObs.usesSeverityPrefixes).length > 0) {
+    lines.push(
+      Object.keys(reviewObs.usesSeverityPrefixes).join(", ")
+    );
+  } else {
+    lines.push("_[Derived from comments above \u2014 fill in which they actually use]_");
+  }
+  lines.push(
+    "",
+    "### Vocabulary / phrases they use",
+    "_[Fill in from sample comments below]_",
+    "",
+    "---",
+    "",
+    "## Code Patterns",
+    ""
+  );
+  if (gitObs.primaryExtensions) {
+    lines.push(
+      `**Primary file types**: ${formatPairs(gitObs.primaryExtensions)}`
+    );
+  }
+  if (gitObs.primaryDirectories) {
+    lines.push(
+      `**Primary codebase areas**: ${formatPairs(gitObs.primaryDirectories, "/")}`
+    );
+  }
+  if (gitObs.namingStyle) {
+    const ns = gitObs.namingStyle;
+    lines.push(
+      `**Naming style**: camelCase (${ns.camelCase}), PascalCase (${ns.PascalCase}), snake_case (${ns.snake_case})`
+    );
+    const dominant = dominantNamingStyle(ns);
+    if (dominant) lines.push(`> ${dominant}`);
+  }
+  if (gitObs.fileTypeProfile) {
+    const p = gitObs.fileTypeProfile;
+    const parts = [
+      p.components && `components (${p.components})`,
+      p.tests && `tests (${p.tests})`,
+      p.configs && `configs (${p.configs})`,
+      p.docs && `docs (${p.docs})`,
+      p.other && `other (${p.other})`
+    ].filter(Boolean);
+    if (parts.length > 0) {
+      lines.push(`**File type profile**: ${parts.join(", ")}`);
+    }
+  }
+  if (gitObs.primaryExtensions || gitObs.primaryDirectories || gitObs.namingStyle || gitObs.fileTypeProfile) {
+    lines.push("");
+  }
+  if (codeStyleObs.observations.length > 0) {
+    lines.push("### Detected Code Style Preferences");
+    if (codeStyleObs.primaryLanguage) {
+      lines.push(
+        `_Primary language: ${codeStyleObs.primaryLanguage} \xB7 ${codeStyleObs.totalLinesAnalyzed} added lines analyzed_`
+      );
+    }
+    lines.push("");
+    for (const obs of codeStyleObs.observations) {
+      if (obs.confidence === "strong") {
+        lines.push(`- **${obs.category}**: ${obs.observation}`);
+      } else {
+        lines.push(`- ${obs.category}: ${obs.observation}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(
+    "### Patterns they introduce / prefer"
+  );
+  const namingInsight = gitObs.namingStyle ? dominantNamingStyle(gitObs.namingStyle) : null;
+  if (namingInsight) {
+    lines.push(`- ${namingInsight}`);
+  }
+  lines.push(
+    "_[Fill in manually from code inspection and review comment themes]_",
+    "",
+    "### Patterns they push back on",
+    "_[Fill in manually]_",
+    "",
+    "---",
+    "",
+    "## Known Blind Spots",
+    "_[Fill in manually \u2014 areas they historically under-comment on]_",
+    "",
+    "---",
+    "",
+    "## Example Review Comments",
+    "_These ground Claude's output in their actual voice. Aim for 5\u201310 verbatim examples._",
+    ""
+  );
+  if (reviewObs.sampleComments && reviewObs.sampleComments.length > 0) {
+    for (const comment of reviewObs.sampleComments) {
+      const truncated = comment.length > 300 ? comment.slice(0, 300) + "..." : comment;
+      lines.push(`> ${truncated}`, "");
+    }
+  }
+  lines.push("---", "", "## Commit Message Style", "");
+  if (gitObs.commitMessageAvgLength != null) {
+    lines.push(`- **Avg length**: ${gitObs.commitMessageAvgLength} chars`);
+    lines.push(
+      `- **Uses imperative mood**: ${gitObs.likelyUsesImperativeMood ?? "unknown"}`
+    );
+    if (gitObs.conventionalCommitPrefixes) {
+      const prefixStr = Object.entries(gitObs.conventionalCommitPrefixes).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} (${v})`).join(", ");
+      lines.push(`- **Conventional commits**: yes \u2014 ${prefixStr}`);
+      if (gitObs.commitScopePatterns && gitObs.commitScopePatterns.length > 0) {
+        lines.push(
+          `- **Common scopes**: ${gitObs.commitScopePatterns.join(", ")}`
+        );
+      }
+    }
+    if (gitObs.commitMessageSample) {
+      lines.push("- **Sample messages**:");
+      for (const msg of gitObs.commitMessageSample) {
+        lines.push(`  - \`${msg}\``);
+      }
+    }
+    lines.push("");
+  }
+  if (slackObs.sampleTechnicalMessages && slackObs.sampleTechnicalMessages.length > 0) {
+    lines.push("---", "", "## Slack / Chat Voice (technical messages)", "");
+    for (const msg of slackObs.sampleTechnicalMessages) {
+      const truncated = msg.length > 200 ? msg.slice(0, 200) + "..." : msg;
+      lines.push(`> ${truncated}`, "");
+    }
+  }
+  lines.push("---", "", "## Docs Authored", "");
+  if (docsSignals.authoredDocs.length > 0) {
+    for (const doc of docsSignals.authoredDocs) {
+      lines.push(`- \`${doc}\``);
+    }
+  } else {
+    lines.push("_None found or docs-dir not provided._");
+  }
+  lines.push(
+    "",
+    "---",
+    "",
+    "<!-- Generated by @poltergeist-ai/cli -->",
+    `<!-- Run date: ${today} -->`
+  );
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var POLTERGEIST_DIR = ".poltergeist";
+var CACHE_DIR = `${POLTERGEIST_DIR}/repos`;
+var GHOSTS_DIR = `${POLTERGEIST_DIR}/ghosts`;
+function ensureReposGitignored() {
+  const gitignorePath = ".gitignore";
+  const entry = ".poltergeist/repos/";
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync4(gitignorePath, "utf-8");
+    if (content.includes(entry)) return;
+    appendFileSync(gitignorePath, `
+# Poltergeist cached clones
+${entry}
+`);
+  } else {
+    writeFileSync(gitignorePath, `# Poltergeist cached clones
+${entry}
+`);
+  }
+}
+function printUsage() {
+  console.log(`Usage: poltergeist [extract] [options]
+
+Build a contributor ghost profile from data sources.
+
+Options:
+  --contributor <name>    Contributor name (required; use GitHub username for best results)
+  --email <email>         Contributor email (for git log filtering)
+  --slug <slug>           Output slug (default: derived from name)
+  --git-repo <path|url>   Path to local git repo or remote URL (cloned to .poltergeist/repos/)
+  --gitlab-export <path>  Path to GitLab MR comments JSON export
+  --slack-export <path>   Path to Slack export directory
+  --docs-dir <path>       Path to design docs / ADRs directory
+  --github-token <token>  GitHub personal access token (for higher API rate limits)
+  --output <path>         Output path (default: .poltergeist/ghosts/<slug>.md)
+  --verbose               Enable verbose logging
+  --help                  Show this help message`);
+}
+function isRemoteUrl(value) {
+  return value.startsWith("https://") || value.startsWith("http://") || value.startsWith("git@");
+}
+function repoSlug(url) {
+  return url.replace(/\.git$/, "").replace(/^https?:\/\//, "").replace(/^git@/, "").replace(/[/:]+/g, "-").replace(/^-|-$/g, "");
+}
+function resolveGitRepo(value, verbose) {
+  if (!isRemoteUrl(value)) return value;
+  const slug = repoSlug(value);
+  const cloneDir = path4.join(CACHE_DIR, slug);
+  if (existsSync(cloneDir)) {
+    console.log(`[extract] Using cached clone at ${cloneDir}`);
+    try {
+      execFileSync2("git", ["-C", cloneDir, "fetch", "--quiet"], {
+        encoding: "utf-8",
+        stdio: verbose ? "inherit" : "pipe",
+        timeout: 6e4
+      });
+    } catch {
+      console.log("[extract] Warning: fetch failed, using existing cache");
+    }
+    return cloneDir;
+  }
+  console.log(`[extract] Cloning ${value} into ${cloneDir}...`);
+  mkdirSync(CACHE_DIR, { recursive: true });
+  ensureReposGitignored();
+  execFileSync2(
+    "git",
+    ["clone", "--bare", "--filter=blob:none", value, cloneDir],
+    {
+      encoding: "utf-8",
+      stdio: verbose ? "inherit" : "pipe",
+      timeout: 12e4
+    }
+  );
+  return cloneDir;
+}
+async function run() {
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs.length === 0 || rawArgs[0] === "--help" || rawArgs[0] === "-h") {
+    printUsage();
+    return 0;
+  }
+  const args = rawArgs[0] === "extract" ? rawArgs.slice(1) : rawArgs;
+  const { values } = parseArgs({
+    args,
+    options: {
+      contributor: { type: "string" },
+      email: { type: "string" },
+      slug: { type: "string" },
+      "git-repo": { type: "string" },
+      "gitlab-export": { type: "string" },
+      "slack-export": { type: "string" },
+      "docs-dir": { type: "string" },
+      "github-token": { type: "string" },
+      output: { type: "string" },
+      verbose: { type: "boolean", default: false },
+      help: { type: "boolean", default: false }
+    },
+    strict: true
+  });
+  if (values.help) {
+    printUsage();
+    return 0;
+  }
+  if (!values.contributor) {
+    console.error("Error: --contributor is required.");
+    printUsage();
+    return 1;
+  }
+  const contributor = values.contributor;
+  const email = values.email;
+  const slug = values.slug ?? slugify(contributor);
+  const outputPath = values.output ?? `${GHOSTS_DIR}/${slug}.md`;
+  const verbose = values.verbose ?? false;
+  const githubToken = values["github-token"];
+  const sourcesUsed = [];
+  let gitObs = {};
+  let codeStyleObs = { observations: [], totalLinesAnalyzed: 0 };
+  let reviewObs = {};
+  let slackObs = {};
+  let docsSignals = { authoredDocs: [], docExcerpts: [] };
+  if (values["git-repo"]) {
+    const repoPath = resolveGitRepo(values["git-repo"], verbose);
+    console.log(`[extract] Mining git history in ${repoPath}...`);
+    const gitSignals = extractGitSignals(
+      repoPath,
+      contributor,
+      email,
+      verbose
+    );
+    gitObs = summariseGit(gitSignals);
+    if (gitSignals.rawDiffOutput) {
+      const codeStyleSignals = extractCodeStyleFromDiff(gitSignals.rawDiffOutput);
+      codeStyleObs = summariseCodeStyle(codeStyleSignals);
+    }
+    sourcesUsed.push("git-history");
+    const ghParsed = parseGitHubUrl(values["git-repo"]);
+    if (ghParsed) {
+      console.log(
+        `[extract] Fetching GitHub PR review comments for ${contributor}...`
+      );
+      try {
+        const ghSignals = await extractGitHubSignals(
+          ghParsed.owner,
+          ghParsed.repo,
+          contributor,
+          githubToken,
+          verbose
+        );
+        if (ghSignals.totalComments > 0) {
+          reviewObs = summariseReview(ghSignals);
+          sourcesUsed.push("github-pr-comments");
+        }
+      } catch (e) {
+        console.log(`[github] Warning: could not fetch PR comments \u2014 ${e}`);
+      }
+    }
+  }
+  if (values["gitlab-export"]) {
+    console.log(
+      `[extract] Parsing GitLab comment export ${values["gitlab-export"]}...`
+    );
+    const gitlabSignals = extractGitLabSignals(
+      values["gitlab-export"],
+      contributor,
+      verbose
+    );
+    const gitlabObs = summariseGitLab(gitlabSignals);
+    if (reviewObs.totalReviewComments && gitlabObs.totalReviewComments) {
+      reviewObs.sampleComments = [
+        ...reviewObs.sampleComments ?? [],
+        ...gitlabObs.sampleComments ?? []
+      ].slice(0, 10);
+      reviewObs.totalReviewComments += gitlabObs.totalReviewComments;
+    } else if (gitlabObs.totalReviewComments) {
+      reviewObs = gitlabObs;
+    }
+    sourcesUsed.push("gitlab-comments");
+  }
+  if (values["slack-export"]) {
+    console.log(
+      `[extract] Scanning Slack export ${values["slack-export"]}...`
+    );
+    const slackSignals = extractSlackSignals(
+      values["slack-export"],
+      contributor,
+      verbose
+    );
+    slackObs = summariseSlack(slackSignals);
+    sourcesUsed.push("slack-export");
+  }
+  if (values["docs-dir"]) {
+    console.log(`[extract] Scanning docs in ${values["docs-dir"]}...`);
+    docsSignals = extractDocsSignals(values["docs-dir"], contributor, verbose);
+    sourcesUsed.push("docs");
+  }
+  if (sourcesUsed.length === 0) {
+    console.error(
+      "Error: no data sources provided. Use --git-repo, --gitlab-export, --slack-export, or --docs-dir."
+    );
+    return 1;
+  }
+  console.log(
+    `[extract] Building ghost file for ${contributor} (slug: ${slug})...`
+  );
+  const ghostMd = buildGhostMarkdown({
+    contributor,
+    slug,
+    gitObs,
+    codeStyleObs,
+    reviewObs,
+    slackObs,
+    docsSignals,
+    sourcesUsed
+  });
+  const dir = path4.dirname(outputPath);
+  if (dir && dir !== ".") {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(outputPath, ghostMd);
+  console.log(`
+Ghost draft written to: ${outputPath}`);
+  console.log("\nNext steps:");
+  console.log(
+    "  1. Open the file and fill in all [fill in manually] sections"
+  );
+  console.log(
+    "  2. Review the sample comments \u2014 they're the most important voice signal"
+  );
+  console.log(
+    "  3. Validate with a team member who knows this contributor"
+  );
+  console.log(
+    `  4. Run a test review: claude 'Review as @${slug}' < git diff main`
+  );
+  return 0;
+}
+run().then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(err);
+    process.exit(1);
+  }
+);