genai-commit 0.0.0

package/dist/chunk-PPSTCEXT.js

@@ -0,0 +1,829 @@
+// src/utils/exec.ts
+import { spawn } from "child_process";
+async function execCommand(command, args, options = {}) {
+  const { input, timeout = 12e4, cwd } = options;
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill("SIGTERM");
+      reject(new Error(`Command timed out after ${timeout}ms`));
+    }, timeout);
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (!killed) {
+        resolve({
+          stdout,
+          stderr,
+          exitCode: code ?? 0
+        });
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    if (input) {
+      proc.stdin.write(input);
+      proc.stdin.end();
+    }
+  });
+}
+async function execSimple(command, args, options = {}) {
+  const result = await execCommand(command, args, options);
+  if (result.exitCode !== 0) {
+    throw new Error(`Command failed with exit code ${result.exitCode}: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+
+// src/prompts/templates.ts
+var CLAUDE_COMMIT_PROMPT = `You are a commit message generator.
+
+Analyze the git diff and generate commit messages.
+
+Rules:
+- Follow Conventional Commits: type(scope): description
+- Types: feat, fix, docs, style, refactor, test, chore, perf, ci, build
+- Title under 72 characters
+- Split into multiple commits when changes are logically separate
+- Group related file changes into single commit when appropriate
+- NEVER include Jira ticket numbers (like AS-123, PROJ-456) in titles or messages
+- Jira tickets are assigned separately via the [t] option
+
+Language settings (check the input for TITLE_LANG and MESSAGE_LANG):
+- TITLE_LANG: Language for commit title (after the type(scope): prefix)
+- MESSAGE_LANG: Language for detailed message
+- Default: title in English, message in Korean
+
+Examples:
+- Title (en): "feat(auth): add OAuth login support"
+- Title (ko): "feat(auth): OAuth \uB85C\uADF8\uC778 \uC9C0\uC6D0 \uCD94\uAC00"
+- Message (en): "Implemented OAuth 2.0 flow with Google provider"
+- Message (ko): "Google OAuth 2.0 \uC778\uC99D \uD750\uB984 \uAD6C\uD604"
+
+Output ONLY valid JSON matching the required schema. No other text.`;
+var CLAUDE_REGROUP_PROMPT = `You are a commit message regrouper.
+
+Your task is to merge commits that share the same Jira ticket URL into a single commit.
+
+Rules:
+1. Commits with the SAME Jira URL must be merged into ONE commit
+2. Combine all files from the merged commits
+3. Create a new summarized title that covers all merged changes
+4. Create a new summarized message that describes all combined changes
+5. Keep the Jira URL in the merged commit (jira_url field)
+6. Commits WITHOUT a Jira URL should remain unchanged
+7. Follow Conventional Commits: type(scope): description
+8. Title under 72 characters
+
+Language settings (check the input for TITLE_LANG and MESSAGE_LANG):
+- TITLE_LANG: Language for commit title
+- MESSAGE_LANG: Language for detailed message
+
+Output ONLY valid JSON matching the required schema. No other text.`;
+var CURSOR_COMMIT_PROMPT = `You are a commit message generator. Analyze git changes and generate commit messages.
+
+IMPORTANT: You MUST reply ONLY in the EXACT format below. No markdown, no explanation, no other text.
+
+===COMMIT===
+FILES: file1.ts, file2.ts
+TITLE: type(scope): description
+MESSAGE: detailed message here
+
+RULES:
+1. Each commit block MUST start with ===COMMIT=== on its own line
+2. FILES: comma-separated file paths (use ONLY files from the input, NEVER invent files)
+3. TITLE: follow Conventional Commits format, under 72 characters
+4. MESSAGE: detailed description in specified language
+5. You may output multiple ===COMMIT=== blocks for separate logical changes
+6. Group related files into the same commit
+7. NEVER include Jira ticket numbers in titles or messages
+
+Conventional Commit Types:
+- feat: new feature
+- fix: bug fix
+- docs: documentation
+- style: formatting (no code change)
+- refactor: code restructuring
+- test: adding tests
+- chore: maintenance
+- perf: performance improvement
+- ci: CI/CD changes
+- build: build system changes
+
+Language Settings (check input for TITLE_LANG and MESSAGE_LANG):
+- TITLE_LANG: en = English title, ko = Korean title
+- MESSAGE_LANG: en = English message, ko = Korean message
+
+Example Output:
+===COMMIT===
+FILES: src/auth/login.ts, src/auth/logout.ts
+TITLE: feat(auth): add OAuth login support
+MESSAGE: OAuth 2.0 \uC778\uC99D \uD750\uB984\uC744 \uAD6C\uD604\uD558\uACE0 \uB85C\uADF8\uC544\uC6C3 \uCC98\uB9AC\uB97C \uCD94\uAC00\uD588\uC2B5\uB2C8\uB2E4.
+===COMMIT===
+FILES: src/utils/helper.ts
+TITLE: chore(utils): add helper functions
+MESSAGE: \uACF5\uD1B5 \uC720\uD2F8\uB9AC\uD2F0 \uD568\uC218\uB97C \uCD94\uAC00\uD588\uC2B5\uB2C8\uB2E4.`;
+var CURSOR_REGROUP_PROMPT = `You are a commit message regrouper. Merge commits with the same Jira ticket into a single commit.
+
+IMPORTANT: You MUST reply ONLY in the EXACT format below. No markdown, no explanation, no other text.
+
+===COMMIT===
+FILES: file1.ts, file2.ts
+TITLE: type(scope): description (JIRA-123)
+MESSAGE: detailed message here
+
+RULES:
+1. Merge all commits with the SAME Jira key into ONE commit
+2. Combine all files from merged commits (no duplicates)
+3. Create a summarized title covering all merged changes
+4. Add the Jira key at the end of the title: "description (AS-123)"
+5. Create a summarized message describing all combined changes
+6. Follow Conventional Commits format
+7. Title under 72 characters
+
+Language Settings (check input for TITLE_LANG and MESSAGE_LANG):
+- TITLE_LANG: en = English title, ko = Korean title
+- MESSAGE_LANG: en = English message, ko = Korean message
+
+Example Output:
+===COMMIT===
+FILES: src/components/Button.tsx, src/components/Input.tsx
+TITLE: feat(ui): add Button and Input components (AS-123)
+MESSAGE: Button\uACFC Input \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uCD94\uAC00\uD588\uC2B5\uB2C8\uB2E4.`;
+var COMMIT_SCHEMA = {
+  type: "object",
+  properties: {
+    commits: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" }
+          },
+          title: { type: "string" },
+          message: { type: "string" },
+          jira_key: { type: "string" }
+        },
+        required: ["files", "title", "message"]
+      }
+    }
+  },
+  required: ["commits"]
+};
+function getPromptTemplate(provider, category) {
+  if (provider === "claude") {
+    return category === "commit" ? CLAUDE_COMMIT_PROMPT : CLAUDE_REGROUP_PROMPT;
+  } else {
+    return category === "commit" ? CURSOR_COMMIT_PROMPT : CURSOR_REGROUP_PROMPT;
+  }
+}
+function getJsonSchema() {
+  return COMMIT_SCHEMA;
+}
+
+// src/parser/json.ts
+function parseJsonResponse(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed.commits || !Array.isArray(parsed.commits)) {
+      throw new Error("Response does not contain commits array");
+    }
+    const commits = parsed.commits.map((c) => ({
+      files: Array.isArray(c.files) ? c.files : [],
+      title: String(c.title || ""),
+      message: String(c.message || ""),
+      jiraKey: c.jira_key ? String(c.jira_key) : void 0
+    }));
+    const validCommits = commits.filter(
+      (c) => c.files.length > 0 && c.title.length > 0
+    );
+    if (validCommits.length === 0) {
+      throw new Error("No valid commits found in response");
+    }
+    return { commits: validCommits };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON response: ${raw.substring(0, 200)}...`);
+    }
+    throw error;
+  }
+}
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  maxInputSize: 3e4,
+  maxDiffSize: 15e3,
+  timeout: 12e4,
+  // 120 seconds
+  treeDepth: 3,
+  maxRetries: 2,
+  titleLang: "en",
+  messageLang: "ko"
+};
+var CURSOR_DEFAULT_MODEL = "gemini-3-flash";
+var CLAUDE_DEFAULT_MODEL = "haiku";
+
+// src/providers/claude.ts
+var ClaudeCodeProvider = class {
+  name = "claude-code";
+  sessionId;
+  timeout;
+  model;
+  constructor(options) {
+    this.timeout = options?.timeout ?? 12e4;
+    this.model = options?.model ?? CLAUDE_DEFAULT_MODEL;
+  }
+  async generate(input, promptType) {
+    const prompt = getPromptTemplate("claude", promptType);
+    const schema = getJsonSchema();
+    const args = [
+      "-p",
+      "--model",
+      this.model,
+      "--output-format",
+      "json",
+      "--json-schema",
+      JSON.stringify(schema),
+      "--append-system-prompt",
+      prompt
+    ];
+    if (this.sessionId) {
+      args.push("--resume", this.sessionId);
+    }
+    const result = await execCommand("claude", args, {
+      input,
+      timeout: this.timeout
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Claude CLI failed: ${result.stderr}`);
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      this.sessionId = parsed.session_id;
+      return {
+        raw: JSON.stringify(parsed.structured_output),
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse Claude response: ${result.stdout}`);
+    }
+  }
+  parseResponse(response) {
+    return parseJsonResponse(response.raw);
+  }
+  async login() {
+    console.log("Setting up Claude Code authentication...");
+    await execCommand("claude", ["setup-token"], { timeout: 6e4 });
+  }
+  async status() {
+    try {
+      const version = await execSimple("claude", ["--version"], { timeout: 1e4 });
+      return {
+        available: true,
+        version: version.trim(),
+        details: "Claude Code CLI is available"
+      };
+    } catch {
+      return {
+        available: false,
+        details: "Claude Code CLI not found. Install it first."
+      };
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  clearSession() {
+    this.sessionId = void 0;
+  }
+};
+
+// src/parser/delimiter.ts
+var COMMIT_DELIMITER = "===COMMIT===";
+function parseCommitBlock(block) {
+  const lines = block.split("\n");
+  let files = "";
+  let title = "";
+  let message = "";
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("FILES:")) {
+      files = trimmedLine.substring(6).trim();
+    } else if (trimmedLine.startsWith("TITLE:")) {
+      title = trimmedLine.substring(6).trim();
+    } else if (trimmedLine.startsWith("MESSAGE:")) {
+      message = trimmedLine.substring(8).trim();
+    }
+  }
+  if (!files || !title) {
+    return null;
+  }
+  const fileList = files.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+  if (fileList.length === 0) {
+    return null;
+  }
+  return {
+    files: fileList,
+    title,
+    message: message || ""
+  };
+}
+function parseDelimiterResponse(raw) {
+  const commits = [];
+  const blocks = raw.split(COMMIT_DELIMITER).slice(1);
+  for (const block of blocks) {
+    const trimmedBlock = block.trim();
+    if (trimmedBlock) {
+      const commit = parseCommitBlock(trimmedBlock);
+      if (commit) {
+        commits.push(commit);
+      }
+    }
+  }
+  if (commits.length === 0) {
+    throw new Error(
+      `No valid commits found in response. Raw response:
+${raw.substring(0, 500)}...`
+    );
+  }
+  return { commits };
+}
+function toDelimiterFormat(commits) {
+  return commits.map(
+    (c) => `${COMMIT_DELIMITER}
+FILES: ${c.files.join(", ")}
+TITLE: ${c.title}
+MESSAGE: ${c.message}`
+  ).join("\n");
+}
+
+// src/providers/cursor.ts
+var CursorCLIProvider = class {
+  name = "cursor-cli";
+  timeout;
+  model;
+  constructor(options) {
+    this.timeout = options?.timeout ?? 12e4;
+    this.model = options?.model ?? CURSOR_DEFAULT_MODEL;
+  }
+  async generate(input, promptType) {
+    const prompt = getPromptTemplate("cursor", promptType);
+    const fullInput = `${prompt}
+
+---
+
+${input}`;
+    const result = await execCommand(
+      "cursor",
+      ["agent", "-p", "--model", this.model, "--output-format", "text"],
+      {
+        input: fullInput,
+        timeout: this.timeout
+      }
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(`Cursor CLI failed: ${result.stderr}`);
+    }
+    return { raw: result.stdout };
+  }
+  parseResponse(response) {
+    return parseDelimiterResponse(response.raw);
+  }
+  async login() {
+    console.log("Logging in to Cursor...");
+    await execCommand("cursor", ["agent", "login"], { timeout: 6e4 });
+  }
+  async status() {
+    try {
+      const result = await execCommand("cursor", ["agent", "status"], { timeout: 1e4 });
+      return {
+        available: true,
+        details: result.stdout.trim() || "Cursor CLI is available"
+      };
+    } catch {
+      return {
+        available: false,
+        details: "Cursor CLI not available. Install it first."
+      };
+    }
+  }
+  getSessionId() {
+    return void 0;
+  }
+  clearSession() {
+  }
+};
+
+// src/providers/index.ts
+function createProvider(type, options) {
+  switch (type) {
+    case "claude-code":
+      return new ClaudeCodeProvider(options);
+    case "cursor-cli":
+      return new CursorCLIProvider(options);
+    default:
+      throw new Error(`Unknown provider: ${type}`);
+  }
+}
+function isValidProviderType(type) {
+  return type === "claude-code" || type === "cursor-cli";
+}
+
+// src/git/status.ts
+import simpleGit from "simple-git";
+var gitInstance = null;
+function getGit(cwd) {
+  if (!gitInstance || cwd) {
+    gitInstance = simpleGit(cwd);
+  }
+  return gitInstance;
+}
+async function isGitRepository(cwd) {
+  try {
+    const git = getGit(cwd);
+    await git.revparse(["--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch(cwd) {
+  const git = getGit(cwd);
+  const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+  return branch.trim();
+}
+async function getGitStatus(cwd) {
+  const git = getGit(cwd);
+  const status = await git.status();
+  const changes = [];
+  const stats = {
+    added: 0,
+    modified: 0,
+    deleted: 0,
+    renamed: 0,
+    untracked: 0,
+    total: 0
+  };
+  for (const file of status.created) {
+    changes.push({ file, status: "A" });
+    stats.added++;
+  }
+  for (const file of status.modified) {
+    changes.push({ file, status: "M" });
+    stats.modified++;
+  }
+  for (const file of status.deleted) {
+    changes.push({ file, status: "D" });
+    stats.deleted++;
+  }
+  for (const file of status.renamed) {
+    changes.push({ file: file.to, status: "R" });
+    stats.renamed++;
+  }
+  for (const file of status.not_added) {
+    if (!changes.some((c) => c.file === file)) {
+      changes.push({ file, status: "M" });
+      stats.modified++;
+    }
+  }
+  for (const file of status.files) {
+    if (file.index === "?" && file.working_dir === "?") {
+      changes.push({ file: file.path, status: "?" });
+      stats.untracked++;
+    }
+  }
+  stats.total = stats.added + stats.modified + stats.deleted + stats.renamed + stats.untracked;
+  return { changes, stats };
+}
+async function getAllChangedFiles(cwd) {
+  const { changes } = await getGitStatus(cwd);
+  return new Set(changes.map((c) => c.file));
+}
+async function hasChanges(cwd) {
+  const { stats } = await getGitStatus(cwd);
+  return stats.total > 0;
+}
+
+// src/git/tree.ts
+var DEFAULT_OPTIONS = {
+  treeDepth: 3,
+  compressionThreshold: 10
+};
+function getExtension(file) {
+  const match = file.match(/\.([^./]+)$/);
+  return match ? match[1] : "";
+}
+function generateTreeSummary(files, changeType, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (files.length === 0) {
+    return "";
+  }
+  if (files.length <= opts.compressionThreshold) {
+    return files.map((f) => `${changeType} ${f}`).join("\n");
+  }
+  const dirGroups = /* @__PURE__ */ new Map();
+  const directFiles = [];
+  for (const file of files) {
+    const parts = file.split("/");
+    if (parts.length <= opts.treeDepth) {
+      directFiles.push(`${changeType} ${file}`);
+    } else {
+      const dir = parts.slice(0, opts.treeDepth).join("/");
+      const ext = getExtension(file);
+      if (!dirGroups.has(dir)) {
+        dirGroups.set(dir, { count: 0, extensions: /* @__PURE__ */ new Map() });
+      }
+      const group = dirGroups.get(dir);
+      group.count++;
+      if (ext) {
+        group.extensions.set(ext, (group.extensions.get(ext) ?? 0) + 1);
+      }
+    }
+  }
+  const compressed = [...dirGroups.entries()].map(([dir, group]) => {
+    const extSummary = [...group.extensions.entries()].map(([ext, count]) => `${count} *.${ext}`).join(", ");
+    if (extSummary) {
+      return `${changeType} ${dir}/ [${group.count} files: ${extSummary}]`;
+    } else {
+      return `${changeType} ${dir}/ [${group.count} files]`;
+    }
+  });
+  return [...directFiles, ...compressed].join("\n");
+}
+function generateFullTreeSummary(branch, changes, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const added = changes.filter((c) => c.status === "A").map((c) => c.file);
+  const modified = changes.filter((c) => c.status === "M").map((c) => c.file);
+  const deleted = changes.filter((c) => c.status === "D").map((c) => c.file);
+  const renamed = changes.filter((c) => c.status === "R").map((c) => c.file);
+  const untracked = changes.filter((c) => c.status === "?").map((c) => c.file);
+  const total = added.length + modified.length + deleted.length + renamed.length + untracked.length;
+  let output = `=== CHANGE SUMMARY ===
+Branch: ${branch}
+Total: ${total} files
+  - Added (A): ${added.length}
+  - Modified (M): ${modified.length}
+  - Deleted (D): ${deleted.length}
+  - Renamed (R): ${renamed.length}
+  - Untracked (?): ${untracked.length}
+
+=== FILE TREE ===
+`;
+  if (modified.length > 0) {
+    output += `
+--- Modified (${modified.length}) ---
+`;
+    output += generateTreeSummary(modified, "M", opts);
+    output += "\n";
+  }
+  if (added.length > 0) {
+    output += `
+--- Added (${added.length}) ---
+`;
+    output += generateTreeSummary(added, "A", opts);
+    output += "\n";
+  }
+  if (deleted.length > 0) {
+    output += `
+--- Deleted (${deleted.length}) ---
+`;
+    output += generateTreeSummary(deleted, "D", opts);
+    output += "\n";
+  }
+  if (renamed.length > 0) {
+    output += `
+--- Renamed (${renamed.length}) ---
+`;
+    output += generateTreeSummary(renamed, "R", opts);
+    output += "\n";
+  }
+  if (untracked.length > 0) {
+    output += `
+--- Untracked (${untracked.length}) ---
+`;
+    output += generateTreeSummary(untracked, "?", opts);
+    output += "\n";
+  }
+  return output;
+}
+
+// src/git/diff.ts
+var DEFAULT_OPTIONS2 = {
+  maxInputSize: 3e4,
+  maxDiffSize: 15e3,
+  treeDepth: 3
+};
+async function getModifiedDiffs(maxSize, cwd) {
+  const git = getGit(cwd);
+  const diffSummary = await git.diffSummary(["HEAD"]);
+  const modifiedFiles = diffSummary.files.filter((f) => !f.binary && "changes" in f && f.changes > 0).map((f) => f.file);
+  if (modifiedFiles.length === 0) {
+    return "";
+  }
+  let output = `
+=== MODIFIED FILE DIFFS (${modifiedFiles.length} files) ===`;
+  let currentSize = output.length;
+  for (const file of modifiedFiles) {
+    try {
+      const fileDiff = await git.diff(["HEAD", "--", file]);
+      const diffSize = fileDiff.length;
+      if (currentSize + diffSize + 100 > maxSize) {
+        const remaining = modifiedFiles.length - modifiedFiles.indexOf(file);
+        output += `
+
+[... ${remaining} more files truncated due to size limit]`;
+        break;
+      }
+      if (fileDiff) {
+        output += `
+
+--- ${file} ---
+${fileDiff}`;
+        currentSize += diffSize + file.length + 10;
+      }
+    } catch {
+    }
+  }
+  return output;
+}
+async function getDiffContent(treeSummary, options = {}, cwd) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const treeSize = treeSummary.length;
+  const remainingSize = opts.maxInputSize - treeSize - 500;
+  let diffContent = "";
+  if (remainingSize > 1e3) {
+    const maxDiff = Math.min(remainingSize, opts.maxDiffSize);
+    diffContent = await getModifiedDiffs(maxDiff, cwd);
+  }
+  return diffContent;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => console.log(chalk.cyan(message)),
+  success: (message) => console.log(chalk.green(message)),
+  warning: (message) => console.log(chalk.yellow(message)),
+  error: (message) => console.error(chalk.red(message)),
+  highlight: (message) => console.log(chalk.magenta(message)),
+  dim: (message) => console.log(chalk.dim(message))
+};
+var colors = {
+  red: chalk.red,
+  green: chalk.green,
+  yellow: chalk.yellow,
+  cyan: chalk.cyan,
+  blue: chalk.blue,
+  magenta: chalk.magenta,
+  dim: chalk.dim,
+  bold: chalk.bold
+};
+
+// src/git/executor.ts
+import fs from "fs";
+async function stageFiles(files, cwd) {
+  const git = getGit(cwd);
+  for (const file of files) {
+    try {
+      if (fs.existsSync(file)) {
+        await git.add(file);
+      } else {
+        try {
+          await git.rm(file);
+        } catch {
+          await git.add(["-A", file]);
+        }
+      }
+    } catch (error) {
+      logger.warning(`Failed to stage file: ${file}`);
+    }
+  }
+}
+async function executeCommit(commit, cwd) {
+  const git = getGit(cwd);
+  try {
+    let title = commit.title;
+    if (commit.jiraKey && !title.includes(`(${commit.jiraKey})`)) {
+      title = `${title} (${commit.jiraKey})`;
+    }
+    logger.info("Staging files...");
+    await stageFiles(commit.files, cwd);
+    logger.success(`Committing: ${title}`);
+    await git.commit([title, commit.message]);
+    return true;
+  } catch (error) {
+    logger.error(`Commit failed: ${error}`);
+    return false;
+  }
+}
+async function executeCommits(commits, cwd) {
+  for (let i = 0; i < commits.length; i++) {
+    const commit = commits[i];
+    console.log(colors.yellow(`
+Staging files for commit ${i + 1}/${commits.length}...`));
+    const success = await executeCommit(commit, cwd);
+    if (!success) {
+      logger.error("Commit failed. Aborting.");
+      return false;
+    }
+    console.log("");
+  }
+  logger.success("All commits completed successfully!");
+  return true;
+}
+
+// src/jira/extractor.ts
+var JIRA_KEY_PATTERN = /[A-Z]+-\d+/g;
+function extractJiraKeys(input) {
+  const matches = input.match(JIRA_KEY_PATTERN);
+  if (!matches) {
+    return [];
+  }
+  return [...new Set(matches)];
+}
+function formatJiraKeys(keys) {
+  return keys.join(", ");
+}
+function hasJiraKeys(input) {
+  return JIRA_KEY_PATTERN.test(input);
+}
+
+// src/utils/validation.ts
+var MAX_TITLE_LENGTH = 72;
+function validateTitleLength(commits) {
+  commits.forEach((commit, i) => {
+    if (commit.title.length > MAX_TITLE_LENGTH) {
+      logger.warning(
+        `Commit ${i + 1} title exceeds ${MAX_TITLE_LENGTH} chars (${commit.title.length} chars)`
+      );
+    }
+  });
+}
+function validateFilesExist(commits, validFiles) {
+  commits.forEach((commit) => {
+    commit.files.forEach((file) => {
+      if (!validFiles.has(file)) {
+        logger.warning(
+          `File '${file}' not in change list (may be AI hallucination or deleted file)`
+        );
+      }
+    });
+  });
+}
+function isValidConventionalCommit(title) {
+  const pattern = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build)(\([^)]+\))?:\s.+/;
+  return pattern.test(title);
+}
+
+export {
+  execCommand,
+  execSimple,
+  getPromptTemplate,
+  getJsonSchema,
+  parseJsonResponse,
+  DEFAULT_CONFIG,
+  CURSOR_DEFAULT_MODEL,
+  CLAUDE_DEFAULT_MODEL,
+  ClaudeCodeProvider,
+  parseDelimiterResponse,
+  toDelimiterFormat,
+  CursorCLIProvider,
+  createProvider,
+  isValidProviderType,
+  isGitRepository,
+  getCurrentBranch,
+  getGitStatus,
+  getAllChangedFiles,
+  hasChanges,
+  generateTreeSummary,
+  generateFullTreeSummary,
+  getModifiedDiffs,
+  getDiffContent,
+  logger,
+  colors,
+  stageFiles,
+  executeCommits,
+  extractJiraKeys,
+  formatJiraKeys,
+  hasJiraKeys,
+  validateTitleLength,
+  validateFilesExist,
+  isValidConventionalCommit
+};
+//# sourceMappingURL=chunk-PPSTCEXT.js.map