lovecode-ai 0.1.0

package/dist/chunk-G7VQGYJW.js

@@ -0,0 +1,858 @@
+// src/git/commands.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+function exec(cmd, cwd) {
+  try {
+    const stdout = execSync(cmd, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15e3
+    });
+    return { stdout: stdout.trim(), stderr: "", failed: false };
+  } catch (err) {
+    const e = err;
+    const toStr = (v) => {
+      if (!v) return "";
+      if (typeof v === "string") return v;
+      return v.toString("utf-8");
+    };
+    const stdout = toStr(e.stdout).trim();
+    const stderr = toStr(e.stderr).trim();
+    return { stdout, stderr: stderr || e.message, failed: true };
+  }
+}
+function isGitAvailable() {
+  try {
+    execSync("git --version", { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitRoot(cwd) {
+  const result = exec("git rev-parse --show-toplevel", cwd);
+  if (result.stderr) return null;
+  return result.stdout;
+}
+function isRepo(cwd) {
+  return getGitRoot(cwd) !== null;
+}
+function getCurrentBranch(cwd) {
+  const result = exec("git rev-parse --abbrev-ref HEAD", cwd);
+  return result.stdout || "unknown";
+}
+function getStatus(cwd) {
+  const root = getGitRoot(cwd);
+  const defaultCwd = root || cwd || process.cwd();
+  const branchStr = exec("git status --branch --porcelain=v2", defaultCwd);
+  const branch = getCurrentBranch(defaultCwd);
+  let behind = 0;
+  let ahead = 0;
+  const behindMatch = branchStr.stdout.match(/# branch\.ab \+(\d+) \-(\d+)/);
+  if (behindMatch) {
+    ahead = parseInt(behindMatch[1], 10);
+    behind = parseInt(behindMatch[2], 10);
+  }
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  const conflicted = [];
+  for (const line of branchStr.stdout.split("\n")) {
+    if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      const parts = line.split(" ");
+      const xy = parts[0].slice(0, 2);
+      const isStaged = xy[0] !== "." && xy[0] !== " ";
+      const isUnstaged = xy[1] !== "." && xy[1] !== " ";
+      const path3 = parts[parts.length - 1];
+      if (xy[0] === "u" || xy[1] === "u") {
+        conflicted.push(path3);
+      } else {
+        if (isStaged) staged.push(path3);
+        if (isUnstaged) unstaged.push(path3);
+      }
+    } else if (line.startsWith("? ")) {
+      untracked.push(line.slice(2));
+    }
+  }
+  return {
+    branch,
+    behind,
+    ahead,
+    staged,
+    unstaged,
+    untracked,
+    conflicted,
+    clean: staged.length === 0 && unstaged.length === 0 && untracked.length === 0 && conflicted.length === 0
+  };
+}
+function stageAll(cwd) {
+  const root = getGitRoot(cwd);
+  const result = exec("git add -A", root || cwd);
+  return !result.failed;
+}
+function stageFiles(files, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return false;
+  const result = exec(`git add -- ${files.map((f) => `"${f}"`).join(" ")}`, root);
+  return !result.failed;
+}
+function commit(message, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return { success: false, output: "Not a git repository" };
+  const result = exec(`git commit -m "${message.replace(/"/g, '\\"')}"`, root);
+  const output = (result.stdout + "\n" + result.stderr).toLowerCase();
+  if (output.includes("nothing to commit")) {
+    return { success: false, output: "Nothing to commit. Working tree clean." };
+  }
+  if (result.failed) {
+    return { success: false, output: result.stderr || result.stdout };
+  }
+  const hashMatch = result.stdout.match(/\[[\w-]+ ([a-f0-9]+)\]/);
+  return {
+    success: true,
+    hash: hashMatch?.[1],
+    output: result.stdout
+  };
+}
+function getDiff(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return "";
+  const result = exec("git diff --staged", root);
+  if (result.stdout) return result.stdout;
+  const unstaged = exec("git diff", root);
+  return unstaged.stdout;
+}
+function getStagedDiff(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return "";
+  const result = exec("git diff --cached", root);
+  return result.stdout;
+}
+function getUnstagedDiff(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return "";
+  const result = exec("git diff", root);
+  return result.stdout;
+}
+function getFullDiff(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return "";
+  const result = exec("git diff HEAD", root);
+  return result.stdout;
+}
+function getLog(count = 10, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return [];
+  const result = exec(`git log --oneline --format="%H|%ai|%an|%s" --max-count=${count}`, root);
+  if (!result.stdout) return [];
+  return result.stdout.split("\n").map((line) => {
+    const [hash, date, author, ...msgParts] = line.split("|");
+    return { hash, date, author, message: msgParts.join("|") };
+  });
+}
+function getBranches(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return [];
+  const result = exec("git branch -v", root);
+  if (!result.stdout) return [];
+  const branches = [];
+  for (const line of result.stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const current = line.startsWith("* ");
+    const parts = trimmed.replace(/^\*\s*/, "").split(/\s+/);
+    const name = parts[0];
+    branches.push({ current, name, behind: 0, ahead: 0 });
+  }
+  return branches;
+}
+function createBranch(name, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return false;
+  const result = exec(`git checkout -b "${name}"`, root);
+  return !result.failed;
+}
+function switchBranch(name, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return { success: false, output: "Not a git repository" };
+  const result = exec(`git checkout "${name}"`, root);
+  if (result.failed) return { success: false, output: result.stderr || result.stdout };
+  return { success: true, output: result.stdout || result.stderr };
+}
+function deleteBranch(name, force = false, cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return { success: false, output: "Not a git repository" };
+  const flag = force ? "-D" : "-d";
+  const result = exec(`git branch ${flag} "${name}"`, root);
+  if (result.failed) return { success: false, output: result.stderr || result.stdout };
+  return { success: true, output: result.stdout || result.stderr };
+}
+function cleanupMergedBranches(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return [];
+  const current = getCurrentBranch(root);
+  const result = exec("git branch --merged", root);
+  const deleted = [];
+  for (const line of result.stdout.split("\n")) {
+    const name = line.trim().replace(/^\*\s*/, "");
+    if (name && name !== current && name !== "main" && name !== "master") {
+      const del = deleteBranch(name, false, root);
+      if (del.success) deleted.push(name);
+    }
+  }
+  return deleted;
+}
+function getPRDiff(baseBranch = "main", cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return "";
+  const result = exec(`git diff ${baseBranch}...HEAD`, root);
+  return result.stdout;
+}
+function getPRLog(baseBranch = "main", cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return [];
+  const result = exec(`git log ${baseBranch}..HEAD --oneline --format="%H|%ai|%an|%s"`, root);
+  if (!result.stdout) return [];
+  return result.stdout.split("\n").map((line) => {
+    const [hash, date, author, ...msgParts] = line.split("|");
+    return { hash, date, author, message: msgParts.join("|") };
+  });
+}
+function hasConflicts(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return false;
+  const result = exec("git diff --name-only --diff-filter=U", root);
+  return result.stdout.trim().length > 0;
+}
+function getConflictFiles(cwd) {
+  const root = getGitRoot(cwd);
+  if (!root) return [];
+  const result = exec("git diff --name-only --diff-filter=U", root);
+  return result.stdout ? result.stdout.split("\n").filter(Boolean) : [];
+}
+function getConflictMarkers(filePath, cwd) {
+  const root = getGitRoot(cwd);
+  const fullPath = root ? path.join(root, filePath) : filePath;
+  if (!fs.existsSync(fullPath)) return [];
+  const content = fs.readFileSync(fullPath, "utf-8");
+  const lines = content.split("\n");
+  const markers = [];
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    if (l.startsWith("<<<<<<<")) markers.push({ line: i + 1, type: "start" });
+    else if (l.startsWith("=======")) markers.push({ line: i + 1, type: "separator" });
+    else if (l.startsWith(">>>>>>>")) markers.push({ line: i + 1, type: "end" });
+  }
+  return markers;
+}
+function formatStatus(status) {
+  const lines = [
+    `Branch: ${status.branch}`,
+    status.clean ? "(clean)" : ""
+  ].filter(Boolean);
+  if (status.behind || status.ahead) {
+    lines.push(`  ${status.behind > 0 ? `${status.behind} behind` : ""}${status.behind && status.ahead ? ", " : ""}${status.ahead > 0 ? `${status.ahead} ahead` : ""}`);
+  }
+  for (const [label, items] of [["Staged", status.staged], ["Unstaged", status.unstaged], ["Untracked", status.untracked], ["Conflicted", status.conflicted]]) {
+    if (items.length > 0) {
+      lines.push(`  ${label}:`);
+      for (const item of items.slice(0, 20)) {
+        lines.push(`    ${item}`);
+      }
+      if (items.length > 20) lines.push(`    ... and ${items.length - 20} more`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatBranches(branches) {
+  return branches.map((b) => `${b.current ? "* " : "  "}${b.name}`).join("\n");
+}
+function formatLog(log) {
+  return log.map((e) => `${e.hash.slice(0, 8)}  ${e.date.slice(0, 10)}  ${e.author}  ${e.message}`).join("\n");
+}
+function abbreviateDiff(diff, maxLines = 100) {
+  const lines = diff.split("\n");
+  if (lines.length <= maxLines) return diff;
+  return lines.slice(0, maxLines).join("\n") + `
+... (${lines.length - maxLines} more lines)`;
+}
+
+// src/ai/registry.ts
+import chalk2 from "chalk";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var LOG_LEVEL = (process.env.LOVECODE_LOG_LEVEL || "info").toUpperCase();
+var currentLevel = LogLevel[LOG_LEVEL] ?? 1 /* INFO */;
+var Logger = class {
+  static debug(...args) {
+    if (currentLevel <= 0 /* DEBUG */) {
+      console.error(chalk.dim("[debug]"), ...args);
+    }
+  }
+  static info(...args) {
+    if (currentLevel <= 1 /* INFO */) {
+      console.error(chalk.blue("[info]"), ...args);
+    }
+  }
+  static warn(...args) {
+    if (currentLevel <= 2 /* WARN */) {
+      console.error(chalk.yellow("[warn]"), ...args);
+    }
+  }
+  static error(...args) {
+    if (currentLevel <= 3 /* ERROR */) {
+      console.error(chalk.red("[error]"), ...args);
+    }
+  }
+};
+
+// src/ai/ollama.ts
+var OllamaProvider = class {
+  name = "ollama";
+  async chat(messages, config) {
+    const baseUrl = config.baseUrl || "http://localhost:11434";
+    Logger.debug(`Ollama chat: ${config.model} (${messages.length} messages)`);
+    const response = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: config.model,
+        messages,
+        stream: false,
+        options: {
+          temperature: config.temperature ?? 0.2,
+          num_predict: config.maxTokens ?? 4096
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.message?.content ?? "";
+  }
+  async *stream(messages, config) {
+    const baseUrl = config.baseUrl || "http://localhost:11434";
+    const response = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: config.model,
+        messages,
+        stream: true,
+        options: {
+          temperature: config.temperature ?? 0.2,
+          num_predict: config.maxTokens ?? 4096
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.done) return;
+          if (parsed.message?.content) {
+            yield parsed.message.content;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  async isAvailable(baseUrl) {
+    try {
+      const res = await fetch(`${baseUrl || "http://localhost:11434"}/api/tags`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/ai/openai-like.ts
+var OpenAILikeProvider = class {
+  name;
+  baseUrl;
+  constructor(name, baseUrl) {
+    this.name = name;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  async chat(messages, config) {
+    const url = `${this.baseUrl}/chat/completions`;
+    Logger.debug(`[${this.name}] chat: ${config.model} (${messages.length} messages)`);
+    const apiKey = this.getApiKey();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+      },
+      body: JSON.stringify({
+        model: config.model,
+        messages,
+        temperature: config.temperature ?? 0.2,
+        max_tokens: config.maxTokens ?? 4096,
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`[${this.name}] API error ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content ?? "";
+  }
+  async *stream(messages, config) {
+    const url = `${this.baseUrl}/chat/completions`;
+    const apiKey = this.getApiKey();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+      },
+      body: JSON.stringify({
+        model: config.model,
+        messages,
+        temperature: config.temperature ?? 0.2,
+        max_tokens: config.maxTokens ?? 4096,
+        stream: true
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`[${this.name}] API error ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const jsonStr = trimmed.slice(6).trim();
+        if (jsonStr === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(jsonStr);
+          const content = parsed.choices?.[0]?.delta?.content;
+          if (content) yield content;
+        } catch {
+        }
+      }
+    }
+  }
+  getApiKey() {
+    const envVar = this.name.toUpperCase();
+    return process.env[`${envVar}_API_KEY`] || process.env.OPENAI_API_KEY;
+  }
+  async isAvailable() {
+    try {
+      const res = await fetch(`${this.baseUrl}/models`, {
+        headers: this.getApiKey() ? { Authorization: `Bearer ${this.getApiKey()}` } : {}
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/ai/registry.ts
+var registry = [
+  {
+    name: "ollama",
+    provider: new OllamaProvider(),
+    models: ["codellama", "deepseek-coder", "llama3.2", "llama3.1", "mistral", "mixtral", "phi3", "qwen2.5-coder"],
+    local: true,
+    priority: 10,
+    defaultModel: "codellama",
+    getConfig: (model) => ({
+      model,
+      baseUrl: "http://localhost:11434",
+      temperature: 0.2,
+      maxTokens: 8192
+    })
+  },
+  {
+    name: "groq",
+    provider: new OpenAILikeProvider("groq", "https://api.groq.com/openai/v1"),
+    models: ["llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768", "gemma2-9b-it", "deepseek-r1-distill-llama-70b"],
+    local: false,
+    priority: 30,
+    defaultModel: "llama3-70b-8192",
+    getConfig: (model) => ({
+      model,
+      baseUrl: "https://api.groq.com/openai/v1",
+      temperature: 0.2,
+      maxTokens: 8192
+    })
+  },
+  {
+    name: "openrouter",
+    provider: new OpenAILikeProvider("openrouter", "https://openrouter.ai/api/v1"),
+    models: [
+      "google/gemini-2.0-flash-001",
+      "google/gemini-2.0-flash-lite-preview",
+      "mistralai/mistral-7b-instruct",
+      "meta-llama/llama-3.2-3b-instruct",
+      "deepseek/deepseek-chat",
+      "qwen/qwen-2.5-7b-instruct"
+    ],
+    local: false,
+    priority: 40,
+    defaultModel: "google/gemini-2.0-flash-001",
+    getConfig: (model) => ({
+      model,
+      baseUrl: "https://openrouter.ai/api/v1",
+      temperature: 0.2,
+      maxTokens: 8192
+    })
+  },
+  {
+    name: "together",
+    provider: new OpenAILikeProvider("together", "https://api.together.xyz/v1"),
+    models: [
+      "mistralai/Mixtral-8x22B-Instruct-v0.1",
+      "mistralai/Mistral-7B-Instruct-v0.3",
+      "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+      "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+      "deepseek-ai/deepseek-coder-33b-instruct",
+      "Qwen/Qwen2.5-7B-Instruct-Turbo"
+    ],
+    local: false,
+    priority: 50,
+    defaultModel: "mistralai/Mixtral-8x22B-Instruct-v0.1",
+    getConfig: (model) => ({
+      model,
+      baseUrl: "https://api.together.xyz/v1",
+      temperature: 0.2,
+      maxTokens: 8192
+    })
+  },
+  {
+    name: "huggingface",
+    provider: new OpenAILikeProvider("huggingface", "https://api-inference.huggingface.co/v1"),
+    models: [
+      "HuggingFaceH4/zephyr-7b-beta",
+      "mistralai/Mistral-7B-Instruct-v0.3",
+      "meta-llama/Meta-Llama-3-8B-Instruct",
+      "google/gemma-2-9b-it"
+    ],
+    local: false,
+    priority: 60,
+    defaultModel: "HuggingFaceH4/zephyr-7b-beta",
+    getConfig: (model) => ({
+      model,
+      baseUrl: "https://api-inference.huggingface.co/v1",
+      temperature: 0.2,
+      maxTokens: 4096
+    })
+  }
+];
+function getProvider(name) {
+  return registry.find((p) => p.name === name);
+}
+function getProviderForModel(model) {
+  return registry.find((p) => p.models.includes(model) || p.defaultModel === model);
+}
+function getLocalProviders() {
+  return registry.filter((p) => p.local);
+}
+function resolveModel(modelOrProvider) {
+  const byName = getProvider(modelOrProvider);
+  if (byName) {
+    return { entry: byName, model: byName.defaultModel };
+  }
+  const byModel = getProviderForModel(modelOrProvider);
+  if (byModel) {
+    return { entry: byModel, model: modelOrProvider };
+  }
+  const local = getLocalProviders()[0];
+  return { entry: local, model: modelOrProvider };
+}
+function printProviders() {
+  const lines = [chalk2.bold("\n  Available Providers")];
+  for (const entry of registry) {
+    const tag = entry.local ? chalk2.green(" LOCAL ") : chalk2.blue(" CLOUD ");
+    const defaultModel = chalk2.dim(`(default: ${entry.defaultModel})`);
+    const models = entry.models.slice(0, 4).join(", ");
+    const more = entry.models.length > 4 ? chalk2.dim(` +${entry.models.length - 4} more`) : "";
+    lines.push(`
+  ${tag} ${chalk2.cyan(entry.name.padEnd(12))} ${defaultModel}`);
+    lines.push(`      ${chalk2.dim(models)}${more}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function setDefaultModel(model) {
+  const resolved = resolveModel(model);
+  resolved.entry.defaultModel = resolved.model;
+  return { provider: resolved.entry.name, model: resolved.model };
+}
+function getDefaultModel() {
+  const highest = [...registry].sort((a, b) => {
+    if (a.local && !b.local) return -1;
+    if (!a.local && b.local) return 1;
+    return a.priority - b.priority;
+  })[0];
+  return { provider: highest.name, model: highest.defaultModel };
+}
+
+// src/git/message.ts
+function getDefaultProvider() {
+  const defaultModel = getDefaultModel();
+  const resolved = resolveModel(defaultModel.model);
+  const provider = resolved.entry.provider;
+  const config = resolved.entry.getConfig ? resolved.entry.getConfig(resolved.model) : { model: resolved.model, temperature: 0.3, maxTokens: 512 };
+  return { provider, config };
+}
+var COMMIT_PROMPT = `You are a commit message generator. Analyze the provided git diff and generate a concise, conventional commit message.
+
+Format: <type>(<scope>): <description>
+
+Types: feat, fix, refactor, test, docs, style, chore, perf, ci
+Scope is optional.
+
+Rules:
+- First line: max 72 characters
+- If needed, follow with a blank line and bullet points for details
+- Focus on WHAT and WHY, not HOW
+- Use imperative mood
+
+Respond with ONLY the commit message, no explanations.`;
+var PR_SUMMARY_PROMPT = `You are a PR summary generator. Analyze the provided branch diff and commit log, then generate a comprehensive pull request summary.
+
+Format:
+## Summary
+<brief overview of changes>
+
+## Changes
+- <bullet point per logical change>
+
+## Motivation
+<why these changes were made>
+
+## Testing
+<suggested testing approach>
+
+Keep it concise but informative. Focus on the impact of changes.`;
+async function generateCommitMessage(options) {
+  if (!isGitAvailable()) return "git not available";
+  let diff = getStagedDiff();
+  if (!diff) diff = getFullDiff();
+  if (!diff) return "No changes detected";
+  const { provider, config } = options?.provider ? { provider: options.provider, config: options.providerConfig || { model: "default", temperature: 0.3, maxTokens: 512 } } : getDefaultProvider();
+  const truncatedDiff = abbreviateDiff(diff, 150);
+  const messages = [
+    { role: "system", content: COMMIT_PROMPT },
+    { role: "user", content: `Git diff:
+
+${truncatedDiff}` }
+  ];
+  try {
+    return await provider.chat(messages, { ...config, temperature: 0.3, maxTokens: 512 });
+  } catch {
+    return fallbackCommitMessage(diff);
+  }
+}
+async function generatePRSummary(baseBranch, options) {
+  if (!isGitAvailable()) return "git not available";
+  const branch = getCurrentBranch();
+  const base = baseBranch || "main";
+  const diff = getPRDiff(base);
+  const log = getPRLog(base);
+  if (!diff && log.length === 0) return `No changes between ${base} and ${branch}`;
+  const { provider, config } = options?.provider ? { provider: options.provider, config: options.providerConfig || { model: "default", temperature: 0.3, maxTokens: 1024 } } : getDefaultProvider();
+  const truncatedDiff = abbreviateDiff(diff, 200);
+  const commitLog = log.map((e) => `  - ${e.message}`).join("\n");
+  const messages = [
+    { role: "system", content: PR_SUMMARY_PROMPT },
+    {
+      role: "user",
+      content: `Branch: ${branch} \u2192 ${base}
+
+Commits:
+${commitLog}
+
+Diff:
+${truncatedDiff}`
+    }
+  ];
+  try {
+    return await provider.chat(messages, { ...config, temperature: 0.3, maxTokens: 1024 });
+  } catch {
+    return fallbackPRSummary(branch, base, log);
+  }
+}
+function fallbackCommitMessage(diff) {
+  const lines = diff.split("\n");
+  const added = lines.filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+  const removed = lines.filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+  const filesChanged = new Set(
+    lines.filter((l) => l.startsWith("diff --git")).map((l) => l.split(" b/")[1])
+  ).size;
+  const type = removed > added ? "fix" : "refactor";
+  return `${type}: update ${filesChanged} file${filesChanged > 1 ? "s" : ""} (+${added} -${removed})`;
+}
+function fallbackPRSummary(branch, base, log) {
+  return `## Summary
+Changes on branch \`${branch}\` relative to \`${base}\`.
+
+## Changes
+${log.map((e) => `- ${e.message}`).join("\n")}
+
+## Motivation
+Automated summary generated by LoveCode AI.`;
+}
+
+// src/git/conflict.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function detectConflicts(cwd) {
+  if (!isGitAvailable() || !isRepo(cwd)) return [];
+  if (!hasConflicts(cwd)) return [];
+  const files = getConflictFiles(cwd);
+  const root = getGitRoot(cwd);
+  return files.map((file) => {
+    const markers = getConflictMarkers(file, cwd);
+    const regions = [];
+    for (let i = 0; i < markers.length; i++) {
+      if (markers[i].type === "start") {
+        const end = markers.find((m, j) => j > i && m.type === "end");
+        if (end) {
+          regions.push({ startLine: markers[i].line, endLine: end.line });
+        }
+      }
+    }
+    const fullPath = root ? path2.join(root, file) : file;
+    let lineCount = 0;
+    try {
+      const content = fs2.readFileSync(fullPath, "utf-8");
+      lineCount = content.split("\n").length;
+    } catch {
+    }
+    return {
+      file,
+      markers: markers.length / 3,
+      lines: lineCount,
+      regions
+    };
+  });
+}
+function suggestResolutions(cwd) {
+  const conflicts = detectConflicts(cwd);
+  if (conflicts.length === 0) return [];
+  return conflicts.map((conflict) => {
+    const strategy = pickStrategy(conflict);
+    return {
+      file: conflict.file,
+      strategy: strategy.label,
+      explanation: strategy.explanation
+    };
+  });
+}
+function pickStrategy(conflict) {
+  if (conflict.regions.length <= 2 && conflict.markers <= 2) {
+    return {
+      label: "manual-edit",
+      explanation: `Small conflict in ${conflict.file} (${conflict.markers} conflict regions). Open the file, resolve each conflict region by keeping the appropriate changes, remove <<<<<<<, =======, >>>>>>> markers, then run 'git add ${conflict.file}' and 'git commit'.`
+    };
+  }
+  return {
+    label: "review-carefully",
+    explanation: `Multiple conflict regions in ${conflict.file}. Review each region carefully, keeping the correct combination of changes. After resolving all conflicts, use 'git add ${conflict.file}' and continue the merge with 'git commit'.`
+  };
+}
+function formatConflictInfo(conflicts) {
+  if (conflicts.length === 0) return "No merge conflicts detected.";
+  const lines = [`Merge Conflicts Detected (${conflicts.length} files):`];
+  for (const c of conflicts) {
+    lines.push(`  ${c.file}`);
+    lines.push(`    Conflict regions: ${c.markers}`);
+    lines.push(`    Total lines: ${c.lines}`);
+    for (const region of c.regions) {
+      lines.push(`    Lines ${region.startLine}-${region.endLine}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatResolutionSuggestions(suggestions) {
+  if (suggestions.length === 0) return "No resolution suggestions needed.";
+  const lines = ["Resolution Suggestions:"];
+  for (const s of suggestions) {
+    lines.push(`  File: ${s.file}`);
+    lines.push(`  Strategy: ${s.strategy}`);
+    lines.push(`  ${s.explanation}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export {
+  OllamaProvider,
+  isGitAvailable,
+  getGitRoot,
+  isRepo,
+  getCurrentBranch,
+  getStatus,
+  stageAll,
+  stageFiles,
+  commit,
+  getDiff,
+  getStagedDiff,
+  getUnstagedDiff,
+  getFullDiff,
+  getLog,
+  getBranches,
+  createBranch,
+  switchBranch,
+  deleteBranch,
+  cleanupMergedBranches,
+  getPRDiff,
+  getPRLog,
+  hasConflicts,
+  getConflictFiles,
+  getConflictMarkers,
+  formatStatus,
+  formatBranches,
+  formatLog,
+  abbreviateDiff,
+  getProvider,
+  printProviders,
+  setDefaultModel,
+  generateCommitMessage,
+  generatePRSummary,
+  detectConflicts,
+  suggestResolutions,
+  formatConflictInfo,
+  formatResolutionSuggestions
+};