gitpulse-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1202 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/ui/logo.ts
+import chalk from "chalk";
+var LOGO = `
+   _____ _ _   _____       _
+  / ____(_) | |  __ \\     | |
+ | |  __ _| |_| |__) |   _| |___  ___
+ | | |_ | | __|  ___/ | | | / __|/ _ \\
+ | |__| | | |_| |   | |_| | \\__ \\  __/
+  \\_____|_|\\__|_|    \\__,_|_|___/\\___|
+`;
+function printLogo() {
+  console.log(chalk.hex("#6366f1")(LOGO));
+  console.log(chalk.dim("  AI-Powered Git Contribution Analyzer\n"));
+}
+
+// src/utils/version.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+function getVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  let dir = path.dirname(__filename);
+  for (let i = 0; i < 10; i++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      return pkg.version ?? "0.0.0";
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "0.0.0";
+}
+
+// src/commands/analyze.ts
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { confirm, select, input } from "@inquirer/prompts";
+import {
+  Analyzer,
+  createProvider,
+  generateReport,
+  loadConfig,
+  HomeManager
+} from "@gitpulse/core";
+
+// src/ui/theme.ts
+import chalk2 from "chalk";
+var theme = {
+  primary: chalk2.hex("#6366f1"),
+  secondary: chalk2.hex("#8b5cf6"),
+  success: chalk2.hex("#22c55e"),
+  warning: chalk2.hex("#f59e0b"),
+  error: chalk2.hex("#ef4444"),
+  info: chalk2.hex("#3b82f6"),
+  dim: chalk2.dim,
+  bold: chalk2.bold,
+  heading: chalk2.bold.hex("#6366f1"),
+  prompt: chalk2.hex("#6366f1").bold,
+  score: (score) => {
+    if (score >= 80) return chalk2.hex("#22c55e")(score.toFixed(1));
+    if (score >= 60) return chalk2.hex("#3b82f6")(score.toFixed(1));
+    if (score >= 40) return chalk2.hex("#f59e0b")(score.toFixed(1));
+    return chalk2.hex("#ef4444")(score.toFixed(1));
+  },
+  trend: (direction) => {
+    switch (direction) {
+      case "improving":
+        return chalk2.hex("#22c55e")("\u25B2 improving");
+      case "declining":
+        return chalk2.hex("#ef4444")("\u25BC declining");
+      case "stable":
+        return chalk2.hex("#94a3b8")("\u25BA stable");
+    }
+  }
+};
+
+// src/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text: theme.dim(text),
+    color: "cyan"
+  });
+}
+function phaseSpinner(phase, totalPhases, text) {
+  return createSpinner(`[Phase ${phase}/${totalPhases}] ${text}`);
+}
+
+// src/ui/table.ts
+import Table from "cli-table3";
+function renderScoreTable(report) {
+  const table = new Table({
+    head: [
+      theme.bold("Author"),
+      theme.bold("Overall"),
+      theme.bold("Code Quality"),
+      theme.bold("Complexity"),
+      theme.bold("Discipline"),
+      theme.bold("Collab"),
+      theme.bold("Trend"),
+      theme.bold("Commits")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    }
+  });
+  for (const author of report.authors) {
+    const s = author.score;
+    table.push([
+      s.authorName,
+      theme.score(s.overallScore),
+      theme.score(s.dimensionScores.codeQuality.score),
+      theme.score(s.dimensionScores.complexityImpact.score),
+      theme.score(s.dimensionScores.commitDiscipline.score),
+      theme.score(s.dimensionScores.collaboration.score),
+      theme.trend(s.trend.direction),
+      String(s.scoredCommitCount)
+    ]);
+  }
+  console.log(table.toString());
+}
+function renderSummaryTable(report) {
+  const table = new Table({
+    style: { head: [], border: ["dim"] }
+  });
+  table.push(
+    { [theme.bold("Total Commits")]: String(report.metadata.totalCommits) },
+    { [theme.bold("Analyzed")]: String(report.metadata.analyzedCommits) },
+    { [theme.bold("Cached")]: String(report.metadata.cachedCommits) },
+    { [theme.bold("Skipped")]: String(report.metadata.skippedCommits) },
+    { [theme.bold("Authors")]: String(report.summary.totalAuthors) },
+    { [theme.bold("Average Score")]: theme.score(report.summary.averageScore) },
+    { [theme.bold("Top Performer")]: report.summary.topPerformer }
+  );
+  console.log(table.toString());
+}
+
+// src/ui/progress.ts
+import cliProgress from "cli-progress";
+function createProgressBar(total) {
+  const bar = new cliProgress.SingleBar({
+    format: `  ${theme.primary("{bar}")} {value}/{total} ({percentage}%) | {message}`,
+    barCompleteChar: "\u2588",
+    barIncompleteChar: "\u2591",
+    hideCursor: true
+  });
+  bar.start(total, 0, { message: "" });
+  return bar;
+}
+
+// src/utils/error-handler.ts
+function handleError(error) {
+  if (error instanceof Error) {
+    console.error(`
+${theme.error("Error:")} ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(theme.dim(error.stack ?? ""));
+    }
+  } else {
+    console.error(`
+${theme.error("Error:")} An unexpected error occurred`);
+  }
+  process.exit(1);
+}
+function handleReplError(error) {
+  if (error instanceof Error) {
+    console.error(`
+${theme.error("Error:")} ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(theme.dim(error.stack ?? ""));
+    }
+  } else {
+    console.error(`
+${theme.error("Error:")} An unexpected error occurred`);
+  }
+}
+
+// src/utils/remote-repo.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+import * as os from "os";
+import * as crypto from "crypto";
+import simpleGit from "simple-git";
+var REMOTE_URL_RE = /^(?:https?:\/\/|git@|ssh:\/\/|git:\/\/)/;
+function isRemoteUrl(input4) {
+  return REMOTE_URL_RE.test(input4);
+}
+function repoSlug(url) {
+  const cleaned = url.replace(/^(?:https?:\/\/|git@|ssh:\/\/|git:\/\/)/, "").replace(/\.git\/?$/, "").replace(/:/g, "/").replace(/\/+$/, "");
+  const slug = cleaned.replace(/[^a-zA-Z0-9_.-]/g, "-").replace(/-+/g, "-");
+  const hash = crypto.createHash("sha256").update(url).digest("hex").slice(0, 8);
+  return `${slug}-${hash}`;
+}
+function getCacheDir() {
+  return path2.join(os.homedir(), ".gitpulse", "repos");
+}
+async function resolveRepoPath(input4) {
+  if (!isRemoteUrl(input4)) {
+    return { localPath: input4 };
+  }
+  const slug = repoSlug(input4);
+  const cacheDir = getCacheDir();
+  const localPath = path2.join(cacheDir, slug);
+  fs2.mkdirSync(cacheDir, { recursive: true });
+  if (fs2.existsSync(path2.join(localPath, ".git"))) {
+    console.log(theme.dim(`Using cached clone at ${localPath}`));
+    console.log(theme.dim("Fetching latest changes..."));
+    try {
+      const git = simpleGit(localPath);
+      await git.fetch(["--all"]);
+      console.log(theme.success("Fetch complete.\n"));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(theme.warning(`Fetch failed (using cached clone): ${msg}
+`));
+    }
+  } else {
+    console.log(theme.dim(`Cloning ${input4}...`));
+    const git = simpleGit();
+    await git.clone(input4, localPath);
+    console.log(theme.success("Clone complete.\n"));
+  }
+  return { localPath };
+}
+
+// src/commands/analyze.ts
+async function analyzeCommandInner(repoPath, options) {
+  const { localPath } = await resolveRepoPath(repoPath);
+  const absolutePath = path3.resolve(localPath);
+  const home = new HomeManager();
+  home.ensureInitialized();
+  const overrides = {};
+  if (options.provider) overrides.provider = options.provider;
+  if (options.model) overrides.model = options.model;
+  const config = await loadConfig(absolutePath, overrides);
+  const format = options.format ?? config.output.format;
+  const model = await createProvider({
+    type: config.provider,
+    model: config.model,
+    apiKey: config.apiKey,
+    baseURL: config.baseURL
+  });
+  const analyzer = await Analyzer.create(absolutePath, {
+    config,
+    model,
+    noCache: options.noCache
+  });
+  const scope = {
+    branch: options.branch,
+    since: options.since,
+    until: options.until,
+    authors: options.author,
+    maxCommits: options.maxCommits,
+    path: absolutePath
+  };
+  if (!options.since && !options.until && !options.yes) {
+    const fmt = (d) => d.toISOString().slice(0, 10);
+    const ago = (months) => {
+      const d = /* @__PURE__ */ new Date();
+      d.setMonth(d.getMonth() - months);
+      return fmt(d);
+    };
+    const range = await select({
+      message: "Select time range for analysis:",
+      choices: [
+        { name: "Last month", value: "last-1" },
+        { name: "Last 3 months", value: "last-3" },
+        { name: "Last 6 months", value: "last-6" },
+        { name: "Last year", value: "last-12" },
+        { name: "All time (no filter)", value: "all" },
+        { name: "Custom range...", value: "custom" }
+      ]
+    });
+    if (range === "custom") {
+      const customSince = await input({ message: "Since (YYYY-MM-DD, leave empty for none):" });
+      const customUntil = await input({ message: "Until (YYYY-MM-DD, leave empty for none):" });
+      if (customSince) scope.since = customSince;
+      if (customUntil) scope.until = customUntil;
+    } else if (range !== "all") {
+      const months = parseInt(range.split("-")[1], 10);
+      scope.since = ago(months);
+    }
+  }
+  const estimate = await analyzer.estimate(scope);
+  console.log(theme.heading("\nAnalysis Summary:"));
+  console.log(`   Total commits:     ${estimate.totalCommits}`);
+  console.log(`   Cached (skip):     ${estimate.cachedCommits}`);
+  console.log(`   To analyze:        ${estimate.toAnalyze}`);
+  console.log(`   Est. LLM calls:    ~${estimate.estimatedLlmCalls}`);
+  console.log(`   Est. tokens:       ~${(estimate.estimatedTokens / 1e3).toFixed(0)}K`);
+  console.log(`   Est. cost:         ~$${estimate.estimatedCost.toFixed(2)}`);
+  console.log("");
+  if (estimate.toAnalyze === 0) {
+    console.log(theme.success("All commits are cached. Generating report from cache.\n"));
+  } else if (!options.yes) {
+    const proceed = await confirm({ message: "Proceed with analysis?", default: true });
+    if (!proceed) {
+      console.log(theme.dim("Analysis cancelled."));
+      return;
+    }
+  }
+  const startTime = Date.now();
+  let currentSpinner = phaseSpinner(1, 3, "Extracting commits");
+  currentSpinner.start();
+  const state = { progressBar: null };
+  const onProgress = (progress) => {
+    if (progress.phase === "extracting") {
+      currentSpinner.text = theme.dim(
+        `[Phase 1/3] ${progress.message}`
+      );
+    } else if (progress.phase === "scoring") {
+      if (currentSpinner.isSpinning) {
+        currentSpinner.succeed(theme.dim("Commits extracted"));
+      }
+      if (!state.progressBar && progress.total > 0) {
+        console.log(theme.dim(`
+  Scoring commits [Phase 2/3]:`));
+        state.progressBar = createProgressBar(progress.total);
+      }
+      if (state.progressBar) {
+        state.progressBar.update(progress.current, { message: progress.message });
+      }
+    } else if (progress.phase === "aggregating") {
+      if (state.progressBar) {
+        state.progressBar.stop();
+        state.progressBar = null;
+      }
+      if (currentSpinner.isSpinning) {
+        currentSpinner.succeed(theme.dim("Scoring complete"));
+      }
+      currentSpinner = phaseSpinner(3, 3, "Aggregating results");
+      currentSpinner.start();
+    }
+  };
+  const report = await analyzer.analyze(scope, onProgress);
+  if (state.progressBar) state.progressBar.stop();
+  if (currentSpinner.isSpinning) {
+    currentSpinner.succeed(theme.dim("Report generated"));
+  }
+  const durationMs = Date.now() - startTime;
+  try {
+    home.recordAnalysis(report, scope, durationMs, estimate);
+    home.updateMemory(report);
+  } catch {
+  }
+  if (format === "terminal") {
+    console.log(theme.heading("\nResults:\n"));
+    renderSummaryTable(report);
+    console.log("");
+    renderScoreTable(report);
+    for (const author of report.authors) {
+      console.log(`
+${theme.bold(author.score.authorName)}`);
+      console.log(`  Score: ${theme.score(author.score.overallScore)}/100 | Trend: ${theme.trend(author.score.trend.direction)}`);
+      if (author.highlights.length > 0) {
+        console.log(`  Highlights: ${author.highlights.join(", ")}`);
+      }
+      if (author.recommendations.length > 0) {
+        console.log(`  Recommendations: ${author.recommendations.join(", ")}`);
+      }
+    }
+  } else {
+    const output = generateReport(report, format);
+    if (options.output) {
+      const outputPath = path3.resolve(options.output);
+      fs3.writeFileSync(outputPath, output, "utf-8");
+      console.log(theme.success(`
+Report saved to ${outputPath}`));
+    } else {
+      console.log(output);
+    }
+  }
+  console.log("");
+}
+async function analyzeCommand(repoPath, options) {
+  try {
+    await analyzeCommandInner(repoPath, options);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/commands/report.ts
+import * as path4 from "path";
+import * as fs4 from "fs";
+import {
+  CacheManager,
+  loadConfig as loadConfig2,
+  generateReport as generateReport2,
+  loadAllRubrics,
+  computeRubricHash
+} from "@gitpulse/core";
+async function reportCommandInner(repoPath, options) {
+  const { localPath } = await resolveRepoPath(repoPath);
+  const absolutePath = path4.resolve(localPath);
+  const config = await loadConfig2(absolutePath);
+  const format = options.format ?? config.output.format;
+  const rubrics = loadAllRubrics(absolutePath);
+  const rubricHash = computeRubricHash(rubrics);
+  const cache = new CacheManager(absolutePath);
+  const cached = cache.getAllCached(rubricHash);
+  if (cached.size === 0) {
+    console.log(theme.warning("No cached scores found. Run `gitpulse analyze` first."));
+    return;
+  }
+  console.log(theme.dim(`Found ${cached.size} cached commit scores.
+`));
+  const commitScores = Array.from(cached.values());
+  const report = buildReportFromCache(commitScores, absolutePath, config.provider, config.model, config.scoring.weights);
+  if (format === "terminal") {
+    renderSummaryTable(report);
+    console.log("");
+    renderScoreTable(report);
+  } else {
+    const output = generateReport2(report, format);
+    if (options.output) {
+      const outputPath = path4.resolve(options.output);
+      fs4.writeFileSync(outputPath, output, "utf-8");
+      console.log(theme.success(`Report saved to ${outputPath}`));
+    } else {
+      console.log(output);
+    }
+  }
+}
+async function reportCommand(repoPath, options) {
+  try {
+    await reportCommandInner(repoPath, options);
+  } catch (error) {
+    handleError(error);
+  }
+}
+function buildReportFromCache(scores, repoPath, provider, model, weights) {
+  return {
+    metadata: {
+      generatedAt: /* @__PURE__ */ new Date(),
+      repositoryPath: repoPath,
+      scope: {},
+      dimensionWeights: weights,
+      totalCommits: scores.length,
+      analyzedCommits: scores.length,
+      cachedCommits: scores.length,
+      skippedCommits: 0,
+      llmProvider: provider,
+      llmModel: model
+    },
+    summary: {
+      averageScore: scores.reduce((s, c) => s + c.overallScore, 0) / scores.length,
+      medianScore: [...scores].sort((a, b) => a.overallScore - b.overallScore)[Math.floor(scores.length / 2)]?.overallScore ?? 0,
+      topPerformer: "N/A (from cache)",
+      totalAuthors: 0,
+      dateRange: { start: /* @__PURE__ */ new Date(), end: /* @__PURE__ */ new Date() }
+    },
+    authors: [],
+    commitScores: scores
+  };
+}
+
+// src/commands/config.ts
+import { loadConfig as loadConfig3, HomeManager as HomeManager2 } from "@gitpulse/core";
+
+// src/wizard/setup.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { select as select2, input as input2, confirm as confirm2 } from "@inquirer/prompts";
+async function runSetupWizard(targetDir) {
+  console.log(theme.heading("\nGitPulse Configuration Wizard\n"));
+  const provider = await select2({
+    message: "Select your LLM provider:",
+    choices: [
+      { value: "openai", name: "OpenAI (GPT-4o, GPT-4o-mini)" },
+      { value: "anthropic", name: "Anthropic (Claude)" },
+      { value: "google", name: "Google (Gemini)" },
+      { value: "vertex", name: "Google Vertex AI (Gemini via Vertex)" },
+      { value: "custom", name: "Custom (OpenAI-compatible endpoint)" }
+    ]
+  });
+  const defaultModels = {
+    openai: "gpt-4o",
+    anthropic: "claude-sonnet-4-20250514",
+    google: "gemini-1.5-pro",
+    vertex: "gemini-1.5-pro",
+    custom: "default"
+  };
+  const model = await input2({
+    message: "Model name:",
+    default: defaultModels[provider] ?? "gpt-4o"
+  });
+  let baseURL;
+  if (provider === "custom") {
+    baseURL = await input2({
+      message: "Base URL for the API:",
+      validate: (v) => {
+        try {
+          new URL(v);
+          return true;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+  }
+  const envVarNames = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    google: "GOOGLE_GENERATIVE_AI_API_KEY",
+    vertex: "GOOGLE_VERTEX_API_KEY",
+    custom: "API_KEY"
+  };
+  const envVar = envVarNames[provider] ?? "API_KEY";
+  console.log(
+    theme.dim(
+      `
+Tip: Set your API key via the ${theme.info(envVar)} environment variable.
+`
+    )
+  );
+  const customize = await confirm2({
+    message: "Customize scoring weights?",
+    default: false
+  });
+  let weights = {
+    codeQuality: 0.3,
+    complexityImpact: 0.25,
+    commitDiscipline: 0.25,
+    collaboration: 0.2
+  };
+  if (customize) {
+    console.log(theme.dim("Enter weights (must sum to 1.0):"));
+    const cq = await input2({ message: "Code Quality weight:", default: "0.30" });
+    const ci = await input2({ message: "Complexity & Impact weight:", default: "0.25" });
+    const cd = await input2({ message: "Commit Discipline weight:", default: "0.25" });
+    const co = await input2({ message: "Collaboration weight:", default: "0.20" });
+    weights = {
+      codeQuality: parseFloat(cq),
+      complexityImpact: parseFloat(ci),
+      commitDiscipline: parseFloat(cd),
+      collaboration: parseFloat(co)
+    };
+  }
+  const config = buildConfigYaml(provider, model, baseURL, weights);
+  const configPath = path5.join(targetDir, ".gitpulse.yml");
+  fs5.writeFileSync(configPath, config, "utf-8");
+  console.log(theme.success(`
+Configuration saved to ${configPath}`));
+}
+function buildConfigYaml(provider, model, baseURL, weights) {
+  let yaml = `# GitPulse Configuration
+provider: ${provider}
+model: ${model}
+`;
+  if (baseURL) {
+    yaml += `baseURL: ${baseURL}
+`;
+  }
+  yaml += `
+scoring:
+  weights:
+    codeQuality: ${weights.codeQuality}
+    complexityImpact: ${weights.complexityImpact}
+    commitDiscipline: ${weights.commitDiscipline}
+    collaboration: ${weights.collaboration}
+  timeDecay: false
+  maxTokensPerDiff: 8000
+
+analysis:
+  maxConcurrency: 3
+  skipMergeCommits: true
+  skipLockFiles: true
+  skipAutoGenerated: true
+
+output:
+  format: terminal
+  anonymize: false
+
+privacy:
+  excludeFileContents: false
+  anonymize: false
+`;
+  return yaml;
+}
+
+// src/commands/config.ts
+async function configCommandInner(options, setValue) {
+  if (options.init) {
+    const home = new HomeManager2();
+    const result = home.initialize();
+    if (result.created) {
+      console.log(theme.success(`Created ${result.homePath}/`));
+    } else {
+      console.log(theme.dim(`Home directory already exists: ${result.homePath}/`));
+    }
+    if (result.copiedRubrics.length > 0) {
+      console.log(theme.success(`Copied rubrics: ${result.copiedRubrics.join(", ")}`));
+    }
+    if (result.skippedRubrics.length > 0) {
+      console.log(theme.dim(`Skipped existing rubrics: ${result.skippedRubrics.join(", ")}`));
+    }
+    await runSetupWizard(process.cwd());
+    return;
+  }
+  if (options.show || !options.set && !options.init) {
+    const config = await loadConfig3(process.cwd());
+    console.log(theme.heading("\nCurrent Configuration:\n"));
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  if (options.set && setValue) {
+    console.log(theme.dim(`Setting ${options.set} = ${setValue}`));
+    console.log(theme.warning("Direct config setting via CLI not yet implemented. Edit .gitpulse.yml directly."));
+  }
+}
+async function configCommand(options, setValue) {
+  try {
+    await configCommandInner(options, setValue);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/commands/compare.ts
+import * as path6 from "path";
+import {
+  Analyzer as Analyzer2,
+  createProvider as createProvider2,
+  loadConfig as loadConfig4
+} from "@gitpulse/core";
+async function compareCommandInner(author1, author2, options) {
+  const { localPath } = await resolveRepoPath(options.path ?? ".");
+  const repoPath = path6.resolve(localPath);
+  const config = await loadConfig4(repoPath);
+  const model = await createProvider2({
+    type: config.provider,
+    model: config.model,
+    apiKey: config.apiKey,
+    baseURL: config.baseURL
+  });
+  const analyzer = await Analyzer2.create(repoPath, { config, model });
+  const scope = {
+    since: options.since,
+    until: options.until,
+    path: repoPath
+  };
+  console.log(theme.heading(`
+Comparing: ${author1} vs ${author2}
+`));
+  console.log(theme.dim("Running analysis...\n"));
+  const report = await analyzer.analyze(scope);
+  const a1 = report.authors.find(
+    (a) => a.score.authorName.toLowerCase().includes(author1.toLowerCase()) || a.score.authorEmail.toLowerCase().includes(author1.toLowerCase())
+  );
+  const a2 = report.authors.find(
+    (a) => a.score.authorName.toLowerCase().includes(author2.toLowerCase()) || a.score.authorEmail.toLowerCase().includes(author2.toLowerCase())
+  );
+  if (!a1) {
+    console.log(theme.error(`Author not found: ${author1}`));
+    return;
+  }
+  if (!a2) {
+    console.log(theme.error(`Author not found: ${author2}`));
+    return;
+  }
+  const dims = [
+    { label: "Overall", get: (a) => a.score.overallScore },
+    { label: "Code Quality", get: (a) => a.score.dimensionScores.codeQuality.score },
+    { label: "Complexity", get: (a) => a.score.dimensionScores.complexityImpact.score },
+    { label: "Discipline", get: (a) => a.score.dimensionScores.commitDiscipline.score },
+    { label: "Collaboration", get: (a) => a.score.dimensionScores.collaboration.score }
+  ];
+  const nameWidth = Math.max(a1.score.authorName.length, a2.score.authorName.length, 15);
+  console.log(
+    `${"Dimension".padEnd(20)} ${a1.score.authorName.padEnd(nameWidth)} ${a2.score.authorName.padEnd(nameWidth)} ${"Winner"}`
+  );
+  console.log("-".repeat(20 + nameWidth * 2 + 15));
+  for (const dim of dims) {
+    const v1 = dim.get(a1);
+    const v2 = dim.get(a2);
+    const winner = v1 > v2 ? a1.score.authorName : v2 > v1 ? a2.score.authorName : "Tie";
+    console.log(
+      `${dim.label.padEnd(20)} ${theme.score(v1).padEnd(nameWidth + 10)} ${theme.score(v2).padEnd(nameWidth + 10)} ${winner}`
+    );
+  }
+  console.log(`
+${"Commits".padEnd(20)} ${String(a1.score.scoredCommitCount).padEnd(nameWidth)} ${String(a2.score.scoredCommitCount).padEnd(nameWidth)}`);
+  console.log(`${"Trend".padEnd(20)} ${theme.trend(a1.score.trend.direction).padEnd(nameWidth + 10)} ${theme.trend(a2.score.trend.direction)}`);
+  console.log("");
+}
+async function compareCommand(author1, author2, options) {
+  try {
+    await compareCommandInner(author1, author2, options);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/repl/repl.ts
+import * as readline from "readline";
+import { select as select4, confirm as confirm3, input as inputPrompt } from "@inquirer/prompts";
+import { HomeManager as HomeManager4 } from "@gitpulse/core";
+
+// src/wizard/onboarding.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import * as os2 from "os";
+import { select as select3, input as input3, password } from "@inquirer/prompts";
+var HOME_DIR = path7.join(os2.homedir(), ".gitpulse");
+var CONFIG_FILE = path7.join(HOME_DIR, "config.yml");
+function isOnboardingNeeded() {
+  return !fs6.existsSync(CONFIG_FILE);
+}
+async function runOnboarding() {
+  console.log(theme.heading("\n  Welcome to GitPulse!\n"));
+  console.log(theme.dim("  Let's set up your global configuration.\n"));
+  const provider = await select3({
+    message: "Select your LLM provider:",
+    choices: [
+      { value: "openai", name: "OpenAI (GPT-4o, GPT-4o-mini)" },
+      { value: "anthropic", name: "Anthropic (Claude)" },
+      { value: "google", name: "Google (Gemini)" },
+      { value: "vertex", name: "Google Vertex AI (Gemini via Vertex)" },
+      { value: "custom", name: "Custom (OpenAI-compatible endpoint)" }
+    ]
+  });
+  const defaultModels = {
+    openai: "gpt-4o",
+    anthropic: "claude-sonnet-4-20250514",
+    google: "gemini-1.5-pro",
+    vertex: "gemini-1.5-pro",
+    custom: "default"
+  };
+  const model = await input3({
+    message: "Model name:",
+    default: defaultModels[provider] ?? "gpt-4o"
+  });
+  let baseURL;
+  if (provider === "custom") {
+    baseURL = await input3({
+      message: "Base URL for the API:",
+      validate: (v) => {
+        try {
+          new URL(v);
+          return true;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+  }
+  const apiKey = await password({
+    message: `API Key for ${provider}:`,
+    mask: "*"
+  });
+  fs6.mkdirSync(HOME_DIR, { recursive: true });
+  let yaml = `# GitPulse Global Configuration
+provider: ${provider}
+model: ${model}
+`;
+  if (baseURL) {
+    yaml += `baseURL: ${baseURL}
+`;
+  }
+  if (apiKey) {
+    yaml += `apiKey: ${apiKey}
+`;
+  }
+  fs6.writeFileSync(CONFIG_FILE, yaml, "utf-8");
+  console.log(theme.success(`
+  Configuration saved to ${CONFIG_FILE}`));
+  console.log("");
+}
+
+// src/commands/history.ts
+import Table2 from "cli-table3";
+import { HomeManager as HomeManager3 } from "@gitpulse/core";
+async function historyCommandInner(options) {
+  const home = new HomeManager3();
+  const entries = home.getHistory(options?.repo);
+  if (entries.length === 0) {
+    console.log(theme.dim("\n  No analysis history found. Run `analyze` to get started.\n"));
+    return;
+  }
+  const limit = options?.limit ?? 20;
+  const shown = entries.slice(0, limit);
+  const table = new Table2({
+    head: [
+      theme.bold("Date"),
+      theme.bold("Repository"),
+      theme.bold("Commits"),
+      theme.bold("Avg Score"),
+      theme.bold("Provider"),
+      theme.bold("Cost")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    }
+  });
+  for (const entry of shown) {
+    const date = new Date(entry.timestamp);
+    const dateStr = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+    table.push([
+      dateStr,
+      entry.repoName,
+      String(entry.summary.analyzedCommits),
+      theme.score(entry.summary.averageScore),
+      `${entry.cost.llmProvider}/${entry.cost.llmModel}`,
+      `$${entry.cost.estimatedCost.toFixed(2)}`
+    ]);
+  }
+  console.log(theme.heading("\n  Analysis History\n"));
+  console.log(table.toString());
+  if (entries.length > limit) {
+    console.log(theme.dim(`
+  Showing ${limit} of ${entries.length} entries.`));
+  }
+  console.log("");
+}
+
+// src/repl/arg-parser.ts
+function parseArgs(input4) {
+  const args2 = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < input4.length; i++) {
+    const ch = input4[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (ch === " " && !inSingle && !inDouble) {
+      if (current.length > 0) {
+        args2.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current.length > 0) {
+    args2.push(current);
+  }
+  return args2;
+}
+function consumeFlag(args2, flag, alias) {
+  const idx = args2.findIndex((a) => a === flag || alias && a === alias);
+  if (idx === -1) return false;
+  args2.splice(idx, 1);
+  return true;
+}
+function consumeOption(args2, flag, alias) {
+  const idx = args2.findIndex((a) => a === flag || alias && a === alias);
+  if (idx === -1) return void 0;
+  const value = args2[idx + 1];
+  args2.splice(idx, value !== void 0 ? 2 : 1);
+  return value;
+}
+function consumeMultiOption(args2, flag, alias) {
+  const values = [];
+  let found = false;
+  while (true) {
+    const idx = args2.findIndex((a) => a === flag || alias && a === alias);
+    if (idx === -1) break;
+    found = true;
+    const value = args2[idx + 1];
+    if (value !== void 0 && !value.startsWith("-")) {
+      args2.splice(idx, 2);
+      values.push(value);
+    } else {
+      args2.splice(idx, 1);
+    }
+  }
+  return found ? values : void 0;
+}
+function parseAnalyzeArgs(args2) {
+  const rest = [...args2];
+  const options = {};
+  options.branch = consumeOption(rest, "--branch", "-b");
+  options.since = consumeOption(rest, "--since");
+  options.until = consumeOption(rest, "--until");
+  options.author = consumeMultiOption(rest, "--author");
+  const maxCommits = consumeOption(rest, "--max-commits");
+  if (maxCommits) options.maxCommits = parseInt(maxCommits, 10);
+  options.format = consumeOption(rest, "--format");
+  options.output = consumeOption(rest, "--output", "-o");
+  if (consumeFlag(rest, "--no-cache")) options.noCache = true;
+  if (consumeFlag(rest, "-y") || consumeFlag(rest, "--yes")) options.yes = true;
+  options.provider = consumeOption(rest, "--provider");
+  options.model = consumeOption(rest, "--model");
+  const repoPath = rest.find((a) => !a.startsWith("-")) ?? ".";
+  return { repoPath, options };
+}
+function parseReportArgs(args2) {
+  const rest = [...args2];
+  const options = {};
+  options.format = consumeOption(rest, "--format");
+  options.output = consumeOption(rest, "--output", "-o");
+  const repoPath = rest.find((a) => !a.startsWith("-")) ?? ".";
+  return { repoPath, options };
+}
+function parseConfigArgs(args2) {
+  const rest = [...args2];
+  const options = {};
+  if (consumeFlag(rest, "--init")) options.init = true;
+  if (consumeFlag(rest, "--show")) options.show = true;
+  options.set = consumeOption(rest, "--set");
+  const value = rest.find((a) => !a.startsWith("-"));
+  return { options, value };
+}
+function parseCompareArgs(args2) {
+  const rest = [...args2];
+  const options = {};
+  options.path = consumeOption(rest, "--path", "-p");
+  options.since = consumeOption(rest, "--since");
+  options.until = consumeOption(rest, "--until");
+  const positional = rest.filter((a) => !a.startsWith("-"));
+  if (positional.length < 2) {
+    return null;
+  }
+  return { author1: positional[0], author2: positional[1], options };
+}
+function parseHistoryArgs(args2) {
+  const rest = [...args2];
+  const options = {};
+  options.repo = consumeOption(rest, "--repo");
+  const limit = consumeOption(rest, "--limit", "-n");
+  if (limit) options.limit = parseInt(limit, 10);
+  return { options };
+}
+
+// src/repl/repl.ts
+async function startRepl() {
+  printLogo();
+  if (isOnboardingNeeded()) {
+    await runOnboarding();
+  } else {
+    await showWelcomeBack();
+  }
+  await replLoop();
+}
+async function showWelcomeBack() {
+  const home = new HomeManager4();
+  const memory = home.getMemory();
+  if (memory.lastRun) {
+    const date = new Date(memory.lastRun.timestamp);
+    const dateStr = date.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    console.log(theme.heading("  Welcome back!\n"));
+    console.log(`  Last analysis: ${theme.bold(memory.lastRun.repoName)} on ${dateStr}`);
+    console.log(`  Commits: ${memory.lastRun.totalCommits} | Avg Score: ${theme.score(memory.lastRun.averageScore)}`);
+    if (memory.preferences.preferredProvider) {
+      console.log(`  Provider: ${memory.preferences.preferredProvider}/${memory.preferences.preferredModel ?? "default"}`);
+    }
+    console.log(`  Total analyses: ${memory.totalAnalysisCount}
+`);
+    const continueSettings = await confirm3({
+      message: "Continue with current settings?",
+      default: true
+    });
+    if (!continueSettings) {
+      await runOnboarding();
+    }
+  } else {
+    console.log(theme.heading("  Welcome back!\n"));
+    console.log(theme.dim("  No previous analysis found. Run `analyze <path>` to get started.\n"));
+  }
+}
+function promptLine() {
+  return new Promise((resolve4) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      resolve4(null);
+    });
+    rl.on("close", () => {
+      resolve4(null);
+    });
+    rl.question(theme.prompt("gitpulse> "), (answer) => {
+      resolve4(answer);
+      rl.close();
+    });
+  });
+}
+async function replLoop() {
+  console.log(theme.dim("  Type a command, press Enter for quick menu, or type `help` for usage.\n"));
+  while (true) {
+    const line = await promptLine();
+    if (line === null) {
+      console.log(theme.dim("\n  Goodbye!"));
+      return;
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      try {
+        const shouldExit = await showQuickMenu();
+        if (shouldExit) return;
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortPromptError") {
+        } else {
+          handleReplError(error);
+        }
+      }
+      continue;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      console.log(theme.dim("\n  Goodbye!"));
+      return;
+    }
+    if (trimmed === "help") {
+      printHelp();
+      continue;
+    }
+    try {
+      await dispatchCommand(trimmed);
+    } catch (error) {
+      handleReplError(error);
+    }
+  }
+}
+async function dispatchCommand(input4) {
+  const argv = parseArgs(input4);
+  if (argv.length === 0) return;
+  const command = argv[0].toLowerCase();
+  const args2 = argv.slice(1);
+  switch (command) {
+    case "analyze": {
+      const { repoPath, options } = parseAnalyzeArgs(args2);
+      await analyzeCommandInner(repoPath, options);
+      break;
+    }
+    case "report": {
+      const { repoPath, options } = parseReportArgs(args2);
+      await reportCommandInner(repoPath, options);
+      break;
+    }
+    case "config": {
+      const { options, value } = parseConfigArgs(args2);
+      await configCommandInner(options, value);
+      break;
+    }
+    case "compare": {
+      const parsed = parseCompareArgs(args2);
+      if (!parsed) {
+        console.log(theme.error("Usage: compare <author1> <author2> [--path <path>] [--since <date>] [--until <date>]"));
+        break;
+      }
+      await compareCommandInner(parsed.author1, parsed.author2, parsed.options);
+      break;
+    }
+    case "history": {
+      const { options } = parseHistoryArgs(args2);
+      await historyCommandInner(options);
+      break;
+    }
+    case "help": {
+      printHelp();
+      break;
+    }
+    default: {
+      console.log(theme.warning(`Unknown command: ${command}`));
+      console.log(theme.dim("Type `help` for available commands.\n"));
+    }
+  }
+}
+async function showQuickMenu() {
+  const action = await select4({
+    message: "What would you like to do?",
+    choices: [
+      { value: "analyze", name: "Analyze a repository" },
+      { value: "report", name: "Generate a report from cache" },
+      { value: "compare", name: "Compare two developers" },
+      { value: "history", name: "View analysis history" },
+      { value: "config", name: "Manage configuration" },
+      { value: "help", name: "Show help" },
+      { value: "exit", name: "Exit" }
+    ]
+  });
+  switch (action) {
+    case "analyze": {
+      const repoPath = await inputPrompt({
+        message: "Repository path or URL:",
+        default: "."
+      });
+      await analyzeCommandInner(repoPath, {});
+      break;
+    }
+    case "report": {
+      const repoPath = await inputPrompt({
+        message: "Repository path or URL:",
+        default: "."
+      });
+      await reportCommandInner(repoPath, {});
+      break;
+    }
+    case "compare": {
+      const author1 = await inputPrompt({ message: "First author name or email:" });
+      const author2 = await inputPrompt({ message: "Second author name or email:" });
+      await compareCommandInner(author1, author2, {});
+      break;
+    }
+    case "history": {
+      await historyCommandInner();
+      break;
+    }
+    case "config": {
+      await configCommandInner({ show: true });
+      break;
+    }
+    case "help": {
+      printHelp();
+      break;
+    }
+    case "exit": {
+      console.log(theme.dim("\n  Goodbye!"));
+      return true;
+    }
+  }
+  return false;
+}
+function printHelp() {
+  console.log(theme.heading("\n  Available Commands:\n"));
+  console.log("  analyze [path]          Analyze a repository");
+  console.log("    --branch, -b <name>   Branch to analyze");
+  console.log("    --since <date>        Start date");
+  console.log("    --until <date>        End date");
+  console.log("    --author <names...>   Filter by author");
+  console.log("    --max-commits <n>     Max commits to analyze");
+  console.log("    --format <type>       Output: terminal, json, markdown, html");
+  console.log("    -o, --output <path>   Output file path");
+  console.log("    --no-cache            Force re-scoring");
+  console.log("    -y, --yes             Skip confirmation");
+  console.log("    --provider <type>     LLM provider override");
+  console.log("    --model <name>        LLM model override");
+  console.log("");
+  console.log("  report [path]           Generate report from cached scores");
+  console.log("    --format <type>       Output format");
+  console.log("    -o, --output <path>   Output file path");
+  console.log("");
+  console.log("  compare <a1> <a2>       Compare two developers");
+  console.log("    -p, --path <path>     Repository path");
+  console.log("    --since <date>        Start date");
+  console.log("    --until <date>        End date");
+  console.log("");
+  console.log("  history                 View analysis history");
+  console.log("    --repo <path>         Filter by repository");
+  console.log("    -n, --limit <n>       Limit entries");
+  console.log("");
+  console.log("  config                  Show current configuration");
+  console.log("    --init                Run setup wizard");
+  console.log("    --show                Show configuration");
+  console.log("");
+  console.log("  help                    Show this help");
+  console.log("  exit / quit             Exit REPL");
+  console.log("");
+  console.log(theme.dim("  Press Enter (empty input) for quick menu."));
+  console.log("");
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+if (args.length === 0) {
+  startRepl().catch(handleError);
+} else {
+  const program = new Command();
+  program.name("gitpulse").description("AI-powered Git contribution analyzer").version(getVersion()).hook("preAction", () => {
+    printLogo();
+  });
+  program.command("analyze").description("Analyze repository contributions").argument("[path]", "Path or URL to git repository", ".").option("-b, --branch <branch>", "Branch to analyze").option("--since <date>", "Start date (e.g., 2025-01-01)").option("--until <date>", "End date").option("--author <names...>", "Filter by author name(s)").option("--max-commits <n>", "Maximum number of commits", parseInt).option("--format <type>", "Output format: terminal, json, markdown, html").option("-o, --output <path>", "Output file path").option("--no-cache", "Ignore cache, force re-scoring").option("-y, --yes", "Skip confirmation prompt").option("--provider <type>", "LLM provider override").option("--model <name>", "LLM model override").action(async (repoPath, options) => {
+    await analyzeCommand(repoPath, options);
+  });
+  program.command("report").description("Generate report from cached scores").argument("[path]", "Path or URL to git repository", ".").option("--format <type>", "Output format: terminal, json, markdown, html").option("-o, --output <path>", "Output file path").action(async (repoPath, options) => {
+    await reportCommand(repoPath, options);
+  });
+  program.command("config").description("Manage configuration").option("--init", "Run interactive setup wizard").option("--show", "Show current configuration").option("--set <key>", "Set a config value").argument("[value]", "Value to set").action(async (value, options) => {
+    await configCommand(options, value);
+  });
+  program.command("compare").description("Compare two developers").argument("<author1>", "First author name or email").argument("<author2>", "Second author name or email").option("-p, --path <path>", "Path or URL to git repository", ".").option("--since <date>", "Start date").option("--until <date>", "End date").action(async (author1, author2, options) => {
+    await compareCommand(author1, author2, options);
+  });
+  program.parseAsync(process.argv).catch(handleError);
+}
+//# sourceMappingURL=index.js.map