gitbrain 0.2.0

package/README.md

@@ -0,0 +1,164 @@
+# GitBrain
+
+GitBrain is a modular Node.js CLI for generating developer-facing content from Git commits and analyzing pull request risk.
+
+## Features
+
+### `gitbrain content`
+Fetches the latest 5 commits and generates a human-friendly dev update thread with:
+- **Smart categorization**: commits are classified as features, fixes, refactoring, docs, or other
+- **Narrative summary**: auto-generated summary like "shipped 2 features, fixed 1 issue"
+- **Highlights**: key features and fixes called out at the top
+- **Clean formatting**: organized sections with author attribution
+
+### `gitbrain risk`
+Computes a risk score based on diff summary metrics with:
+- **Risk level**: LOW / MEDIUM / HIGH
+- **Critical file detection**: identifies changes to auth, payment, security, config, and core files
+- **AI-powered analysis**: explains risk in plain language and highlights likely failure points
+- **Detailed metrics**: files changed, lines added/deleted
+- **Smart scoring**: weighted calculation based on scope and criticality of changes
+
+## Critical file categories
+
+The risk analyzer automatically detects changes to critical files and flags them:
+
+- **🔐 Auth**: Files containing authentication logic (auth, oauth, jwt, password, session, token, login)
+- **💳 Payment**: Files related to payments (payment, stripe, paypal, checkout, billing, credit, invoice)
+- **🔒 Security**: Files related to encryption and security (crypto, secret, encryption, ssl, certificate, tls)
+- **⚙️ Config**: Configuration and environment files (config, env, .env, settings, database, connection, api)
+- **🔧 Core**: Core application files (core, kernel, engine, main.js, index.js, package.json)
+
+When critical files are detected, the risk score receives a significant boost to flag them for review.
+
+## Install
+
+```bash
+npm install
+npm link
+```
+
+## Environment
+
+GitBrain stores your provider and API key persistently in `~/.gitbrain/config.json`.
+
+- `OPENAI_API_KEY` for OpenAI
+- `GEMINI_API_KEY` for Gemini-style endpoints
+- Optionally `OPENAI_API_BASE` to override the API host
+- Optionally `OPENAI_MODEL` or `GEMINI_MODEL` to set the LLM model
+
+Example:
+
+```bash
+export OPENAI_API_KEY=your_key_here
+export OPENAI_MODEL=gpt-3.5-turbo
+```
+
+## Persistent configuration
+
+If no config exists, GitBrain will prompt for provider and API key on first use and save it locally.
+
+To update or reset the stored provider settings, use:
+
+```bash
+gitbrain config
+```
+
+You can still override the provider on each run:
+
+```bash
+gitbrain content --provider openai
+gitbrain risk --provider gemini
+```
+
+If no key is provided and no local config exists, GitBrain falls back to basic local analysis and shows a warning.
+
+## Error handling
+
+GitBrain includes robust error handling for common issues:
+
+**Not a Git repository**: When you run any command outside a Git repository, you'll see a friendly error message with a suggestion to initialize a repository:
+
+```
+error Not a Git repository
+  This command must be run inside a Git repository.
+  Try: git init
+```
+
+This applies to all commands: `content`, `today`, and `risk`.
+
+## Usage
+
+```bash
+gitbrain content
+
+gitbrain today
+
+gitbrain risk
+```
+
+## Example output
+
+### Content command
+```
+📝 Dev Update
+
+This sprint I shipped 2 features, fixed 1 issue.
+
+Highlights
+✨ Key feature: Add dark mode support
+🐛 Fixed: Navigation menu rendering
+
+What changed
+Features:
+  • Add dark mode support — alice
+  • Improve search performance — bob
+
+Fixes:
+  • Fix menu click handler — alice
+
+📊 3 commits from current repository
+```
+
+### Risk command
+```
+⚠️  Risk Assessment
+
+Risk Level: MEDIUM  (Score: 68 / 100)
+
+🚨 Critical files detected:
+  🔐 Auth: src/auth/login.js
+  💳 Payment: src/payment/checkout.js
+  ⚙️  Config: .env, config/database.js
+
+Metrics:
+  Files changed: 12
+  Lines added: 250
+  Lines deleted: 120
+  Total changes: 370
+
+⚠️ Critical files changed. Require careful review and testing.
+```
+
+## Project structure
+
+- `bin/index.js`: CLI entrypoint
+- `src/commands`: command handlers
+- `src/core`: Git integration, analysis, and formatting
+- `src/services`: AI helpers and commit analysis
+- `src/utils`: reusable CLI utilities
+
+## Development
+
+Run the CLI locally:
+
+```bash
+npm run start -- content
+npm run start -- risk
+```
+
+## Notes
+
+- Requires Node.js 18 or later
+- Designed to be extended with additional commands like `today`, AI summarization, and CI integration
+

package/bin/index.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { program } from "commander";
+import { runContent } from "../src/commands/content.js";
+import { runRisk } from "../src/commands/risk.js";
+import { runToday } from "../src/commands/today.js";
+import { runConfig } from "../src/commands/config.js";
+import { resolveRuntimeConfig } from "../src/index.js";
+import { info, error, success } from "../src/utils/logger.js";
+import { NotGitRepoError } from "../src/core/git.js";
+
+program
+  .name("gitbrain")
+  .description("GitBrain CLI for AI-powered Git repository analysis")
+  .version("0.1.0")
+  .option("-p, --provider <provider>", "Select LLM provider (openai|gemini)");
+
+async function loadRuntimeConfig() {
+  const opts = program.opts();
+  return await resolveRuntimeConfig({ provider: opts.provider });
+}
+
+function showProviderHint(runtime) {
+  const provider = runtime.config?.provider || "openai";
+  const hasKey = Boolean(runtime.config?.apiKey || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY);
+  if (!hasKey) {
+    console.log(chalk.yellow("LLM provider not configured. Use gitbrain config, OPENAI_API_KEY, or GEMINI_API_KEY."));
+    return;
+  }
+
+  const source = runtime.isStored ? "stored config" : runtime.isEnv ? "environment" : "default";
+  console.log(chalk.gray(`LLM provider: ${provider} (${source}). Use --provider openai|gemini to override.`));
+}
+
+program
+  .command("content")
+  .description("Generate developer-facing content from recent commits")
+  .action(async () => {
+    const runtime = await loadRuntimeConfig();
+    showProviderHint(runtime);
+    info("Analyzing recent commits...");
+    try {
+      const { result, aiUsed } = await runContent(runtime.config);
+      console.log(result);
+      success("Content generation complete.");
+    } catch (err) {
+      if (!(err instanceof NotGitRepoError)) {
+        error(err);
+      }
+      process.exit(1);
+    }
+  });
+
+program
+  .command("today")
+  .description("Summarize commits made today")
+  .action(async () => {
+    const runtime = await loadRuntimeConfig();
+    showProviderHint(runtime);
+    info("Analyzing today's work...");
+    try {
+      const { result, aiUsed } = await runToday(runtime.config);
+      console.log(result);
+      success("Today's summary complete.");
+    } catch (err) {
+      if (!(err instanceof NotGitRepoError)) {
+        error(err);
+      }
+      process.exit(1);
+    }
+  });
+
+program
+  .command("risk")
+  .description("Analyze repository change risk")
+  .action(async () => {
+    const runtime = await loadRuntimeConfig();
+    showProviderHint(runtime);
+    info("Evaluating repository diff...");
+    try {
+      const { result, aiUsed } = await runRisk(runtime.config);
+      console.log(result);
+      success("Risk analysis complete.");
+    } catch (err) {
+      if (!(err instanceof NotGitRepoError)) {
+        error(err);
+      }
+      process.exit(1);
+    }
+  });
+
+program
+  .command("config")
+  .description("Update or reset persistent AI provider configuration")
+  .action(async () => {
+    info("Opening GitBrain configuration...");
+    try {
+      const result = await runConfig();
+      console.log(result);
+      success("Configuration saved.");
+    } catch (err) {
+      error(err);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gitbrain",
+  "version": "0.2.0",
+  "description": "AI-powered Git CLI for commit analysis and PR risk assessment",
+  "bin": {
+    "gitbrain": "./bin/index.js"
+  },
+  "type": "module",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node ./bin/index.js",
+    "dev": "node ./bin/index.js",
+    "check": "node --check ./bin/index.js"
+  },
+  "dependencies": {
+    "@google/generative-ai": "^0.24.1",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "openai": "^4.104.0",
+    "simple-git": "^3.19.1"
+  },
+  "license": "MIT",
+  "keywords": [
+    "cli",
+    "git",
+    "ai",
+    "developer-tools"
+  ],
+  "author": "Bright"
+}

package/src/commands/config.js

@@ -0,0 +1,14 @@
+import { promptForConfig, getConfig } from "../services/config.js";
+import { info } from "../utils/logger.js";
+
+export async function runConfig() {
+  info("Opening GitBrain AI configuration...");
+  const { config: existing } = await getConfig();
+
+  if (existing && existing.provider) {
+    console.log(`Current provider: ${existing.provider}`);
+  }
+
+  const config = await promptForConfig(existing?.provider || "openai");
+  return `Saved ${config.provider} configuration successfully.`;
+}

package/src/commands/content.js

@@ -0,0 +1,28 @@
+import { getRecentCommits, NotGitRepoError } from "../core/git.js";
+import { formatThread } from "../core/formatter.js";
+import { generateDevSummary, analyzeCodebasePatterns } from "../services/ai.js";
+import { info, formatGitError } from "../utils/logger.js";
+
+export async function runContent(config) {
+  try {
+    info("Loading the latest commit history...");
+    const commits = await getRecentCommits({ maxCount: 5 });
+
+    if (!commits.length) {
+      return { result: "No commits were found in the current repository. Please run this inside a Git repo with commit history.", aiUsed: false };
+    }
+
+    const summaryResult = await generateDevSummary(commits, config);
+    const patternResult = await analyzeCodebasePatterns(commits, config);
+
+    const aiUsed = summaryResult.aiUsed || patternResult.aiUsed;
+    const result = formatThread(commits, summaryResult.text, "content", patternResult.text);
+    return { result, aiUsed };
+  } catch (err) {
+    if (err instanceof NotGitRepoError) {
+      formatGitError();
+      throw err;
+    }
+    throw err;
+  }
+}

package/src/commands/risk.js

@@ -0,0 +1,23 @@
+import { getDiffSummary, NotGitRepoError } from "../core/git.js";
+import { calculateRisk } from "../core/analyzer.js";
+import { analyzeRiskWithAI } from "../services/ai.js";
+import { formatRisk } from "../core/formatter.js";
+import { info, formatGitError } from "../utils/logger.js";
+
+export async function runRisk(config) {
+  try {
+    info("Collecting diff summary from repository...");
+    const diff = await getDiffSummary();
+    const scoreSummary = calculateRisk(diff);
+    const aiResult = await analyzeRiskWithAI(diff, config);
+    const riskAnalysis = { ...scoreSummary, aiAnalysis: aiResult.text };
+    const result = formatRisk(diff, riskAnalysis);
+    return { result, aiUsed: aiResult.aiUsed };
+  } catch (err) {
+    if (err instanceof NotGitRepoError) {
+      formatGitError();
+      throw err;
+    }
+    throw err;
+  }
+}

package/src/commands/today.js

@@ -0,0 +1,25 @@
+import { getTodayCommits, NotGitRepoError } from "../core/git.js";
+import { formatThread } from "../core/formatter.js";
+import { generateDevSummary } from "../services/ai.js";
+import { info, formatGitError } from "../utils/logger.js";
+
+export async function runToday(config) {
+  try {
+    info("Loading commits from today...");
+    const commits = await getTodayCommits();
+
+    if (!commits.length) {
+      return { result: "No commits found for today. You've earned a relaxing break!", aiUsed: false };
+    }
+
+    const summaryResult = await generateDevSummary(commits, config);
+    const result = formatThread(commits, summaryResult.text, "today");
+    return { result, aiUsed: summaryResult.aiUsed };
+  } catch (err) {
+    if (err instanceof NotGitRepoError) {
+      formatGitError();
+      throw err;
+    }
+    throw err;
+  }
+}

package/src/core/analyzer.js

@@ -0,0 +1,85 @@
+function normalizeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+const CRITICAL_PATTERNS = {
+  auth: /auth|oauth|jwt|password|credential|session|token|login/i,
+  payment: /payment|stripe|paypal|checkout|billing|credit|invoice|transaction|card/i,
+  security: /crypto|secret|encryption|ssl|certificate|tls|https/i,
+  config: /config|env|\.env|settings|database|connection|api/i,
+  core: /core|kernel|engine|main\.js|index\.js|package\.json/i,
+};
+
+function detectCriticalFiles(diff) {
+  const criticalFiles = {
+    auth: [],
+    payment: [],
+    security: [],
+    config: [],
+    core: [],
+  };
+
+  if (!Array.isArray(diff.files)) {
+    return criticalFiles;
+  }
+
+  diff.files.forEach((file) => {
+    const filePath = typeof file === "string" ? file : file.file || file.name || "";
+    const lowerPath = filePath.toLowerCase();
+
+    Object.entries(CRITICAL_PATTERNS).forEach(([category, pattern]) => {
+      if (pattern.test(lowerPath)) {
+        criticalFiles[category].push(filePath);
+      }
+    });
+  });
+
+  return criticalFiles;
+}
+
+function calculateCriticalRiskBonus(criticalFiles) {
+  let bonus = 0;
+
+  Object.entries(criticalFiles).forEach(([category, files]) => {
+    if (files.length > 0) {
+      const multiplier = category === "payment" ? 40 : category === "auth" ? 35 : category === "security" ? 35 : 20;
+      bonus += multiplier;
+    }
+  });
+
+  return bonus;
+}
+
+export function calculateRisk(diff) {
+  const files = Array.isArray(diff.files) ? diff.files.length : normalizeNumber(diff.files);
+  const insertions = normalizeNumber(diff.insertions);
+  const deletions = normalizeNumber(diff.deletions);
+
+  let score = 0;
+
+  if (files > 10) score += 35;
+  else if (files > 5) score += 20;
+  else if (files > 0) score += 10;
+
+  if (insertions > 500) score += 35;
+  else if (insertions > 200) score += 20;
+  else if (insertions > 0) score += 10;
+
+  if (deletions > 500) score += 30;
+  else if (deletions > 200) score += 15;
+  else if (deletions > 0) score += 8;
+
+  const criticalFiles = detectCriticalFiles(diff);
+  const criticalBonus = calculateCriticalRiskBonus(criticalFiles);
+  score += criticalBonus;
+
+  return {
+    score: clamp(score, 0, 100),
+    criticalFiles,
+    hasCritical: Object.values(criticalFiles).some((files) => files.length > 0),
+  };
+}

package/src/core/formatter.js

@@ -0,0 +1,146 @@
+import chalk from "chalk";
+import { categorizeCommits, extractHighlights } from "../services/ai.js";
+
+export function formatThread(commits, narrativeSummary, context = "content", analysisNotes = "") {
+  const categories = categorizeCommits(commits);
+  const highlights = extractHighlights(commits);
+
+  const sections = [];
+
+  sections.push(
+    context === "today"
+      ? chalk.bold.cyan("📅 Today's Work")
+      : chalk.bold.cyan("📝 Dev Update")
+  );
+  sections.push("");
+
+  if (narrativeSummary) {
+    const summaryText = narrativeSummary.trim();
+    const formatted = context === "today" ? summaryText : summaryText;
+    sections.push(chalk.gray(formatted));
+    sections.push("");
+  }
+
+  if (analysisNotes) {
+    sections.push(chalk.bold("AI Insight"));
+    sections.push(chalk.white(analysisNotes));
+    sections.push("");
+  }
+
+  if (highlights.length > 0) {
+    sections.push(chalk.bold("Highlights"));
+    highlights.forEach((h) => sections.push(chalk.cyan(h)));
+    sections.push("");
+  }
+
+  const categoryItems = [];
+
+  if (categories.features.length > 0) {
+    categoryItems.push(formatCategory("Features", categories.features));
+  }
+  if (categories.fixes.length > 0) {
+    categoryItems.push(formatCategory("Fixes", categories.fixes));
+  }
+  if (categories.refactoring.length > 0) {
+    categoryItems.push(formatCategory("Refactoring", categories.refactoring));
+  }
+  if (categories.docs.length > 0) {
+    categoryItems.push(formatCategory("Documentation", categories.docs));
+  }
+  if (categories.other.length > 0) {
+    categoryItems.push(formatCategory("Other", categories.other));
+  }
+
+  if (categoryItems.length > 0) {
+    sections.push(chalk.bold("What changed"));
+    sections.push(...categoryItems.flat());
+    sections.push("");
+  }
+
+  sections.push(
+    chalk.dim(
+      `📊 ${commits.length} commit${commits.length > 1 ? "s" : ""} from ${context === "today" ? "today" : "current repository"}`
+    )
+  );
+
+  return sections.join("\n");
+}
+
+function formatCategory(name, commits) {
+  const lines = [chalk.yellow(`${name}:`)];
+  commits.forEach((commit) => {
+    const cleanMsg = commit.message
+      .trim()
+      .replace(/^(feat|fix|refactor|docs)\s*:?\s*/i, "")
+      .replace(/^#\d+\s+/g, "")
+      .slice(0, 80);
+    lines.push(`  ${chalk.gray("•")} ${cleanMsg} ${chalk.dim(`— ${commit.author}`)}`);
+  });
+  lines.push("");
+  return lines;
+}
+
+export function formatRisk(diff, riskAnalysis) {
+  const score = typeof riskAnalysis === "number" ? riskAnalysis : riskAnalysis.score;
+  const criticalFiles = riskAnalysis.criticalFiles || {};
+  const hasCritical = riskAnalysis.hasCritical || false;
+
+  const level = score >= 70 ? "HIGH" : score >= 35 ? "MEDIUM" : "LOW";
+  const styledLevel =
+    level === "HIGH"
+      ? chalk.red.bold(level)
+      : level === "MEDIUM"
+        ? chalk.yellow.bold(level)
+        : chalk.green.bold(level);
+  const changes = normalizeChanges(diff);
+
+  const sections = [chalk.bold.red("⚠️  Risk Assessment"), "", `Risk Level: ${styledLevel}  (Score: ${score} / 100)`, ""];
+
+  if (hasCritical) {
+    sections.push(chalk.red.bold("🚨 Critical files detected:"));
+    if (criticalFiles.auth && criticalFiles.auth.length > 0) {
+      sections.push(chalk.red(`  🔐 Auth: ${criticalFiles.auth.join(", ")}`));
+    }
+    if (criticalFiles.payment && criticalFiles.payment.length > 0) {
+      sections.push(chalk.red(`  💳 Payment: ${criticalFiles.payment.join(", ")}`));
+    }
+    if (criticalFiles.security && criticalFiles.security.length > 0) {
+      sections.push(chalk.red(`  🔒 Security: ${criticalFiles.security.join(", ")}`));
+    }
+    if (criticalFiles.config && criticalFiles.config.length > 0) {
+      sections.push(chalk.yellow(`  ⚙️  Config: ${criticalFiles.config.join(", ")}`));
+    }
+    if (criticalFiles.core && criticalFiles.core.length > 0) {
+      sections.push(chalk.yellow(`  🔧 Core: ${criticalFiles.core.join(", ")}`));
+    }
+    sections.push("");
+  }
+
+  if (riskAnalysis.aiAnalysis) {
+    sections.push(chalk.bold("AI Insight"));
+    sections.push(chalk.white(riskAnalysis.aiAnalysis));
+    sections.push("");
+  }
+
+  sections.push(chalk.dim("Metrics:"));
+  sections.push(`  Files changed: ${Array.isArray(diff.files) ? diff.files.length : diff.files}`);
+  sections.push(`  Lines added: ${diff.insertions ?? 0}`);
+  sections.push(`  Lines deleted: ${diff.deletions ?? 0}`);
+  sections.push(`  Total changes: ${changes}`);
+  sections.push("");
+
+  if (hasCritical) {
+    sections.push(chalk.red.italic("⚠️ Critical files changed. Require careful review and testing."));
+  } else {
+    sections.push(chalk.italic.dim("Tip: Large diffs should be reviewed carefully and tested thoroughly."));
+  }
+
+  return sections.join("\n");
+}
+
+function normalizeChanges(diff) {
+  if (typeof diff.changes === "number") {
+    return diff.changes;
+  }
+  return (diff.insertions ?? 0) + (diff.deletions ?? 0);
+}

package/src/core/git.js

@@ -0,0 +1,57 @@
+import simpleGit from "simple-git";
+
+const git = simpleGit({ baseDir: process.cwd() });
+
+class NotGitRepoError extends Error {
+  constructor(message = "Not a Git repository") {
+    super(message);
+    this.name = "NotGitRepoError";
+  }
+}
+
+async function ensureRepository() {
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    throw new NotGitRepoError();
+  }
+}
+
+export async function getRecentCommits(options = { maxCount: 5 }) {
+  await ensureRepository();
+  const { maxCount } = options;
+  const log = await git.log({ maxCount });
+  return log.all.map((commit) => ({
+    hash: commit.hash,
+    author: commit.author_name,
+    date: commit.date,
+    message: commit.message,
+  }));
+}
+
+export async function getTodayCommits() {
+  await ensureRepository();
+  const startOfDay = new Date();
+  startOfDay.setHours(0, 0, 0, 0);
+
+  const log = await git.log();
+  const todayCommits = log.all
+    .filter((commit) => {
+      const commitDate = new Date(commit.date);
+      return commitDate >= startOfDay;
+    })
+    .map((commit) => ({
+      hash: commit.hash,
+      author: commit.author_name,
+      date: commit.date,
+      message: commit.message,
+    }));
+
+  return todayCommits;
+}
+
+export async function getDiffSummary() {
+  await ensureRepository();
+  return git.diffSummary();
+}
+
+export { NotGitRepoError };

package/src/index.js

@@ -0,0 +1,76 @@
+import { getConfig, getEnvConfig } from "./services/config.js";
+
+function normalizeProvider(provider) {
+  const value = provider?.toString().trim().toLowerCase();
+  if (value === "gemini") {
+    return "gemini";
+  }
+  if (value === "openai") {
+    return "openai";
+  }
+  return null;
+}
+
+export async function resolveRuntimeConfig(options = {}) {
+  const { provider, apiKey } = options;
+  const requestedProvider = normalizeProvider(provider);
+  const { config: storedConfig, isStored } = await getConfig({ promptIfMissing: false });
+
+  let finalProvider = requestedProvider;
+  let finalApiKey = apiKey ?? null;
+  let configSource = null;
+
+  if (finalProvider) {
+    // Provider explicitly requested
+    configSource = "requested";
+    if (!finalApiKey && storedConfig?.provider === finalProvider) {
+      finalApiKey = storedConfig.apiKey;
+      configSource = "stored";
+    }
+    if (!finalApiKey) {
+      const envConfig = getEnvConfig(finalProvider);
+      if (envConfig) {
+        finalApiKey = envConfig.apiKey;
+        configSource = "env";
+      }
+    }
+  } else {
+    // No provider requested - use stored if available
+    if (storedConfig?.provider && storedConfig?.apiKey) {
+      finalProvider = storedConfig.provider;
+      finalApiKey = storedConfig.apiKey;
+      configSource = "stored";
+    } else {
+      // Fall back to env, preferring the one with an active key
+      const openaiKey = process.env.OPENAI_API_KEY;
+      const geminiKey = process.env.GEMINI_API_KEY;
+
+      if (geminiKey && !openaiKey) {
+        finalProvider = "gemini";
+        finalApiKey = geminiKey;
+        configSource = "env";
+      } else {
+        finalProvider = "openai";
+        finalApiKey = openaiKey || null;
+        configSource = openaiKey ? "env" : "default";
+      }
+    }
+  }
+
+  const isEnv = configSource === "env";
+  const resultIsStored = configSource === "stored";
+
+  return {
+    config: {
+      provider: finalProvider,
+      apiKey: finalApiKey,
+    },
+    isStored: resultIsStored,
+    isEnv,
+  };
+}
+
+export { runContent } from "./commands/content.js";
+export { runRisk } from "./commands/risk.js";
+export { runToday } from "./commands/today.js";
+export { runConfig } from "./commands/config.js";

package/src/services/ai.js

@@ -0,0 +1,262 @@
+import OpenAI from "openai";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { warn } from "../utils/logger.js";
+
+function normalizeProvider(provider) {
+  const value = provider?.toString().trim().toLowerCase();
+  if (value === "gemini") {
+    return "gemini";
+  }
+  if (value === "openai") {
+    return "openai";
+  }
+  return "openai";
+}
+
+function getEnvKey(provider) {
+  const normalized = normalizeProvider(provider);
+  if (normalized === "gemini") {
+    return process.env.GEMINI_API_KEY || null;
+  }
+  return process.env.OPENAI_API_KEY || null;
+}
+
+export { getEnvKey };
+
+function getEnvModel(provider) {
+  if (normalizeProvider(provider) === "gemini") {
+    return process.env.GEMINI_MODEL || "gemini-2.5-flash";
+  }
+
+  return process.env.OPENAI_MODEL || "gpt-3.5-turbo";
+}
+
+function parseGeminiText(result) {
+  const candidate = result?.candidates?.[0];
+  if (!candidate) {
+    return "";
+  }
+
+  if (typeof candidate.output === "string") {
+    return candidate.output;
+  }
+
+  if (Array.isArray(candidate.output)) {
+    for (const item of candidate.output) {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (item?.content) {
+        const contentArray = Array.isArray(item.content) ? item.content : [item.content];
+        for (const part of contentArray) {
+          if (typeof part?.text === "string") {
+            return part.text;
+          }
+        }
+      }
+    }
+  }
+
+  return result?.candidates?.[0]?.content?.[0]?.text || "";
+}
+
+async function callLLM(systemPrompt, userPrompt, config) {
+  const provider = normalizeProvider(config?.provider);
+  const apiKey = config?.apiKey || getEnvKey(provider);
+
+  if (!apiKey) {
+    throw new Error("Missing API key");
+  }
+
+  const model = getEnvModel(provider);
+
+  if (provider === "gemini") {
+    const client = new GoogleGenerativeAI(apiKey);
+    const modelClient = client.getGenerativeModel({
+      model,
+      generationConfig: {
+        temperature: 0.6,
+        maxOutputTokens: 500,
+      },
+    });
+
+    const response = await modelClient.generateContent({
+      contents: [
+        {
+          parts: [
+            {
+              text: `${systemPrompt}\n\n${userPrompt}`,
+            },
+          ],
+        },
+      ],
+    });
+
+    return parseGeminiText(response).trim();
+  }
+
+  const openai = new OpenAI({ apiKey });
+  const response = await openai.chat.completions.create({
+    model,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ],
+    temperature: 0.6,
+    max_tokens: 500,
+  });
+
+  return response.choices?.[0]?.message?.content?.trim() ?? "";
+}
+
+function collectCommitMessages(commits) {
+  return commits
+    .map((commit) => (typeof commit === "string" ? commit : commit.message || ""))
+    .filter(Boolean);
+}
+
+function fallbackSummary(commits) {
+  const messages = collectCommitMessages(commits);
+  if (!messages.length) {
+    return "No commit messages available to summarize.";
+  }
+
+  const topMessages = messages.slice(0, 5).map((message) => `• ${message}`);
+  return `Recent work includes ${messages.length} update${messages.length > 1 ? "s" : ""}. ${topMessages.join(" ")}`;
+}
+
+function fallbackRiskAnalysis(diffSummary) {
+  const files = Array.isArray(diffSummary.files) ? diffSummary.files.length : diffSummary.files;
+  const insertions = diffSummary.insertions ?? 0;
+  const deletions = diffSummary.deletions ?? 0;
+
+  const points = [`This diff touches ${files} file${files === 1 ? "" : "s"}.`, `Insertions: ${insertions}, deletions: ${deletions}.`, `Larger insertions or deletions increase the chance of regression.`];
+  return points.join(" ");
+}
+
+function fallbackCodebasePatterns(commits) {
+  const messages = collectCommitMessages(commits);
+  if (!messages.length) {
+    return "No commit history available to identify codebase patterns.";
+  }
+
+  const lower = messages.map((message) => message.toLowerCase());
+  const aiSignals = lower.filter((message) => /\b(ai|gpt|copilot|generated|auto-generated|openai)\b/.test(message));
+  const duplicates = messages.filter((message, index) => messages.indexOf(message) !== index);
+  const styles = new Set(messages.map((message) => message.trim().match(/^[^:\-\s]+/)?.[0]?.toLowerCase() || "").filter(Boolean));
+
+  const observations = [];
+  if (aiSignals.length) {
+    observations.push("Commit history includes language that may indicate AI-assisted or generated work.");
+  }
+  if (duplicates.length) {
+    observations.push("Some messages repeat, which can indicate duplicate work or inconsistent commit granularity.");
+  }
+  if (styles.size > 2) {
+    observations.push("Commit message style is inconsistent, which may reflect varying structure in the codebase.");
+  }
+
+  return observations.length ? observations.join(" ") : "No strong patterns identified in the commit history.";
+}
+
+export async function generateDevSummary(commits, config) {
+  const messages = collectCommitMessages(commits);
+  if (!messages.length) {
+    return { text: "No commit messages available to summarize.", aiUsed: false };
+  }
+
+  const systemPrompt = "You are an intelligent developer assistant that writes concise developer summaries in clear, human language without markdown.";
+  const userPrompt = `Summarize the following commit messages as a developer update. Explain the work and its impact in a natural devlog tone. Do not use markdown. Commit messages:\n${messages.join("\n")}`;
+
+  try {
+    const text = await callLLM(systemPrompt, userPrompt, config);
+    return { text: text.trim() || fallbackSummary(commits), aiUsed: true };
+  } catch (err) {
+    warn(`AI summary failed: ${err.message}. Using fallback summary.`);
+    return { text: fallbackSummary(commits), aiUsed: false };
+  }
+}
+
+export async function analyzeRiskWithAI(diffSummary, config) {
+  const combined = `Files changed: ${Array.isArray(diffSummary.files) ? diffSummary.files.length : diffSummary.files}. Insertions: ${diffSummary.insertions ?? 0}. Deletions: ${diffSummary.deletions ?? 0}.`;
+  const systemPrompt = "You are an engineering risk analyst. Provide a clear explanation of risk and likely failure points based on diff metrics.";
+  const userPrompt = `Analyze the following diff summary. Explain why the changes may be risky, identify possible failure points, and describe what the team should watch for. Do not use markdown. Summary: ${combined}`;
+
+  try {
+    const text = await callLLM(systemPrompt, userPrompt, config);
+    return { text: text.trim() || fallbackRiskAnalysis(diffSummary), aiUsed: true };
+  } catch (err) {
+    warn(`AI risk analysis failed: ${err.message}. Using fallback risk explanation.`);
+    return { text: fallbackRiskAnalysis(diffSummary), aiUsed: false };
+  }
+}
+
+export async function analyzeCodebasePatterns(commits, config) {
+  const messages = collectCommitMessages(commits);
+  if (!messages.length) {
+    return { text: "No commit history available to identify codebase patterns.", aiUsed: false };
+  }
+
+  const systemPrompt = "You are an engineering assistant that detects codebase quality patterns from commit history.";
+  const userPrompt = `Review the following commit messages and describe any signs of AI-generated code patterns, duplication, or inconsistent structure. Keep the answer brief and plain text.\n${messages.join("\n")}`;
+
+  try {
+    const text = await callLLM(systemPrompt, userPrompt, config);
+    return { text: text.trim() || fallbackCodebasePatterns(commits), aiUsed: true };
+  } catch (err) {
+    warn(`AI codebase pattern analysis failed: ${err.message}. Using fallback pattern analysis.`);
+    return { text: fallbackCodebasePatterns(commits), aiUsed: false };
+  }
+}
+
+export function categorizeCommits(commits) {
+  const categories = {
+    features: [],
+    fixes: [],
+    refactoring: [],
+    docs: [],
+    other: [],
+  };
+
+  commits.forEach((commit) => {
+    const message = (typeof commit === "string" ? commit : commit.message || "").toLowerCase().trim();
+    if (message.startsWith("feat") || message.includes("add") || message.includes("new")) {
+      categories.features.push(commit);
+    } else if (message.startsWith("fix") || message.includes("fix")) {
+      categories.fixes.push(commit);
+    } else if (message.startsWith("refactor") || message.includes("refactor") || message.includes("cleanup")) {
+      categories.refactoring.push(commit);
+    } else if (message.startsWith("docs") || message.includes("doc")) {
+      categories.docs.push(commit);
+    } else {
+      categories.other.push(commit);
+    }
+  });
+
+  return categories;
+}
+
+export function extractHighlights(commits) {
+  const categories = categorizeCommits(commits);
+  const highlights = [];
+
+  if (categories.features.length > 0) {
+    const topFeature = cleanMessage(categories.features[0].message);
+    highlights.push(`✨ Key feature: ${topFeature}`);
+  }
+
+  if (categories.fixes.length > 0) {
+    const topFix = cleanMessage(categories.fixes[0].message);
+    highlights.push(`🐛 Fixed: ${topFix}`);
+  }
+
+  return highlights;
+}
+
+function cleanMessage(msg) {
+  return msg
+    .trim()
+    .replace(/^(feat|fix|refactor|docs)\s*:?\s*/i, "")
+    .replace(/^#\d+\s+/g, "")
+    .replace(/\s+$/, "");
+}

package/src/services/config.js

@@ -0,0 +1,142 @@
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import readline from "readline";
+
+const CONFIG_DIR = path.join(os.homedir(), ".gitbrain");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+function question(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+export async function ensureConfigExists() {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+}
+
+export function getEnvConfig(requestedProvider) {
+  const hasOpenAI = Boolean(process.env.OPENAI_API_KEY);
+  const hasGemini = Boolean(process.env.GEMINI_API_KEY);
+  const requested = requestedProvider?.toString().trim().toLowerCase();
+
+  if (requested === "openai") {
+    return hasOpenAI ? { provider: "openai", apiKey: process.env.OPENAI_API_KEY } : null;
+  }
+
+  if (requested === "gemini") {
+    return hasGemini ? { provider: "gemini", apiKey: process.env.GEMINI_API_KEY } : null;
+  }
+
+  if (hasOpenAI) {
+    return { provider: "openai", apiKey: process.env.OPENAI_API_KEY };
+  }
+
+  if (hasGemini) {
+    return { provider: "gemini", apiKey: process.env.GEMINI_API_KEY };
+  }
+
+  return null;
+}
+
+export async function loadConfig() {
+  await ensureConfigExists();
+
+  try {
+    const raw = await fs.readFile(CONFIG_FILE, "utf8");
+    if (!raw.trim()) {
+      return null;
+    }
+
+    const config = JSON.parse(raw);
+    if (!config || typeof config !== "object") {
+      return null;
+    }
+
+    if (typeof config.provider !== "string" || typeof config.apiKey !== "string") {
+      return null;
+    }
+
+    return {
+      provider: config.provider.toLowerCase(),
+      apiKey: config.apiKey,
+    };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+
+    if (err.name === "SyntaxError") {
+      await fs.rm(CONFIG_FILE, { force: true });
+      return null;
+    }
+
+    throw err;
+  }
+}
+
+export async function getConfig(options = {}) {
+  const { promptIfMissing = true } = options;
+  const stored = await loadConfig();
+  if (stored) {
+    return { config: stored, isStored: true };
+  }
+
+  const envConfig = getEnvConfig();
+  if (envConfig) {
+    return { config: envConfig, isStored: false };
+  }
+
+  if (!promptIfMissing) {
+    return { config: null, isStored: false };
+  }
+
+  const config = await promptForConfig();
+  return { config, isStored: false };
+}
+
+export async function saveConfig(config) {
+  await ensureConfigExists();
+  const safeConfig = {
+    provider: config.provider.toLowerCase(),
+    apiKey: config.apiKey,
+  };
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(safeConfig, null, 2), "utf8");
+  return safeConfig;
+}
+
+export async function deleteConfig() {
+  try {
+    await fs.rm(CONFIG_FILE, { force: true });
+  } catch (err) {
+    // ignore
+  }
+}
+
+export async function promptConfig(defaultProvider = "openai") {
+  const providerPrompt = `Choose LLM provider (openai/gemini) [${defaultProvider}]: `;
+  let rawProvider = (await question(providerPrompt)).trim().toLowerCase();
+  if (!rawProvider) {
+    rawProvider = defaultProvider;
+  }
+  if (rawProvider !== "openai" && rawProvider !== "gemini") {
+    rawProvider = "openai";
+  }
+
+  let apiKey = (await question(`Enter ${rawProvider} API key: `)).trim();
+  while (!apiKey) {
+    apiKey = (await question("API key is required. Enter API key: ")).trim();
+  }
+
+  return { provider: rawProvider, apiKey };
+}
+
+export async function promptForConfig(defaultProvider = "openai") {
+  const config = await promptConfig(defaultProvider);
+  return await saveConfig(config);
+}

package/src/utils/logger.js

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+
+export function info(message) {
+  console.log(chalk.blue("info"), message);
+}
+
+export function success(message) {
+  console.log(chalk.green("success"), message);
+}
+
+export function warn(message) {
+  console.warn(chalk.yellow("warn"), message);
+}
+
+export function error(err) {
+  const message = typeof err === "string" ? err : err?.message ?? "An unexpected error occurred.";
+  console.error(chalk.red("error"), message);
+}
+
+export function formatGitError() {
+  console.error(chalk.red("error"), "Not a Git repository");
+  console.error(chalk.dim("  This command must be run inside a Git repository."));
+  console.error(chalk.dim("  Try: git init"));
+}
+