@kb-labs/commit-core 0.6.0

package/dist/generator/index.js

@@ -0,0 +1,2694 @@
+import { useLogger, useAnalytics, useLLM } from '@kb-labs/sdk';
+import { simpleGit } from 'simple-git';
+import { dirname, basename, extname } from 'path';
+import { minimatch } from 'minimatch';
+import * as readline from 'readline';
+
+// src/generator/commit-plan.ts
+
+// src/generator/commit-tools.ts
+var COMMIT_PLAN_TOOL_PHASE3 = {
+  name: "generate_commit_plan",
+  description: "Generate commits for missing files - either extend existing commits or create new ones",
+  inputSchema: {
+    type: "object",
+    properties: {
+      commits: {
+        type: "array",
+        description: "List of commit actions. Can mix extend_existing and create_new actions.",
+        items: {
+          type: "object",
+          required: ["action", "files"],
+          properties: {
+            action: {
+              type: "string",
+              enum: ["create_new", "extend_existing"],
+              description: 'Whether to create a new commit or add files to an existing commit. Use "extend_existing" to avoid creating unnecessary commits.'
+            },
+            existingCommitId: {
+              type: "string",
+              description: 'ID of existing commit to extend (REQUIRED when action is "extend_existing"). Example: "c1", "c2".',
+              pattern: "^c[0-9]+$"
+            },
+            id: {
+              type: "string",
+              description: "Unique commit identifier (REQUIRED for create_new action, e.g., c1, c2, c3).",
+              pattern: "^c[0-9]+$"
+            },
+            type: {
+              type: "string",
+              enum: ["feat", "fix", "refactor", "chore", "docs", "test", "build", "ci", "perf"],
+              description: "Conventional commit type (REQUIRED for create_new action)."
+            },
+            scope: {
+              type: "string",
+              description: "Scope of the commit (optional)."
+            },
+            message: {
+              type: "string",
+              description: "Commit message in imperative mood (REQUIRED for create_new action).",
+              minLength: 5,
+              maxLength: 100
+            },
+            body: {
+              type: "string",
+              description: "Detailed description (optional)."
+            },
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of file paths to add to this commit.",
+              minItems: 1
+            },
+            releaseHint: {
+              type: "string",
+              enum: ["none", "patch", "minor", "major"],
+              description: "Semantic versioning impact (REQUIRED for create_new action)."
+            },
+            breaking: {
+              type: "boolean",
+              description: "Whether this is a breaking change.",
+              default: false
+            },
+            reasoning: {
+              type: "object",
+              description: "Reasoning for classification (REQUIRED for create_new action).",
+              properties: {
+                newBehavior: { type: "boolean" },
+                fixesBug: { type: "boolean" },
+                internalOnly: { type: "boolean" },
+                explanation: { type: "string", minLength: 10, maxLength: 300 },
+                confidence: { type: "number", minimum: 0, maximum: 1 }
+              }
+            }
+          }
+        }
+      }
+    },
+    required: ["commits"]
+  }
+};
+var COMMIT_PLAN_TOOL = {
+  name: "generate_commit_plan",
+  description: "Generate a structured commit plan with conventional commits following best practices",
+  inputSchema: {
+    type: "object",
+    properties: {
+      needsMoreContext: {
+        type: "boolean",
+        description: "Whether you need to see diff content to make accurate commit type decisions. Set to true if file paths and stats alone are insufficient.",
+        default: false
+      },
+      requestedFiles: {
+        type: "array",
+        items: { type: "string" },
+        description: "List of SPECIFIC files you need diffs for (MAXIMUM 15 files). Only request files where file path and stats are insufficient. DO NOT request all files - be selective and choose only the most critical/ambiguous ones. Prioritize files with unclear intent or complex changes.",
+        default: []
+      },
+      commits: {
+        type: "array",
+        description: "List of commit groups. Each commit groups related files by logical change (not by file type or directory).",
+        items: {
+          type: "object",
+          required: ["id", "type", "message", "files", "releaseHint", "breaking", "reasoning"],
+          properties: {
+            id: {
+              type: "string",
+              description: "Unique commit identifier (e.g., c1, c2, c3).",
+              pattern: "^c[0-9]+$"
+            },
+            type: {
+              type: "string",
+              enum: ["feat", "fix", "refactor", "chore", "docs", "test", "build", "ci", "perf"],
+              description: "Conventional commit type. Use refactor for internal changes, feat only for new user-facing features."
+            },
+            scope: {
+              type: "string",
+              description: 'Scope of the commit (e.g., "cli", "api", "core"). Should reflect affected area, not individual files.'
+            },
+            message: {
+              type: "string",
+              description: 'Commit message in imperative mood, lowercase, no period at end (e.g., "add authentication middleware")',
+              minLength: 5,
+              maxLength: 100
+            },
+            body: {
+              type: "string",
+              description: "Detailed description with bullet points listing affected files/changes. Use for commits with 2+ files."
+            },
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of file paths in this commit. Each file must appear in exactly ONE commit (no duplicates across commits).",
+              minItems: 1
+            },
+            releaseHint: {
+              type: "string",
+              enum: ["none", "patch", "minor", "major"],
+              description: 'Semantic versioning impact. Use "minor" for feat, "patch" for fix/refactor, "none" for chore/docs/test.'
+            },
+            breaking: {
+              type: "boolean",
+              description: "Whether this is a breaking change (breaks public API compatibility).",
+              default: false
+            },
+            reasoning: {
+              type: "object",
+              required: ["newBehavior", "fixesBug", "internalOnly", "explanation", "confidence"],
+              description: "Reasoning for commit type classification. Used for validation and debugging.",
+              properties: {
+                newBehavior: {
+                  type: "boolean",
+                  description: "Does this change add NEW USER-VISIBLE BEHAVIOR? (new API, feature, capability that users can access)"
+                },
+                fixesBug: {
+                  type: "boolean",
+                  description: "Does this change fix BROKEN functionality? (corrects bug or error)"
+                },
+                internalOnly: {
+                  type: "boolean",
+                  description: "Is this ONLY INTERNAL restructuring? (code reorganization, renaming, extracting functions without changing behavior)"
+                },
+                explanation: {
+                  type: "string",
+                  description: "Explain your classification decision. Why did you choose this commit type?",
+                  minLength: 10,
+                  maxLength: 300
+                },
+                confidence: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 1,
+                  description: "Confidence in this classification (0.0 to 1.0). Use <0.7 if you need more context (will trigger Phase 2)."
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    required: ["commits"]
+  }
+};
+async function getGitStatus(cwd) {
+  const git = simpleGit(cwd);
+  const status = await git.status(["--ignore-submodules=all"]);
+  return {
+    staged: status.staged.filter((f) => !shouldIgnoreFile(f)),
+    unstaged: [...status.modified, ...status.deleted].filter((f) => !status.staged.includes(f)).filter((f) => !shouldIgnoreFile(f)),
+    untracked: status.not_added.filter((f) => !shouldIgnoreFile(f))
+  };
+}
+function shouldIgnoreFile(file) {
+  const ignoredPaths = [
+    "node_modules/",
+    ".git/",
+    "dist/",
+    "build/",
+    ".next/",
+    ".turbo/",
+    "coverage/",
+    ".cache/",
+    ".temp/",
+    "tmp/"
+  ];
+  return ignoredPaths.some((path) => file.includes(path));
+}
+function getAllChangedFiles(status) {
+  const allFiles = [
+    .../* @__PURE__ */ new Set([...status.staged, ...status.unstaged, ...status.untracked])
+  ];
+  return allFiles.filter((file) => !shouldIgnoreFile(file));
+}
+function isTextFile(file) {
+  return !file.binary;
+}
+async function isNewFile(cwd, filePath) {
+  try {
+    const repo = await findGitRepo(cwd, filePath);
+    if (!repo) {
+      return true;
+    }
+    const git = simpleGit(repo.repoPath);
+    const result = await git.raw(["ls-tree", "HEAD", "--", repo.relativePath]);
+    return result.trim().length === 0;
+  } catch {
+    return true;
+  }
+}
+async function getFileSummaries(cwd, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  const filesByRepo = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const repo = await findGitRepo(cwd, file);
+    if (!repo) {
+      const group2 = filesByRepo.get(cwd) ?? [];
+      group2.push({ repoPath: cwd, relativePath: file, originalPath: file });
+      filesByRepo.set(cwd, group2);
+      continue;
+    }
+    const group = filesByRepo.get(repo.repoPath) ?? [];
+    group.push({
+      repoPath: repo.repoPath,
+      relativePath: repo.relativePath,
+      originalPath: file
+    });
+    filesByRepo.set(repo.repoPath, group);
+  }
+  for (const [repoPath, fileInfos] of filesByRepo) {
+    const git = simpleGit(repoPath);
+    const relativePaths = fileInfos.map((f) => f.relativePath);
+    try {
+      const stagedDiff = await git.diffSummary([
+        "--cached",
+        "--",
+        ...relativePaths
+      ]);
+      const unstagedDiff = await git.diffSummary(["--", ...relativePaths]);
+      const allDiffFiles = /* @__PURE__ */ new Map();
+      for (const file of unstagedDiff.files) {
+        allDiffFiles.set(file.file, file);
+      }
+      for (const file of stagedDiff.files) {
+        allDiffFiles.set(file.file, file);
+      }
+      for (const file of allDiffFiles.values()) {
+        const fileInfo = fileInfos.find((f) => f.relativePath === file.file);
+        if (!fileInfo) {
+          continue;
+        }
+        const isNew = await isNewFile(repoPath, file.file);
+        if (isTextFile(file)) {
+          summaries.push({
+            path: fileInfo.originalPath,
+            status: mapDiffStatus(file.insertions, file.deletions),
+            additions: file.insertions,
+            deletions: file.deletions,
+            binary: false,
+            isNewFile: isNew
+          });
+        } else {
+          summaries.push({
+            path: fileInfo.originalPath,
+            status: "modified",
+            additions: 0,
+            deletions: 0,
+            binary: true,
+            isNewFile: isNew
+          });
+        }
+      }
+      const processedPaths = new Set(
+        Array.from(allDiffFiles.values()).map((f) => f.file)
+      );
+      const missingInRepo = fileInfos.filter(
+        (f) => !processedPaths.has(f.relativePath)
+      );
+      for (const fileInfo of missingInRepo) {
+        summaries.push({
+          path: fileInfo.originalPath,
+          status: "added",
+          additions: 0,
+          deletions: 0,
+          binary: false,
+          isNewFile: true
+        });
+      }
+    } catch {
+      for (const fileInfo of fileInfos) {
+        summaries.push({
+          path: fileInfo.originalPath,
+          status: "modified",
+          additions: 0,
+          deletions: 0,
+          binary: false,
+          isNewFile: false
+          // Conservative assumption
+        });
+      }
+    }
+  }
+  return summaries;
+}
+function mapDiffStatus(insertions, deletions) {
+  if (deletions === 0 && insertions > 0) {
+    return "added";
+  }
+  if (insertions === 0 && deletions > 0) {
+    return "deleted";
+  }
+  return "modified";
+}
+async function getFileDiffs(cwd, files) {
+  if (files.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const diffs = /* @__PURE__ */ new Map();
+  const filesByRepo = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const repo = await findGitRepo(cwd, file);
+    if (!repo) {
+      const group2 = filesByRepo.get(cwd) ?? [];
+      group2.push({ repoPath: cwd, relativePath: file, originalPath: file });
+      filesByRepo.set(cwd, group2);
+      continue;
+    }
+    const group = filesByRepo.get(repo.repoPath) ?? [];
+    group.push({
+      repoPath: repo.repoPath,
+      relativePath: repo.relativePath,
+      originalPath: file
+    });
+    filesByRepo.set(repo.repoPath, group);
+  }
+  for (const [repoPath, fileInfos] of filesByRepo) {
+    const git = simpleGit(repoPath);
+    for (const { relativePath, originalPath } of fileInfos) {
+      try {
+        let diff = await git.diff(["--cached", "--", relativePath]);
+        if (!diff) {
+          diff = await git.diff(["--", relativePath]);
+        }
+        if (!diff) {
+          diff = await git.show([`:${relativePath}`]).catch(() => "");
+        }
+        if (diff) {
+          diffs.set(originalPath, diff);
+        }
+      } catch {
+      }
+    }
+  }
+  return diffs;
+}
+async function existsAsync(path) {
+  try {
+    const { existsSync } = await import('fs');
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+async function findGitRepo(basePath, filePath) {
+  const segments = filePath.split("/");
+  for (let i = segments.length - 1; i > 0; i--) {
+    const potentialRepoSegments = segments.slice(0, i);
+    const potentialRepoPath = `${basePath}/${potentialRepoSegments.join("/")}`;
+    const gitDir = `${potentialRepoPath}/.git`;
+    if (await existsAsync(gitDir)) {
+      const relativePath = segments.slice(i).join("/");
+      return { repoPath: potentialRepoPath, relativePath };
+    }
+  }
+  if (await existsAsync(`${basePath}/.git`)) {
+    return { repoPath: basePath, relativePath: filePath };
+  }
+  return null;
+}
+async function getRecentCommits(cwd, count = 10) {
+  const git = simpleGit(cwd);
+  try {
+    const log = await git.log({
+      maxCount: count,
+      format: {
+        message: "%s"
+        // Subject line only
+      }
+    });
+    return log.all.map((commit) => commit.message);
+  } catch {
+    return [];
+  }
+}
+
+// src/generator/llm-prompt.ts
+var SYSTEM_PROMPT = `You are a git commit message generator. Analyze the changed files and generate a commit plan.
+
+CRITICAL OUTPUT FORMAT:
+- Return ONLY a valid JSON object
+- Do NOT wrap in markdown code blocks (no \`\`\`json, no \`\`\`)
+- Do NOT add any text before or after the JSON
+- Ensure all strings are properly escaped (use double quotes, escape backslashes and quotes)
+
+IMPORTANT: You must assess your confidence level. If file paths and stats alone are not enough to determine the correct commit type and message, set needsMoreContext to true and list the files you need to see the diff for.
+
+CRITICAL GROUPING RULES:
+- Group files by LOGICAL CHANGE, not by file type or directory
+- If multiple files implement the same feature/fix/refactor, they belong in ONE commit
+- For initial project setup (many new files): group by package or functional area (contracts, core, cli, docs, tests)
+- Target: 3-8 commits for <50 files, 5-12 commits for 50-150 files, 10-20 commits for 150+ files
+- Ask yourself: "Would a developer make these changes in separate commits?" If no, group them!
+- CRITICAL: Each file must appear in EXACTLY ONE commit - no duplicates across commits!
+
+CRITICAL: FILE TYPE SHORTCUTS (check FIRST, before other rules):
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+\u{1F6AB} STOP! Check file extensions BEFORE asking questions below:
+
+\u{1F4DD} ALL files are *.md or *.mdx? \u2192 Type: docs (SKIP all questions below!)
+\u{1F9EA} ALL files in test/, __tests__/, *.test.ts, *.spec.ts? \u2192 Type: test
+\u274C If ANY file has code (.ts, .js, .tsx, .jsx, .py, etc.) \u2192 Continue to questions below
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+CRITICAL COMMIT TYPE CLASSIFICATION:
+For EACH commit, you MUST answer these questions to determine the correct type:
+
+1. Does this change add NEW USER-VISIBLE BEHAVIOR? (yes/no)
+   - Can users/developers do something they couldn't before?
+   - Is there a new API, feature, or capability?
+   \u2192 YES = likely feat
+
+2. Does this change fix BROKEN functionality? (yes/no)
+   - Was something not working correctly?
+   - Is this correcting a bug or error?
+   \u2192 YES = fix
+
+3. Is this ONLY INTERNAL restructuring? (yes/no)
+   - Code reorganization, renaming, extracting functions?
+   - Improving structure WITHOUT changing behavior?
+   - Modified files with balanced additions/deletions?
+   \u2192 YES = refactor
+
+4. Is this configuration, build, or maintenance work? (yes/no)
+   - Dependencies, build configs, tooling?
+   - No code logic changes?
+   \u2192 YES = chore
+
+DEFAULT BIAS: When uncertain between feat and refactor, choose refactor!
+
+Rules:
+1. Use conventional commits: feat, fix, refactor, chore, docs, test, build, ci, perf
+2. Group related files - number of commits should scale with file count (see grouping rules above)
+3. Each commit MUST include "reasoning" field explaining your classification
+4. Message should be lowercase, imperative mood, no period at end
+5. breaking: true only for breaking API changes
+6. For commits with 2+ files, add "body" with bullet points listing affected files/changes
+7. Scope should reflect the affected area (e.g., "cli", "api"), not individual files
+8. CRITICAL: If ALL files in a commit have status "deleted", use type "chore" or "refactor", NOT "feat"
+9. CRITICAL: If a commit is mostly deletions (>80% deletions), use "refactor" or "chore", NOT "feat"
+
+10. CRITICAL: WRITE INFORMATIVE COMMIT MESSAGES (not generic):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+    \u274C BAD (too generic):
+    - "add feature"
+    - "update files"
+    - "refactor code"
+    - "fix bug"
+    - "improve types"
+
+    \u2705 GOOD (specific and descriptive):
+    - "add JWT authentication with refresh token support"
+    - "update TypeScript configuration for strict mode"
+    - "refactor plugin execution to use factory pattern"
+    - "fix null pointer exception in authentication middleware"
+    - "improve type safety in workflow execution context"
+
+    Guidelines:
+    - Include WHAT was changed (specific feature/component)
+    - Include HOW if relevant (method, pattern, technology)
+    - Use concrete nouns (not "files", "code", "feature")
+    - Add context that helps reviewers understand the change
+    - For body: list specific changes, not just file names
+
+11. CRITICAL: SPECIFIC TYPE DETECTION (check BEFORE defaulting to refactor):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+    \u{1F4DD} docs: Documentation ONLY (no code changes)
+    \u2705 ALL files are markdown (*.md, *.mdx) \u2192 docs (even if IsNewFile: true)
+    \u2705 README.md, CONTRIBUTING.md, API docs, ADRs
+    \u2705 Files in docs/ or doc/ directory with only markdown
+    \u2705 JSDoc comments only (no logic changes)
+    \u274C NOT docs if ANY file has code logic changes
+
+    **IMPORTANT**: If ALL files end with .md or .mdx \u2192 ALWAYS use docs, NEVER feat!
+
+    \u{1F41B} fix: Corrects BROKEN functionality
+    \u2705 Bug fixes, error handling corrections
+    \u2705 Fixes crashes, incorrect behavior
+    \u2705 Corrects typos in USER-FACING text (not code comments)
+    \u274C NOT fix if adding new behavior (that's feat)
+
+    \u{1F9EA} test: Test files ONLY
+    \u2705 Files in test/, tests/, __tests__/, *.test.ts, *.spec.ts
+    \u2705 Adding/updating test cases
+    \u274C NOT test if also changing source code
+
+12. CRITICAL: IsNewFile flag determines STRONG BIAS against feat:
+
+    IsNewFile: FALSE (modified existing file):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+    \u2192 DEFAULT to refactor/fix/chore (NOT feat!)
+    \u2192 Only use feat if adds MAJOR new user-facing capability
+
+    Common cases where IsNewFile: false = NOT feat:
+    \u2705 Changed dependencies/imports \u2192 chore
+    \u2705 Added method to existing class \u2192 refactor
+    \u2705 Updated implementation logic \u2192 refactor
+    \u2705 Fixed bug in existing code \u2192 fix
+    \u2705 Renamed/moved code \u2192 refactor
+    \u2705 Modified config files \u2192 chore
+
+    \u274C WRONG: IsNewFile: false, minor additions \u2192 feat
+    \u2705 RIGHT: IsNewFile: false, minor additions \u2192 refactor
+
+
+    IsNewFile: TRUE (brand new file):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+    \u2192 Might be feat IF adds new user capability
+    \u2192 If only config/tooling/internal \u2192 chore
+
+    Examples:
+    \u2705 New API endpoint file \u2192 feat
+    \u2705 New CLI command file \u2192 feat
+    \u2705 New config file \u2192 chore
+    \u2705 New test file \u2192 test
+
+EXACT JSON SCHEMA (copy this structure):
+{
+  "needsMoreContext": false,
+  "requestedFiles": ["file1.ts"],
+  "commits": [
+    {
+      "id": "c1",
+      "type": "feat",
+      "scope": "auth",
+      "message": "add JWT authentication with refresh token support",
+      "body": "- implement JWT token generation and validation\\n- add refresh token rotation mechanism\\n- integrate with existing user authentication flow",
+      "files": ["src/auth/jwt-strategy.ts", "src/auth/refresh-token.ts", "src/middleware/auth.ts"],
+      "releaseHint": "minor",
+      "breaking": false,
+      "reasoning": {
+        "newBehavior": true,
+        "fixesBug": false,
+        "internalOnly": false,
+        "explanation": "Adds new JWT authentication capability with refresh tokens - enables secure stateless authentication for API users",
+        "confidence": 0.85
+      }
+    }
+  ]
+}
+
+VALID TYPE VALUES: feat, fix, refactor, chore, docs, test, build, ci, perf
+VALID RELEASEHINT VALUES: none, patch, minor, major
+
+EXAMPLE OUTPUT (use this as template):
+{
+  "needsMoreContext": false,
+  "requestedFiles": [],
+  "commits": [
+    {
+      "id": "c1",
+      "type": "feat",
+      "scope": "cli",
+      "message": "add commit generation command",
+      "body": "- implement generate command\\n- add LLM integration",
+      "files": ["src/commands/generate.ts", "src/llm.ts"],
+      "releaseHint": "minor",
+      "breaking": false,
+      "reasoning": {
+        "newBehavior": true,
+        "fixesBug": false,
+        "internalOnly": false,
+        "explanation": "New command allows users to generate commits with LLM - new capability",
+        "confidence": 0.9
+      }
+    },
+    {
+      "id": "c2",
+      "type": "test",
+      "message": "add tests for commit generator",
+      "files": ["tests/generate.test.ts"],
+      "releaseHint": "none",
+      "breaking": false,
+      "reasoning": {
+        "newBehavior": false,
+        "fixesBug": false,
+        "internalOnly": true,
+        "explanation": "Test coverage for new feature - internal quality improvement",
+        "confidence": 0.85
+      }
+    }
+  ]
+}
+
+REAL-WORLD EXAMPLES (learn from these patterns):
+
+Example 1: Modified files with low addition ratio \u2192 refactor, NOT feat
+Files:
+  - commit-plan.ts (modified, +150/-120)
+  - llm-prompt.ts (modified, +80/-60)
+Addition ratio: 230/350 = 65% (low, mostly structural changes)
+\u274C WRONG: feat(core): add commit plan and llm prompt generators
+\u2705 CORRECT: refactor(core): update commit plan and llm prompt logic
+Reason: Modified files + low addition ratio = refactoring existing code
+
+Example 2: New package with many files \u2192 feat, NOT chore
+Files: 21 new files in packages/core-resource-broker/
+  - package.json (new)
+  - src/broker/resource-broker.ts (new)
+  - src/queue/priority-queue.ts (new)
+  - ... (18 more new files)
+\u274C WRONG: chore(core-resource-broker): initialize core resource broker package
+\u2705 CORRECT: feat(core-resource-broker): add resource broker for rate limiting and queueing
+Reason: New package = new functionality = feat (even if many files)
+
+Example 3: Bulk move (many added files but not new) \u2192 refactor, NOT feat
+Files: 100 files with status "added" but isNewFile: false
+  - packages/analytics/core/file1.ts (added, isNewFile: false)
+  - packages/analytics/core/file2.ts (added, isNewFile: false)
+  - ... (98 more files, all moved from elsewhere)
+\u274C WRONG: feat(analytics): add analytics packages
+\u2705 CORRECT: refactor(analytics): reorganize analytics package structure
+Reason: isNewFile: false means files existed before, just moved/reorganized
+
+Example 4: All deleted files \u2192 chore, NOT feat
+Files: 22 files, all with status "deleted"
+  - packages/analytics/test1.spec.ts (deleted, +0/-1579)
+  - packages/analytics/test2.spec.ts (deleted, +0/-856)
+  - ... (20 more deleted files)
+\u274C WRONG: feat(analytics): add analytics functionality
+\u2705 CORRECT: chore(analytics): remove unused test files
+Reason: Deleting files is cleanup (chore), not new feature
+
+Example 5: True new feature (genuinely new files) \u2192 feat
+Files: 5 new files with isNewFile: true
+  - src/auth/jwt-strategy.ts (added, +200/-0, isNewFile: true)
+  - src/auth/auth-middleware.ts (added, +150/-0, isNewFile: true)
+  - ... (3 more new files)
+\u2705 CORRECT: feat(auth): add JWT authentication
+Reason: New functionality, truly new files, implements new capability
+
+Example 6: Documentation ONLY \u2192 docs, NOT chore or feat
+Files:
+  - README.md (modified, +50/-20, isNewFile: false)
+  - CONTRIBUTING.md (modified, +30/-10, isNewFile: false)
+  - docs/api.md (modified, +100/-50, isNewFile: false)
+\u274C WRONG: chore(docs): update documentation files
+\u274C WRONG: feat(docs): add documentation
+\u2705 CORRECT: docs: improve README and API documentation
+Reason: ALL files are markdown = docs (regardless of IsNewFile)
+
+Example 6b: NEW documentation files \u2192 docs, NOT feat
+Files:
+  - docs/benchmarks/README.md (added, +200/-0, isNewFile: true)
+  - docs/benchmarks/RESULTS.md (added, +100/-0, isNewFile: true)
+\u274C WRONG: feat(docs): add benchmarks documentation
+\u2705 CORRECT: docs(benchmarks): add benchmarks documentation
+Reason: ALL files are .md = docs type (even if IsNewFile: true)
+
+Example 7: Bug fix with error handling \u2192 fix, NOT refactor
+Files:
+  - src/api/auth.ts (modified, +15/-5, isNewFile: false)
+  Diff shows: Added try-catch, null check for token validation
+\u274C WRONG: refactor(api): update auth token validation
+\u2705 CORRECT: fix(api): handle null token in authentication
+Reason: Adds error handling to prevent crash = bug fix
+
+Example 8: Test files ONLY \u2192 test, NOT chore
+Files:
+  - tests/auth.test.ts (added, +200/-0, isNewFile: true)
+  - tests/fixtures/users.json (added, +50/-0, isNewFile: true)
+\u274C WRONG: chore(tests): add test files
+\u2705 CORRECT: test(auth): add authentication test suite
+Reason: Test files only = test type
+`;
+var SYSTEM_PROMPT_WITH_DIFF = `You are a git commit message generator. You now have the actual diff content for better context.
+
+CRITICAL OUTPUT FORMAT:
+- Return ONLY a valid JSON object
+- Do NOT wrap in markdown code blocks (no \`\`\`json, no \`\`\`)
+- Do NOT add any text before or after the JSON
+- Ensure all strings are properly escaped (use double quotes, escape backslashes and quotes)
+
+CRITICAL: USE IsNewFile METADATA TO DISTINGUISH NEW vs MODIFIED FILES:
+- Each file includes "IsNewFile: true" or "IsNewFile: false"
+- IsNewFile: false \u2192 File EXISTED BEFORE in git history \u2192 Use "refactor", "fix", or "chore"
+- IsNewFile: true \u2192 File is TRULY NEW (never existed) \u2192 Use "feat" for new functionality
+- NEVER use "feat: add initial" for files with "IsNewFile: false" - these are modifications!
+- For files marked "[EXISTING FILE - was modified]" in diff section \u2192 Use refactor/fix/chore, NOT feat
+
+CRITICAL GROUPING RULES:
+- Group files by LOGICAL CHANGE based on diff content
+- If files are changed for the same reason, they belong in ONE commit
+- IMPORTANT: Most files with status "modified" are REFACTORING, not new features
+- For refactoring: analyze the diff to understand what changed (renamed variables, restructured code, etc.)
+- Only use "add initial" or "setup" messages if you see truly NEW functionality being created from scratch
+- Target: 3-8 commits for <50 files, 5-12 commits for 50-150 files, 10-20 commits for 150+ files
+- Only separate genuinely DIFFERENT changes
+- CRITICAL: Each file must appear in EXACTLY ONE commit - no duplicates across commits!
+
+CRITICAL: FILE TYPE SHORTCUTS (check FIRST, before other rules):
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+\u{1F6AB} STOP! Check file extensions in DIFF BEFORE asking questions below:
+
+\u{1F4DD} ALL files in diff are *.md or *.mdx? \u2192 Type: docs (SKIP all questions below!)
+\u{1F9EA} ALL files in diff are test/, __tests__/, *.test.ts, *.spec.ts? \u2192 Type: test
+\u274C If ANY file has code (.ts, .js, .tsx, .jsx, .py, etc.) \u2192 Continue to questions below
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+CRITICAL COMMIT TYPE CLASSIFICATION (same as Phase 1):
+For EACH commit, answer these questions using the DIFF content:
+
+1. Does this change add NEW USER-VISIBLE BEHAVIOR?
+   - Look at the diff: is there a new API, feature, or capability?
+   - Check IsNewFile: false = likely refactor, true = might be feat
+   \u2192 YES = feat
+
+2. Does this change fix BROKEN functionality?
+   - Look for bug fixes, error handling corrections
+   \u2192 YES = fix
+
+3. Is this ONLY INTERNAL restructuring?
+   - Renaming, extracting functions, reorganizing code?
+   - IsNewFile: false with balanced +/- = refactor
+   \u2192 YES = refactor
+
+DEFAULT BIAS: When uncertain between feat and refactor, choose refactor!
+
+Rules:
+
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+!!! RULE 0 (HIGHEST PRIORITY - OVERRIDES ALL OTHER RULES):                    !!!
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+!!!
+!!! IF a file has "IsNewFile: false" in its metadata, IT IS A MODIFIED FILE.
+!!! Modified files CANNOT be feat UNLESS they add ENTIRELY NEW user-facing APIs.
+!!!
+!!! BEFORE classifying ANY commit as "feat", CHECK ALL files' IsNewFile flags:
+!!! - If ANY file has IsNewFile: false \u2192 START with refactor/fix/chore
+!!! - If ALL files have IsNewFile: true \u2192 MIGHT be feat (check diff content)
+!!!
+!!! EXAMPLES OF MODIFIED FILES (IsNewFile: false) \u2192 NOT FEAT:
+!!! \u274C WRONG: Modified file adds new function \u2192 feat
+!!! \u2705 RIGHT: Modified file adds new function \u2192 refactor
+!!!
+!!! \u274C WRONG: Modified file adds new class \u2192 feat
+!!! \u2705 RIGHT: Modified file adds new class \u2192 refactor
+!!!
+!!! \u274C WRONG: Modified file adds new CLI command \u2192 feat
+!!! \u2705 RIGHT: Modified file adds new CLI command \u2192 refactor
+!!!
+!!! ONLY USE FEAT for modified files if:
+!!! - Diff shows COMPLETELY NEW public API endpoint (e.g., POST /api/new-resource)
+!!! - Diff shows COMPLETELY NEW product feature visible to end users
+!!!
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+1. Use conventional commits: feat, fix, refactor, chore, docs, test, build, ci, perf
+2. Group related files - number of commits should scale with file count (see grouping rules above)
+3. Each commit MUST include "reasoning" field based on actual diff content
+4. Message should be lowercase, imperative mood, no period at end
+5. breaking: true only for breaking API changes
+6. Add "body" with bullet points explaining the actual changes you see in the diff
+7. Scope should reflect the affected area (e.g., "cli", "api"), not individual files
+8. CRITICAL: If ALL files in a commit are being DELETED (only deletions in diff), use type "chore" or "refactor", NOT "feat"
+9. CRITICAL: If a commit is mostly deletions (>80% of lines are deletions), use "refactor" or "chore", NOT "feat"
+
+10. CRITICAL: WRITE INFORMATIVE COMMIT MESSAGES (look at diff content):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+    \u274C BAD (too generic):
+    - "add feature"
+    - "update files"
+    - "refactor code"
+    - "fix bug"
+    - "improve implementation"
+
+    \u2705 GOOD (specific, based on diff):
+    - "add rate limiting middleware with Redis backend"
+    - "update API client to support pagination parameters"
+    - "refactor workflow executor to use async/await pattern"
+    - "fix memory leak in event listener cleanup"
+    - "improve error handling in authentication flow"
+
+    Guidelines:
+    - Read the DIFF to understand WHAT changed
+    - Include specific component/module names from diff
+    - Mention the technology/pattern if relevant (Redis, JWT, factory pattern)
+    - For body: describe concrete changes, not just "update X file"
+    - Use technical terms that developers will understand
+
+12. CRITICAL: SPECIFIC TYPE DETECTION (check diff content BEFORE defaulting to refactor):
+    \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+    \u{1F4DD} docs: Documentation ONLY (no code logic changes)
+    \u2705 ALL files in diff are markdown (*.md, *.mdx) \u2192 docs (even if IsNewFile: true)
+    \u2705 Diff shows ONLY markdown content changes
+    \u2705 README.md, ADR files, API docs, benchmarks docs
+    \u2705 Files in docs/ or doc/ directory with only markdown
+    \u274C NOT docs if diff includes ANY code logic changes
+
+    **IMPORTANT**: If ALL files end with .md or .mdx \u2192 ALWAYS use docs, NEVER feat!
+
+    \u{1F41B} fix: Corrects BROKEN functionality (look for bug-fix patterns in diff)
+    \u2705 Diff adds try-catch, null checks, validation
+    \u2705 Diff fixes incorrect calculations or logic errors
+    \u2705 Diff corrects typos in user-facing strings
+    \u2705 Commit message/body mentions "fix", "bug", "error", "crash"
+    \u274C NOT fix if adding new behavior
+
+    \u{1F9EA} test: Test files ONLY
+    \u2705 Diff shows files in test/, __tests__/, *.test.ts, *.spec.ts
+    \u2705 Adding test cases, updating test fixtures
+    \u274C NOT test if diff also changes source code
+
+13. IsNewFile flag (see RULE 0 above for detailed logic):
+    - IsNewFile: false \u2192 refactor/fix/chore/docs/test (NOT feat)
+    - IsNewFile: true \u2192 might be feat (check diff)
+
+EXACT JSON SCHEMA (copy this structure):
+{
+  "commits": [
+    {
+      "id": "c1",
+      "type": "refactor",
+      "scope": "workflow",
+      "message": "extract job executor to separate class with dependency injection",
+      "body": "- create JobExecutor class with injectable dependencies\\n- move execution logic from runtime to executor\\n- add unit tests for isolated executor behavior",
+      "files": ["src/runtime/workflow-runtime.ts", "src/executor/job-executor.ts", "tests/executor.test.ts"],
+      "releaseHint": "patch",
+      "breaking": false,
+      "reasoning": {
+        "newBehavior": false,
+        "fixesBug": false,
+        "internalOnly": true,
+        "explanation": "Diff shows extraction of JobExecutor class from runtime - improves testability through dependency injection pattern, no user-facing changes",
+        "confidence": 0.95
+      }
+    }
+  ]
+}
+
+VALID TYPE VALUES: feat, fix, refactor, chore, docs, test, build, ci, perf
+VALID RELEASEHINT VALUES: none, patch, minor, major
+
+EXAMPLE OUTPUT (based on actual diff content):
+{
+  "commits": [
+    {
+      "id": "c1",
+      "type": "refactor",
+      "scope": "cli",
+      "message": "migrate command routing to builder pattern with fluent API",
+      "body": "- replace imperative routing with CommandRouterBuilder\\n- add fluent API for route registration (addRoute, withMiddleware)\\n- extract plugin discovery to PluginDiscoveryService class\\n- update integration tests for new routing pattern",
+      "files": ["src/commands/routing.ts", "src/commands/router-builder.ts", "src/plugins/discovery-service.ts", "tests/integration/routing.test.ts"],
+      "releaseHint": "patch",
+      "breaking": false,
+      "reasoning": {
+        "newBehavior": false,
+        "fixesBug": false,
+        "internalOnly": true,
+        "explanation": "IsNewFile: false for routing.ts (modified). Diff shows refactoring to builder pattern - improves code organization and testability without changing CLI behavior",
+        "confidence": 0.95
+      }
+    }
+  ]
+}
+
+REAL-WORLD EXAMPLES WITH DIFF CONTEXT (learn from these):
+
+Example 1: Modified files - use diff to determine if feat or refactor
+Diff shows:
+  - Renamed variables (oldName \u2192 newName)
+  - Restructured functions (extract to separate modules)
+  - Updated imports and exports
+\u274C WRONG: feat(core): add new commit plan logic
+\u2705 CORRECT: refactor(core): restructure commit plan and prompt generation
+Reason: Diff shows reorganization, not new functionality
+
+Example 2: New package - check IsNewFile flags in diff
+All files show: IsNewFile: true, implements resource broker from scratch
+\u2705 CORRECT: feat(core-resource-broker): add resource broker for rate limiting
+Reason: Genuinely new package with new functionality
+
+Example 3: Moved files - IsNewFile: false despite status "added"
+Diff shows: [EXISTING FILE - was modified], same content as before
+\u2705 CORRECT: refactor(analytics): reorganize analytics package structure
+Reason: Files moved/reorganized, not newly created
+
+Example 4: Bug fix in existing files
+Diff shows: Fix null pointer exception, add validation check
+\u2705 CORRECT: fix(auth): handle null token in authentication middleware
+Reason: Fixing broken functionality = fix, not feat
+
+Example 5: Documentation ONLY \u2192 docs, NOT chore or feat
+Files:
+  - README.md (modified, +50/-20, IsNewFile: false)
+  - docs/API.md (modified, +30/-10, IsNewFile: false)
+Diff shows: Updated markdown content, improved examples, no code changes
+\u274C WRONG: chore(docs): update documentation
+\u274C WRONG: feat(docs): add documentation
+\u2705 CORRECT: docs: improve README and API documentation
+Reason: ALL files are markdown = docs (regardless of IsNewFile)
+
+Example 5b: NEW documentation files \u2192 docs, NOT feat
+Files:
+  - docs/benchmarks/README.md (added, +200/-0, IsNewFile: true)
+  - docs/benchmarks/RESULTS.md (added, +100/-0, IsNewFile: true)
+Diff shows: New markdown files with benchmarks documentation
+\u274C WRONG: feat(docs): add benchmarks documentation
+\u2705 CORRECT: docs(benchmarks): add benchmarks documentation
+Reason: ALL files are .md = docs type (even if IsNewFile: true)
+
+Example 6: Bug fix with error handling \u2192 fix, NOT refactor
+Files:
+  - src/api/auth.ts (modified, +15/-5, IsNewFile: false)
+Diff shows: Added try-catch around token validation, null check before access
+\u2705 CORRECT: fix(api): handle null token in authentication
+Reason: Adds error handling to prevent crash = bug fix
+
+Example 7: Test files ONLY \u2192 test, NOT chore
+Files:
+  - tests/auth.test.ts (added, +200/-0, IsNewFile: true)
+  - tests/helpers/mock-data.ts (added, +50/-0, IsNewFile: true)
+Diff shows: New test suites for authentication module
+\u2705 CORRECT: test(auth): add authentication test suite
+Reason: Test files only = test type
+`;
+function buildPrompt(summaries, recentCommits) {
+  const fileList = summaries.map((s) => {
+    const stats = s.binary ? "binary" : `+${s.additions}/-${s.deletions}`;
+    const isNew = s.isNewFile ? "IsNewFile: true" : "IsNewFile: false";
+    return `- ${s.path} (${s.status}, ${stats}, ${isNew})`;
+  }).join("\n");
+  const styleHint = recentCommits.length > 0 ? `
+Recent commit style:
+${recentCommits.slice(0, 5).map((c) => `- "${c}"`).join("\n")}` : "";
+  return `Files changed:
+${fileList}
+${styleHint}
+
+Generate commit plan as JSON. If you're unsure about commit type/message from paths alone, set needsMoreContext: true and list files in requestedFiles.`;
+}
+function buildEnhancedPrompt(summaries, patternAnalysis, recentCommits) {
+  const fileList = summaries.map((s) => {
+    const stats = s.binary ? "binary" : `+${s.additions}/-${s.deletions}`;
+    const isNew = s.isNewFile ? "IsNewFile: true" : "IsNewFile: false";
+    return `- ${s.path} (${s.status}, ${stats}, ${isNew})`;
+  }).join("\n");
+  const styleHint = recentCommits.length > 0 ? `
+Recent commit style:
+${recentCommits.slice(0, 5).map((c) => `- "${c}"`).join("\n")}` : "";
+  const patternHint = patternAnalysis.confidence > 0.7 ? `
+
+\u{1F3AF} PATTERN DETECTED (confidence: ${(patternAnalysis.confidence * 100).toFixed(0)}%):
+Pattern type: ${patternAnalysis.patternType}
+Suggested commit type: ${patternAnalysis.suggestedType || "unknown"}
+
+Hints:
+${patternAnalysis.hints.map((h) => `  \u2022 ${h}`).join("\n")}
+
+\u26A0\uFE0F IMPORTANT: Consider this pattern analysis when determining commit types!` : "";
+  return `Files changed:
+${fileList}
+${styleHint}
+${patternHint}
+
+Generate commit plan as JSON. If you're unsure about commit type/message from paths alone, set needsMoreContext: true and list files in requestedFiles.`;
+}
+function buildPromptWithDiff(summaries, diffs, recentCommits) {
+  const fileList = summaries.map((s) => {
+    const stats = s.binary ? "binary" : `+${s.additions}/-${s.deletions}`;
+    const isNew = s.isNewFile ? "IsNewFile: true" : "IsNewFile: false";
+    return `- ${s.path} (${s.status}, ${stats}, ${isNew})`;
+  }).join("\n");
+  const diffContent = Array.from(diffs.entries()).map(([path, diff]) => {
+    const summary = summaries.find((s) => s.path === path);
+    const isNewLabel = summary?.isNewFile ? " [NEW FILE - never existed before]" : " [EXISTING FILE - was modified]";
+    const truncatedDiff = diff.length > 2e3 ? diff.slice(0, 2e3) + "\n... (truncated)" : diff;
+    return `### ${path}${isNewLabel}
+\`\`\`diff
+${truncatedDiff}
+\`\`\``;
+  }).join("\n\n");
+  const styleHint = recentCommits.length > 0 ? `
+Recent commit style:
+${recentCommits.slice(0, 5).map((c) => `- "${c}"`).join("\n")}` : "";
+  return `Files changed:
+${fileList}
+${styleHint}
+
+Diff content for requested files:
+${diffContent}
+
+Now generate accurate commit plan based on the actual changes you see:`;
+}
+function cleanJsonResponse(rawResponse) {
+  let cleaned = rawResponse.trim();
+  cleaned = cleaned.replace(/^```(?:json)?\s*/i, "");
+  cleaned = cleaned.replace(/\s*```$/i, "");
+  cleaned = cleaned.trim();
+  const jsonStart = cleaned.indexOf("{");
+  const jsonEnd = cleaned.lastIndexOf("}");
+  if (jsonStart !== -1 && jsonEnd !== -1 && jsonStart < jsonEnd) {
+    cleaned = cleaned.substring(jsonStart, jsonEnd + 1);
+  }
+  cleaned = cleaned.replace(/,(\s*[}\]])/g, "$1");
+  return cleaned;
+}
+function parseResponse(response, summaries, patternAnalysis) {
+  const cleaned = cleanJsonResponse(response);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch (error) {
+    const preview = cleaned.substring(0, 300).replace(/\n/g, " ");
+    throw new Error(
+      `Failed to parse LLM response as JSON. Preview: "${preview}${cleaned.length > 300 ? "..." : ""}" Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed.commits || !Array.isArray(parsed.commits)) {
+    throw new Error(
+      `LLM response missing "commits" array. Got: ${JSON.stringify(parsed).substring(0, 200)}`
+    );
+  }
+  if (parsed.commits.length === 0) {
+    if (parsed.needsMoreContext) {
+      return {
+        needsMoreContext: true,
+        requestedFiles: Array.isArray(parsed.requestedFiles) ? parsed.requestedFiles : [],
+        commits: [],
+        averageConfidence: 0
+      };
+    }
+    throw new Error("LLM response has empty commits array and needsMoreContext is not set");
+  }
+  const commits = parsed.commits.map((commit, index) => {
+    if (!commit.type) {
+      throw new Error(`Commit ${index + 1} missing required field "type"`);
+    }
+    if (!commit.files || !Array.isArray(commit.files)) {
+      throw new Error(`Commit ${index + 1} missing required field "files" array`);
+    }
+    if (commit.files.length === 0) {
+      throw new Error(`Commit ${index + 1} has empty files array`);
+    }
+    if (!commit.message) {
+      throw new Error(`Commit ${index + 1} missing required field "message"`);
+    }
+    const type = normalizeType(commit.type);
+    const files = commit.files;
+    const reasoning = commit.reasoning;
+    let parsedReasoning;
+    let confidence = 0.5;
+    if (reasoning && typeof reasoning === "object") {
+      confidence = typeof reasoning.confidence === "number" ? reasoning.confidence : 0.5;
+      parsedReasoning = {
+        newBehavior: Boolean(reasoning.newBehavior),
+        fixesBug: Boolean(reasoning.fixesBug),
+        internalOnly: Boolean(reasoning.internalOnly),
+        explanation: typeof reasoning.explanation === "string" ? reasoning.explanation : "No explanation provided",
+        confidence
+      };
+    } else {
+      confidence = typeof commit.confidence === "number" ? commit.confidence : 0.5;
+    }
+    return {
+      id: commit.id || `c${index + 1}`,
+      type,
+      scope: typeof commit.scope === "string" ? commit.scope : void 0,
+      message: typeof commit.message === "string" ? commit.message : "update files",
+      body: typeof commit.body === "string" ? commit.body : void 0,
+      files,
+      releaseHint: normalizeReleaseHint(commit.releaseHint),
+      breaking: Boolean(commit.breaking),
+      reasoning: parsedReasoning,
+      confidence
+      // keep for internal use
+    };
+  });
+  const totalConfidence = commits.reduce((sum, c) => sum + (c.confidence ?? 0.5), 0);
+  const averageConfidence = commits.length > 0 ? totalConfidence / commits.length : 0;
+  const commitsWithFixedTypes = summaries ? commits.map((c) => fixCommitType(c, summaries, patternAnalysis)) : commits;
+  const commitsWithoutConfidence = commitsWithFixedTypes.map((c) => {
+    const { confidence: _, ...commit } = c;
+    return commit;
+  });
+  return {
+    needsMoreContext: Boolean(parsed.needsMoreContext),
+    requestedFiles: Array.isArray(parsed.requestedFiles) ? parsed.requestedFiles : [],
+    commits: commitsWithoutConfidence,
+    averageConfidence
+  };
+}
+function fixCommitType(commit, summaries, patternAnalysis) {
+  const commitFiles = commit.files;
+  const commitSummaries = summaries.filter((s) => commitFiles.includes(s.path));
+  if (commitSummaries.length === 0) {
+    return commit;
+  }
+  if (commit.type === "feat" && commit.confidence < 0.7 && commit.reasoning) {
+    const { newBehavior, internalOnly, fixesBug } = commit.reasoning;
+    if (internalOnly && !newBehavior) {
+      return {
+        ...commit,
+        type: "refactor",
+        reasoning: {
+          ...commit.reasoning,
+          explanation: `[Conservative bias] ${commit.reasoning.explanation}. Low confidence + internalOnly \u2192 refactor`
+        }
+      };
+    }
+    if (fixesBug && !newBehavior) {
+      return {
+        ...commit,
+        type: "fix",
+        reasoning: {
+          ...commit.reasoning,
+          explanation: `[Conservative bias] ${commit.reasoning.explanation}. Fixes bug \u2192 fix`
+        }
+      };
+    }
+    if (!newBehavior) {
+      return {
+        ...commit,
+        type: "refactor",
+        reasoning: {
+          ...commit.reasoning,
+          explanation: `[Conservative bias] ${commit.reasoning.explanation}. No new behavior \u2192 refactor`
+        }
+      };
+    }
+  }
+  const allDeleted = commitSummaries.every((s) => s.status === "deleted");
+  if (allDeleted && commit.type === "feat") {
+    return {
+      ...commit,
+      type: "chore",
+      message: commit.message.replace(/^add /i, "remove ").replace(/^added /i, "removed ")
+    };
+  }
+  const totalAdditions = commitSummaries.reduce((sum, s) => sum + s.additions, 0);
+  const totalDeletions = commitSummaries.reduce((sum, s) => sum + s.deletions, 0);
+  const totalChanges = totalAdditions + totalDeletions;
+  if (totalChanges > 0) {
+    const deletionRatio = totalDeletions / totalChanges;
+    if (deletionRatio > 0.8 && commit.type === "feat") {
+      return {
+        ...commit,
+        type: "refactor"
+      };
+    }
+  }
+  if (patternAnalysis && patternAnalysis.confidence > 0.8 && patternAnalysis.suggestedType) {
+    const llmType = commit.type;
+    const patternType = patternAnalysis.suggestedType;
+    if (llmType !== patternType) {
+      return {
+        ...commit,
+        type: patternType
+      };
+    }
+  }
+  const allModified = commitSummaries.every((s) => s.status === "modified");
+  if (allModified && totalChanges > 0 && commit.type === "feat") {
+    const additionRatio = totalAdditions / totalChanges;
+    if (additionRatio < 0.4) {
+      return {
+        ...commit,
+        type: "refactor"
+      };
+    }
+    if (additionRatio < 0.6) {
+      return {
+        ...commit,
+        type: "refactor"
+      };
+    }
+  }
+  const hasPackageJson = commitSummaries.some((s) => s.path.endsWith("package.json"));
+  if (hasPackageJson && commitSummaries.length >= 10) {
+    const allAdded = commitSummaries.every((s) => s.status === "added");
+    const allIsNewFile = commitSummaries.every((s) => s.isNewFile === true);
+    if (allAdded && allIsNewFile && commit.type === "chore") {
+      return {
+        ...commit,
+        type: "feat",
+        message: commit.message.replace(/^initialize /i, "add ").replace(/^setup /i, "add ")
+      };
+    }
+  }
+  return commit;
+}
+function normalizeType(type) {
+  const validTypes = [
+    "feat",
+    "fix",
+    "refactor",
+    "chore",
+    "docs",
+    "test",
+    "build",
+    "ci",
+    "perf"
+  ];
+  if (typeof type === "string") {
+    const normalized = type.toLowerCase();
+    if (validTypes.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return "chore";
+}
+function normalizeReleaseHint(hint) {
+  if (typeof hint === "string") {
+    const normalized = hint.toLowerCase();
+    if (["none", "patch", "minor", "major"].includes(normalized)) {
+      return normalized;
+    }
+  }
+  return "none";
+}
+function generateHeuristicPlan(summaries) {
+  if (summaries.length === 0) {
+    return [];
+  }
+  const commits = [];
+  let commitIndex = 1;
+  const { packageGroups, remainingFiles } = groupPackageJsonChanges(summaries);
+  for (const group of packageGroups) {
+    commits.push({
+      id: `c${commitIndex++}`,
+      type: "chore",
+      scope: inferPackageScope(group.map((f) => f.path)),
+      message: "update dependencies",
+      files: group.map((f) => f.path),
+      releaseHint: "none",
+      breaking: false
+    });
+  }
+  const { pairedGroups, unpairedFiles } = pairTestsWithImplementation(remainingFiles);
+  for (const group of pairedGroups) {
+    const implFile = group.find((f) => !isTestFile(f.path));
+    const type = inferTypeFromChanges(implFile);
+    commits.push({
+      id: `c${commitIndex++}`,
+      type,
+      scope: inferScope(group.map((f) => f.path)),
+      message: generateMessage(type, group),
+      files: group.map((f) => f.path),
+      releaseHint: inferReleaseHint(type),
+      breaking: false
+    });
+  }
+  const categoryGroups = groupByCategory(unpairedFiles);
+  for (const [category, files] of categoryGroups) {
+    const type = categoryToType(category);
+    const scope = inferScope(files.map((f) => f.path));
+    commits.push({
+      id: `c${commitIndex++}`,
+      type,
+      scope,
+      message: generateMessage(type, files),
+      files: files.map((f) => f.path),
+      releaseHint: inferReleaseHint(type),
+      breaking: false
+    });
+  }
+  return commits;
+}
+function groupPackageJsonChanges(summaries) {
+  const packageFiles = summaries.filter((f) => f.path.endsWith("package.json"));
+  const otherFiles = summaries.filter((f) => !f.path.endsWith("package.json"));
+  if (packageFiles.length === 0) {
+    return { packageGroups: [], remainingFiles: summaries };
+  }
+  const packageGroups = [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const pkgFile of packageFiles) {
+    const pkgDir = dirname(pkgFile.path);
+    const related = otherFiles.filter((f) => {
+      const fileDir = dirname(f.path);
+      return fileDir === pkgDir || fileDir.startsWith(pkgDir + "/");
+    });
+    const configRelated = related.filter((f) => {
+      const name = basename(f.path);
+      return name.includes("config") || name.includes("tsconfig") || name.endsWith(".json") || name.startsWith(".");
+    });
+    const group = [pkgFile, ...configRelated];
+    packageGroups.push(group);
+    claimed.add(pkgFile);
+    configRelated.forEach((f) => claimed.add(f));
+  }
+  const remainingFiles = summaries.filter((f) => !claimed.has(f));
+  return { packageGroups, remainingFiles };
+}
+function pairTestsWithImplementation(summaries) {
+  const testFiles = summaries.filter((f) => isTestFile(f.path));
+  const implFiles = summaries.filter((f) => !isTestFile(f.path));
+  const pairedGroups = [];
+  const pairedImpls = /* @__PURE__ */ new Set();
+  const pairedTests = /* @__PURE__ */ new Set();
+  for (const testFile of testFiles) {
+    const implPath = getImplementationPath(testFile.path);
+    const implFile = implFiles.find((f) => f.path === implPath);
+    if (implFile) {
+      pairedGroups.push([implFile, testFile]);
+      pairedImpls.add(implFile);
+      pairedTests.add(testFile);
+    }
+  }
+  const unpairedFiles = [
+    ...implFiles.filter((f) => !pairedImpls.has(f)),
+    ...testFiles.filter((f) => !pairedTests.has(f))
+  ];
+  return { pairedGroups, unpairedFiles };
+}
+function isTestFile(path) {
+  return path.includes(".test.") || path.includes(".spec.") || path.includes("/__tests__/");
+}
+function getImplementationPath(testPath) {
+  let implPath = testPath.replace(/\.test\.(ts|tsx|js|jsx)$/, ".$1").replace(/\.spec\.(ts|tsx|js|jsx)$/, ".$1");
+  implPath = implPath.replace("/__tests__/", "/");
+  return implPath;
+}
+function groupByCategory(summaries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const category = categorizeFile(summary.path);
+    const existing = groups.get(category) || [];
+    existing.push(summary);
+    groups.set(category, existing);
+  }
+  return groups;
+}
+function inferPackageScope(paths) {
+  const packagePath = paths.find((p) => p.endsWith("package.json"));
+  if (!packagePath) {
+    return void 0;
+  }
+  const parts = packagePath.split("/");
+  if (parts.length > 1) {
+    return parts[parts.length - 2];
+  }
+  return void 0;
+}
+function inferTypeFromChanges(file) {
+  if (!file) {
+    return "chore";
+  }
+  const { additions, deletions, status } = file;
+  if (status === "added" || additions > 0 && deletions === 0) {
+    return "feat";
+  }
+  if (status === "deleted" || deletions > 0 && additions === 0) {
+    return "chore";
+  }
+  if (additions > deletions * 2) {
+    return "feat";
+  }
+  if (deletions > additions * 2) {
+    return "refactor";
+  }
+  return "refactor";
+}
+function categorizeFile(path) {
+  const ext = extname(path);
+  const name = basename(path);
+  const dir = dirname(path);
+  if (path.includes(".test.") || path.includes(".spec.") || path.includes("__tests__") || dir.includes("/test/") || dir.includes("/tests/")) {
+    return "test";
+  }
+  if (ext === ".md" || dir.includes("/docs/") || name === "README.md") {
+    return "docs";
+  }
+  if (name.startsWith(".") || name.includes("config") || ["package.json", "tsconfig.json", "eslint.config.js"].includes(name)) {
+    return "config";
+  }
+  if (dir.includes(".github") || dir.includes(".gitlab") || name.includes("ci")) {
+    return "ci";
+  }
+  if (dir.includes("/build/") || dir.includes("/dist/") || name.includes("build")) {
+    return "build";
+  }
+  const topDir = dir.split("/")[0] || "root";
+  return `src:${topDir}`;
+}
+function categoryToType(category) {
+  if (category === "test") {
+    return "test";
+  }
+  if (category === "docs") {
+    return "docs";
+  }
+  if (category === "config") {
+    return "chore";
+  }
+  if (category === "ci") {
+    return "ci";
+  }
+  if (category === "build") {
+    return "build";
+  }
+  return "chore";
+}
+function inferScope(paths) {
+  if (paths.length === 0) {
+    return void 0;
+  }
+  const dirs = paths.map((p) => dirname(p).split("/"));
+  const firstDir = dirs[0];
+  if (!firstDir) {
+    return void 0;
+  }
+  if (dirs.length === 1) {
+    return firstDir.length > 1 ? firstDir[1] : firstDir[0];
+  }
+  const commonPrefix = [];
+  const minLength = Math.min(...dirs.map((d) => d.length));
+  for (let i = 0; i < minLength; i++) {
+    const segment = firstDir[i];
+    if (segment && dirs.every((d) => d[i] === segment)) {
+      commonPrefix.push(segment);
+    } else {
+      break;
+    }
+  }
+  if (commonPrefix.length > 0) {
+    const scope = commonPrefix[commonPrefix.length - 1];
+    if (scope && scope !== "." && scope !== "src") {
+      return scope;
+    }
+  }
+  return void 0;
+}
+function generateMessage(type, files) {
+  const count = files.length;
+  const allAdded = files.every((f) => f.status === "added");
+  const allDeleted = files.every((f) => f.status === "deleted");
+  if (type === "test") {
+    if (allAdded) {
+      return `add ${count} test file${count > 1 ? "s" : ""}`;
+    }
+    return `update ${count} test file${count > 1 ? "s" : ""}`;
+  }
+  if (type === "docs") {
+    if (allAdded) {
+      return `add documentation`;
+    }
+    return `update documentation`;
+  }
+  if (type === "ci") {
+    return `update ci configuration`;
+  }
+  if (type === "build") {
+    return `update build configuration`;
+  }
+  if (type === "chore") {
+    if (files.some((f) => f.path.includes("package.json"))) {
+      return `update dependencies`;
+    }
+    return `update configuration`;
+  }
+  if (allAdded) {
+    return `add ${count} file${count > 1 ? "s" : ""}`;
+  }
+  if (allDeleted) {
+    return `remove ${count} file${count > 1 ? "s" : ""}`;
+  }
+  return `update ${count} file${count > 1 ? "s" : ""}`;
+}
+function inferReleaseHint(type, _files) {
+  switch (type) {
+    case "feat":
+      return "minor";
+    case "fix":
+      return "patch";
+    case "perf":
+      return "patch";
+    case "refactor":
+      return "patch";
+    default:
+      return "none";
+  }
+}
+
+// src/generator/pattern-detector.ts
+function analyzePatterns(summaries) {
+  if (summaries.length === 0) {
+    return {
+      patternType: "mixed",
+      confidence: 0,
+      hints: [],
+      suggestedType: null
+    };
+  }
+  if (isNewPackagePattern(summaries)) {
+    const packagePath = summaries.find((s) => s.path.endsWith("package.json"))?.path;
+    const packageName = packagePath ? extractPackageName(packagePath) : "unknown";
+    return {
+      patternType: "new-package",
+      confidence: 0.95,
+      hints: [
+        `New package detected: ${packageName}`,
+        `${summaries.length} new files including package.json`,
+        "All files are truly new (isNewFile: true)",
+        "This is a new feature (feat), not chore"
+      ],
+      suggestedType: "feat"
+    };
+  }
+  if (isBulkMovePattern(summaries)) {
+    const dirs = countUniqueDirs(summaries, 3);
+    return {
+      patternType: "refactor-move",
+      confidence: 0.9,
+      hints: [
+        `Bulk move pattern: ${summaries.length} files added`,
+        `Files existed before (isNewFile: false)`,
+        `Organized into ${dirs} director${dirs === 1 ? "y" : "ies"}`,
+        "This is refactoring (reorganization), not new feature"
+      ],
+      suggestedType: "refactor"
+    };
+  }
+  if (isRefactorModificationPattern(summaries)) {
+    const ratio = calculateAdditionRatio(summaries);
+    return {
+      patternType: "refactor-modify",
+      confidence: 0.85,
+      hints: [
+        "All files are modified (not new)",
+        `Low addition ratio: ${(ratio * 100).toFixed(0)}%`,
+        "Mostly structural changes or deletions",
+        "This is refactoring, not new feature"
+      ],
+      suggestedType: "refactor"
+    };
+  }
+  const allDeleted = summaries.every((s) => s.status === "deleted");
+  if (allDeleted) {
+    return {
+      patternType: "deletions",
+      confidence: 0.98,
+      hints: [
+        "All files are deleted",
+        "This is cleanup (chore), not feature"
+      ],
+      suggestedType: "chore"
+    };
+  }
+  const totalAdd = summaries.reduce((sum, s) => sum + s.additions, 0);
+  const totalDel = summaries.reduce((sum, s) => sum + s.deletions, 0);
+  const deletionRatio = totalDel / (totalAdd + totalDel);
+  if (deletionRatio > 0.8) {
+    return {
+      patternType: "deletions",
+      confidence: 0.95,
+      hints: [
+        `Mostly deletions: ${(deletionRatio * 100).toFixed(0)}%`,
+        "This is refactoring or cleanup, not feature"
+      ],
+      suggestedType: "refactor"
+    };
+  }
+  return {
+    patternType: "mixed",
+    confidence: 0,
+    hints: [],
+    suggestedType: null
+  };
+}
+function isNewPackagePattern(summaries) {
+  const hasPackageJson = summaries.some((s) => s.path.endsWith("package.json"));
+  if (!hasPackageJson) {
+    return false;
+  }
+  if (summaries.length < 10) {
+    return false;
+  }
+  const allAdded = summaries.every((s) => s.status === "added");
+  if (!allAdded) {
+    return false;
+  }
+  const allIsNewFile = summaries.every((s) => s.isNewFile === true);
+  if (!allIsNewFile) {
+    return false;
+  }
+  const packageJsonPath = summaries.find((s) => s.path.endsWith("package.json")).path;
+  const packageDir = packageJsonPath.split("/").slice(0, -1).join("/");
+  const filesInPackage = summaries.filter((s) => s.path.startsWith(packageDir + "/"));
+  const inPackageRatio = filesInPackage.length / summaries.length;
+  return inPackageRatio > 0.8;
+}
+function isBulkMovePattern(summaries) {
+  if (summaries.length < 20) {
+    return false;
+  }
+  const allAdded = summaries.every((s) => s.status === "added");
+  if (!allAdded) {
+    return false;
+  }
+  const notNewCount = summaries.filter((s) => s.isNewFile === false).length;
+  const notNewRatio = notNewCount / summaries.length;
+  if (notNewRatio <= 0.5) {
+    return false;
+  }
+  const uniqueDirs = countUniqueDirs(summaries, 3);
+  return uniqueDirs < 5;
+}
+function isRefactorModificationPattern(summaries) {
+  const allModified = summaries.every((s) => s.status === "modified");
+  if (!allModified) {
+    return false;
+  }
+  const additionRatio = calculateAdditionRatio(summaries);
+  return additionRatio < 0.4;
+}
+function countUniqueDirs(summaries, depth) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const summary of summaries) {
+    const parts = summary.path.split("/");
+    if (parts.length >= depth) {
+      const dirPath = parts.slice(0, depth).join("/");
+      dirs.add(dirPath);
+    }
+  }
+  return dirs.size;
+}
+function calculateAdditionRatio(summaries) {
+  const totalAdditions = summaries.reduce((sum, s) => sum + s.additions, 0);
+  const totalDeletions = summaries.reduce((sum, s) => sum + s.deletions, 0);
+  const totalChanges = totalAdditions + totalDeletions;
+  if (totalChanges === 0) {
+    return 0;
+  }
+  return totalAdditions / totalChanges;
+}
+function extractPackageName(path) {
+  const parts = path.split("/");
+  const packageJsonIndex = parts.indexOf("package.json");
+  if (packageJsonIndex > 0) {
+    const packageName = parts[packageJsonIndex - 1];
+    return packageName ?? "unknown";
+  }
+  return "unknown";
+}
+var SecretsDetectedError = class _SecretsDetectedError extends Error {
+  secretMatches;
+  constructor(matches, message) {
+    super(message);
+    this.name = "SecretsDetectedError";
+    this.secretMatches = matches;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SecretsDetectedError);
+    }
+  }
+};
+var SECRET_FILE_PATTERNS = [
+  // Environment files
+  ".env",
+  ".env.*",
+  "*.env",
+  ".envrc",
+  // NPM/Node
+  ".npmrc",
+  ".yarnrc",
+  ".yarnrc.yml",
+  // SSH/GPG keys
+  "*.key",
+  "*.pem",
+  "*.p12",
+  "*.pfx",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  "*.pub",
+  // AWS
+  ".aws/**",
+  "credentials",
+  // Docker
+  ".docker/config.json",
+  // Git credentials
+  ".git-credentials",
+  ".netrc",
+  // Service account files
+  "*-service-account.json",
+  "*-serviceaccount.json",
+  "service-account*.json",
+  "serviceaccount*.json",
+  // Kubernetes
+  "kubeconfig",
+  "*.kubeconfig",
+  // Terraform
+  "*.tfvars",
+  "terraform.tfstate",
+  "terraform.tfstate.backup",
+  // Other common secrets
+  "secrets.yml",
+  "secrets.yaml",
+  "secret.yml",
+  "secret.yaml",
+  "passwords.txt",
+  "password.txt"
+];
+var SECRET_CONTENT_PATTERNS = [
+  // API keys/tokens
+  { pattern: /api[_-]?key[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "API Key" },
+  { pattern: /auth[_-]?token[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "Auth Token" },
+  { pattern: /access[_-]?token[s]?['":\s]*[a-zA-Z0-9_-]{20,}/i, name: "Access Token" },
+  // AWS
+  { pattern: /AKIA[0-9A-Z]{16}/, name: "AWS Access Key ID" },
+  { pattern: /aws[_-]?secret[_-]?access[_-]?key/i, name: "AWS Secret Access Key" },
+  // NPM
+  { pattern: /\/\/registry\.npmjs\.org\/:_authToken=/, name: "NPM Auth Token" },
+  { pattern: /npm_[A-Za-z0-9]{30,}/, name: "NPM Token" },
+  // GitHub
+  { pattern: /gh[pousr]_[A-Za-z0-9_]{36,}/, name: "GitHub Token" },
+  // Slack
+  { pattern: /xox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[A-Za-z0-9]{24,}/, name: "Slack Token" },
+  // Private keys
+  { pattern: /-----BEGIN (RSA|DSA|EC|OPENSSH|PGP) PRIVATE KEY-----/, name: "Private Key" },
+  // Passwords
+  { pattern: /password['":\s]*['"]/i, name: "Password" },
+  // Generic patterns
+  { pattern: /secret['":\s]*['"]/i, name: "Secret" }
+];
+function isSecretFile(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return SECRET_FILE_PATTERNS.some(
+    (pattern) => minimatch(normalizedPath, pattern, { matchBase: true })
+  );
+}
+function detectSecretFiles(files) {
+  return files.filter(isSecretFile);
+}
+function formatSecretsWarning(secretFiles) {
+  const count = secretFiles.length;
+  const filesList = secretFiles.map((f) => `  - ${f}`).join("\n");
+  return [
+    `\u{1F6A8} CRITICAL SECURITY ERROR: Detected ${count} file(s) with potential secrets:`,
+    filesList,
+    "",
+    "\u26D4\uFE0F COMMIT GENERATION ABORTED",
+    "",
+    "These files contain sensitive data (API keys, tokens, credentials)",
+    "that MUST NOT be committed to git or sent to LLM.",
+    "",
+    "\u2705 Actions to fix:",
+    "  1. Add these files to .gitignore",
+    "  2. Remove secrets from the files (use environment variables instead)",
+    "  3. If already committed, use git filter-branch or BFG to remove from history",
+    "",
+    "\u26A0\uFE0F  If you already ran commit:generate before, the secrets may have been",
+    "sent to OpenAI. Rotate your credentials immediately."
+  ].join("\n");
+}
+function detectSecretsWithLocation(diffs) {
+  const matches = [];
+  for (const [file, diff] of diffs.entries()) {
+    const lines = diff.split("\n");
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex] ?? "";
+      for (const { pattern, name } of SECRET_CONTENT_PATTERNS) {
+        pattern.lastIndex = 0;
+        const match = pattern.exec(line);
+        if (match) {
+          const matchedText = match[0];
+          const column = match.index;
+          const snippetStart = Math.max(0, column - 20);
+          const snippetEnd = Math.min(line.length, column + matchedText.length + 20);
+          const snippet = line.substring(snippetStart, snippetEnd);
+          const displayText = matchedText.length > 50 ? matchedText.substring(0, 50) + "..." : matchedText;
+          matches.push({
+            file,
+            line: lineIndex + 1,
+            // 1-based line numbers
+            column: column + 1,
+            // 1-based column numbers
+            pattern: pattern.source,
+            patternName: name,
+            snippet: snippet.trim(),
+            matchedText: displayText
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
+function formatSecretsReport(matches) {
+  const count = matches.length;
+  const fileCount = new Set(matches.map((m) => m.file)).size;
+  const lines = [
+    `\u{1F6A8} CRITICAL SECURITY ERROR: Detected ${count} potential secret(s) in ${fileCount} file(s)`,
+    "",
+    "\u26D4\uFE0F COMMIT GENERATION BLOCKED",
+    ""
+  ];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const existing = byFile.get(match.file) ?? [];
+    existing.push(match);
+    byFile.set(match.file, existing);
+  }
+  for (const [file, fileMatches] of byFile.entries()) {
+    lines.push(`\u{1F4C4} ${file}:`);
+    for (const match of fileMatches) {
+      lines.push(`  Line ${match.line}:${match.column} - ${match.patternName}`);
+      lines.push(`    Pattern: ${match.pattern.substring(0, 60)}${match.pattern.length > 60 ? "..." : ""}`);
+      lines.push(`    Matched: ${match.matchedText}`);
+      lines.push(`    Context: ...${match.snippet}...`);
+      lines.push("");
+    }
+  }
+  lines.push(
+    "\u{1F512} These files contain sensitive data (API keys, tokens, credentials)",
+    "that MUST NOT be committed to git or sent to LLM.",
+    "",
+    "\u2705 Actions to fix:",
+    "  1. Review each match above - some may be false positives (e.g., examples in comments)",
+    "  2. If real secrets: Add files to .gitignore and remove secrets (use env vars)",
+    "  3. If false positives: Use --allow-secrets flag to proceed with confirmation",
+    "",
+    "\u26A0\uFE0F  If secrets were already sent to LLM in previous runs, rotate credentials immediately!"
+  );
+  return lines.join("\n");
+}
+async function promptUserConfirmation(question, defaultValue = false, autoConfirm = false) {
+  if (autoConfirm) {
+    console.log(`${question} [auto-confirmed with --yes]`);
+    return true;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const defaultHint = defaultValue ? "[Y/n]" : "[y/N]";
+  const fullQuestion = `${question} ${defaultHint}: `;
+  return new Promise((resolve) => {
+    rl.question(fullQuestion, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve(defaultValue);
+        return;
+      }
+      if (normalized === "y" || normalized === "yes") {
+        resolve(true);
+        return;
+      }
+      if (normalized === "n" || normalized === "no") {
+        resolve(false);
+        return;
+      }
+      resolve(defaultValue);
+    });
+  });
+}
+
+// src/generator/commit-plan.ts
+var CONFIDENCE_THRESHOLD = 0.7;
+var MAX_LLM_RETRIES = 2;
+var VALID_COMMIT_TYPES = /* @__PURE__ */ new Set(["feat", "fix", "refactor", "chore", "docs", "test", "build", "ci", "perf"]);
+function normalizeCommitId(id) {
+  if (!id) {
+    return void 0;
+  }
+  const trimmed = id.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (/^c\d+$/i.test(trimmed)) {
+    return `c${trimmed.replace(/^c/i, "")}`;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    return `c${trimmed}`;
+  }
+  return trimmed;
+}
+function buildFallbackMessage(files) {
+  const firstFile = files[0];
+  const fileName = firstFile ? firstFile.split("/").pop() ?? firstFile : "files";
+  return files.length === 1 ? `update ${fileName}` : `update ${files.length} files`;
+}
+function toSafeCommitGroup(commit, id) {
+  const files = Array.isArray(commit.files) ? commit.files.filter((file) => typeof file === "string" && file.length > 0) : [];
+  if (files.length === 0) {
+    return null;
+  }
+  const uniqueFiles = [...new Set(files)];
+  const type = typeof commit.type === "string" && VALID_COMMIT_TYPES.has(commit.type) ? commit.type : "chore";
+  const message = typeof commit.message === "string" && commit.message.trim().length > 0 ? commit.message.trim() : buildFallbackMessage(uniqueFiles);
+  const releaseHint = commit.releaseHint ?? (type === "feat" ? "minor" : type === "fix" || type === "refactor" ? "patch" : "none");
+  return {
+    id,
+    type,
+    scope: commit.scope,
+    message,
+    body: commit.body,
+    files: uniqueFiles,
+    releaseHint,
+    breaking: Boolean(commit.breaking),
+    reasoning: commit.reasoning ?? {
+      newBehavior: false,
+      fixesBug: false,
+      internalOnly: true,
+      explanation: "Generated from Phase 3 fallback due invalid or incomplete LLM commit action.",
+      confidence: 0.3
+    }
+  };
+}
+async function generateCommitPlan(options) {
+  const { cwd, onProgress } = options;
+  const logger = useLogger();
+  const analytics = useAnalytics();
+  const llm = useLLM();
+  const startTime = Date.now();
+  const gitStatus = await getGitStatus(cwd);
+  const allFiles = getAllChangedFiles(gitStatus);
+  if (allFiles.length === 0) {
+    return createEmptyPlan(cwd, gitStatus);
+  }
+  const secretFiles = detectSecretFiles(allFiles);
+  if (secretFiles.length > 0) {
+    const basicMatches = secretFiles.map((file) => ({
+      file,
+      line: 0,
+      column: 0,
+      pattern: "SECRET_FILE_PATTERN",
+      patternName: "Secret File Pattern",
+      snippet: "",
+      matchedText: file
+    }));
+    const warning = formatSecretsWarning(secretFiles);
+    await logger.error("\u{1F6A8} SECRETS DETECTED", new Error("Secrets detected"), {
+      secretFiles
+    });
+    console.error("\n" + warning + "\n");
+    if (!options.allowSecrets) {
+      throw new SecretsDetectedError(
+        basicMatches,
+        `Secrets detected in ${secretFiles.length} file(s). Use --allow-secrets to bypass after review, or add files to .gitignore.`
+      );
+    }
+    console.log("\n\u26A0\uFE0F  WARNING: --allow-secrets flag detected\n");
+    const confirmed = await promptUserConfirmation(
+      `\u26A0\uFE0F  Proceed with committing ${secretFiles.length} file(s) that may contain secrets?`,
+      false
+      // default: NO
+    );
+    if (!confirmed) {
+      throw new SecretsDetectedError(
+        basicMatches,
+        "User declined to commit files with potential secrets."
+      );
+    }
+    await logger.warn("User confirmed to proceed with files containing potential secrets", {
+      secretFiles,
+      confirmedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log("\u2705 User confirmed - continuing with commit generation...\n");
+  }
+  const summaries = await getFileSummaries(cwd, allFiles);
+  const patternAnalysis = analyzePatterns(summaries);
+  if (patternAnalysis.confidence > 0.7) {
+    await analytics?.track("commit.pattern-detected", {
+      patternType: patternAnalysis.patternType,
+      confidence: patternAnalysis.confidence,
+      suggestedType: patternAnalysis.suggestedType,
+      fileCount: summaries.length,
+      hints: patternAnalysis.hints
+    });
+    await logger.debug(`Pattern detected: ${patternAnalysis.patternType} (confidence: ${patternAnalysis.confidence.toFixed(2)})`, {
+      suggestedType: patternAnalysis.suggestedType,
+      hints: patternAnalysis.hints
+    });
+  }
+  const recentCommits = options.recentCommits ?? await getRecentCommits(cwd, 10);
+  let commits;
+  let llmUsed = false;
+  let tokensUsed;
+  let escalated = false;
+  if (llm) {
+    try {
+      const supportsNativeTools = typeof llm.chatWithTools === "function";
+      let parsed;
+      if (supportsNativeTools) {
+        await logger.debug("Using native tools approach (chatWithTools)");
+        onProgress?.("Analyzing with native tools...");
+        const result = await generateWithNativeTools(
+          llm,
+          summaries,
+          patternAnalysis,
+          recentCommits,
+          logger,
+          onProgress
+        );
+        parsed = result.parsed;
+        tokensUsed = result.tokensUsed;
+        llmUsed = true;
+      } else {
+        await logger.debug("Using text-based parsing (fallback)");
+        onProgress?.("Analyzing with text-based LLM...");
+        const prompt = buildEnhancedPrompt(summaries, patternAnalysis, recentCommits);
+        const result = await retryLLMCall(
+          () => llm.complete(prompt, {
+            systemPrompt: SYSTEM_PROMPT,
+            temperature: 0.3,
+            maxTokens: 2e3
+          }),
+          "Phase 1",
+          logger,
+          onProgress
+        );
+        parsed = parseResponse(result.content, summaries, patternAnalysis);
+        llmUsed = true;
+        tokensUsed = result.tokensUsed;
+      }
+      const shouldEscalate = parsed.needsMoreContext || parsed.averageConfidence < CONFIDENCE_THRESHOLD || summaries.length >= 10;
+      if (shouldEscalate) {
+        const reason = summaries.length >= 10 ? `${summaries.length} files (\u226510)` : `confidence ${(parsed.averageConfidence * 100).toFixed(0)}%`;
+        await logger.debug(`Escalating to Phase 2: ${reason}`, {
+          fileCount: summaries.length,
+          confidence: parsed.averageConfidence,
+          needsMoreContext: parsed.needsMoreContext,
+          requestedFiles: parsed.requestedFiles
+        });
+        onProgress?.(`${reason} - fetching diff...`);
+        let filesToDiff;
+        if (parsed.requestedFiles.length > 0) {
+          const validFiles = parsed.requestedFiles.filter((f) => summaries.some((s) => s.path === f));
+          filesToDiff = validFiles.slice(0, 15);
+          if (validFiles.length > 15) {
+            await logger.warn(`LLM requested ${validFiles.length} files, truncated to 15 most critical`, {
+              requestedCount: validFiles.length,
+              truncatedCount: 15
+            });
+          }
+        } else {
+          const sortedByChanges = [...summaries].sort((a, b) => {
+            const aChanges = (a.additions ?? 0) + (a.deletions ?? 0);
+            const bChanges = (b.additions ?? 0) + (b.deletions ?? 0);
+            return bChanges - aChanges;
+          });
+          filesToDiff = sortedByChanges.slice(0, 15).map((s) => s.path);
+          await logger.debug("Auto-selected top 15 most changed files for Phase 2", {
+            totalFiles: summaries.length,
+            selectedCount: filesToDiff.length
+          });
+        }
+        const diffs = await getFileDiffs(cwd, filesToDiff);
+        const secretMatches = detectSecretsWithLocation(diffs);
+        if (secretMatches.length > 0) {
+          const report = formatSecretsReport(secretMatches);
+          await logger.error("\u{1F6A8} SECRETS DETECTED IN DIFF CONTENT", new Error("Secrets in diff"), {
+            secretMatches
+          });
+          onProgress?.("\u{1F6A8} Secrets detected in diff");
+          console.error("\n" + report + "\n");
+          if (!options.allowSecrets) {
+            throw new SecretsDetectedError(
+              secretMatches,
+              `Secrets detected in ${secretMatches.length} location(s). Use --allow-secrets to bypass after review, or remove secrets before committing.`
+            );
+          }
+          console.log("\n\u26A0\uFE0F  WARNING: --allow-secrets flag detected\n");
+          const confirmed = await promptUserConfirmation(
+            `\u26A0\uFE0F  Proceed with committing changes that contain ${secretMatches.length} potential secret(s)?`,
+            false,
+            // default: NO
+            options.autoConfirm
+            // auto-confirm if --yes flag
+          );
+          if (!confirmed) {
+            throw new SecretsDetectedError(
+              secretMatches,
+              "User declined to commit changes with potential secrets."
+            );
+          }
+          await logger.warn("User confirmed to proceed with diff containing potential secrets", {
+            secretMatches: secretMatches.map((m) => ({ file: m.file, line: m.line, pattern: m.patternName })),
+            confirmedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          console.log("\u2705 User confirmed - continuing with Phase 2 analysis...\n");
+          onProgress?.("Re-analyzing with diff context (Phase 2)...");
+        }
+        if (diffs.size > 0) {
+          const maxTokensPhase2 = Math.min(6e3, 3e3 + Math.floor(summaries.length / 20) * 500);
+          await logger.debug("Re-analyzing with diff context (Phase 2)", {
+            filesWithDiff: filesToDiff.length,
+            supportsNativeTools
+          });
+          onProgress?.("Re-analyzing with diff context (Phase 2)...");
+          if (supportsNativeTools) {
+            const resultWithDiff = await generateWithNativeToolsPhase2(
+              llm,
+              summaries,
+              diffs,
+              recentCommits,
+              logger,
+              onProgress
+            );
+            parsed = resultWithDiff.parsed;
+            tokensUsed = (tokensUsed ?? 0) + (resultWithDiff.tokensUsed ?? 0);
+            escalated = true;
+          } else {
+            const promptWithDiff = buildPromptWithDiff(summaries, diffs, recentCommits);
+            const resultWithDiff = await retryLLMCall(
+              () => llm.complete(promptWithDiff, {
+                systemPrompt: SYSTEM_PROMPT_WITH_DIFF,
+                temperature: 0.3,
+                maxTokens: maxTokensPhase2
+              }),
+              "Phase 2",
+              logger,
+              onProgress
+            );
+            parsed = parseResponse(resultWithDiff.content, summaries, patternAnalysis);
+            tokensUsed = (tokensUsed ?? 0) + (resultWithDiff.tokensUsed ?? 0);
+            escalated = true;
+          }
+        }
+      }
+      commits = parsed.commits;
+      commits = await validateAndFixCommits(commits, summaries, llm, llmUsed, logger, onProgress);
+    } catch (error) {
+      if (error instanceof SecretsDetectedError) {
+        throw error;
+      }
+      await logger.warn("LLM generation failed after retries, falling back to heuristics", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      onProgress?.("LLM failed, using heuristics...");
+      commits = generateHeuristicPlan(summaries);
+    }
+  } else {
+    commits = generateHeuristicPlan(summaries);
+  }
+  const typeDistribution = commits.reduce((acc, commit) => {
+    acc[commit.type] = (acc[commit.type] || 0) + 1;
+    return acc;
+  }, {});
+  await analytics?.track("commit.generation-complete", {
+    totalFiles: summaries.length,
+    totalCommits: commits.length,
+    llmUsed,
+    escalated,
+    tokensUsed,
+    durationMs: Date.now() - startTime,
+    typeDistribution,
+    cwd
+  });
+  return {
+    schemaVersion: "1.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoRoot: cwd,
+    gitStatus,
+    commits,
+    metadata: {
+      totalFiles: summaries.length,
+      totalCommits: commits.length,
+      llmUsed,
+      tokensUsed,
+      escalated
+    }
+  };
+}
+function createEmptyPlan(cwd, gitStatus) {
+  return {
+    schemaVersion: "1.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repoRoot: cwd,
+    gitStatus,
+    commits: [],
+    metadata: {
+      totalFiles: 0,
+      totalCommits: 0,
+      llmUsed: false
+    }
+  };
+}
+async function generateWithNativeTools(llm, summaries, patternAnalysis, recentCommits, logger, _onProgress) {
+  if (!llm || !llm.chatWithTools) {
+    throw new Error("LLM does not support native tools (chatWithTools)");
+  }
+  const userPrompt = buildEnhancedPrompt(summaries, patternAnalysis, recentCommits);
+  const messages = [
+    {
+      role: "system",
+      content: SYSTEM_PROMPT
+    },
+    {
+      role: "user",
+      content: userPrompt
+    }
+  ];
+  const response = await llm.chatWithTools(messages, {
+    tools: [COMMIT_PLAN_TOOL],
+    toolChoice: {
+      type: "function",
+      function: { name: "generate_commit_plan" }
+    },
+    temperature: 0.3
+  });
+  const toolCall = response.toolCalls?.[0];
+  if (!toolCall || toolCall.name !== "generate_commit_plan") {
+    throw new Error("LLM did not call generate_commit_plan tool");
+  }
+  const toolArgs = toolCall.input;
+  const totalConfidence = toolArgs.commits.reduce((sum, c) => {
+    const confidence = c.reasoning?.confidence ?? 0.5;
+    return sum + confidence;
+  }, 0);
+  const averageConfidence = toolArgs.commits.length > 0 ? totalConfidence / toolArgs.commits.length : 0;
+  await logger.debug("Native tools Phase 1 result", {
+    needsMoreContext: toolArgs.needsMoreContext,
+    requestedFiles: toolArgs.requestedFiles?.length ?? 0,
+    commitsCount: toolArgs.commits.length,
+    averageConfidence
+  });
+  return {
+    parsed: {
+      needsMoreContext: Boolean(toolArgs.needsMoreContext),
+      requestedFiles: toolArgs.requestedFiles ?? [],
+      commits: toolArgs.commits,
+      averageConfidence
+    },
+    tokensUsed: response.usage ? response.usage.promptTokens + response.usage.completionTokens : void 0
+  };
+}
+async function generateMissingFilesCommit(llm, missingSummaries, existingCommits, logger, onProgress) {
+  if (!llm || !llm.chatWithTools) {
+    return null;
+  }
+  const existingCommitsContext = existingCommits.map((c) => {
+    const filesPreview = c.files.length <= 3 ? c.files.join(", ") : `${c.files.slice(0, 3).join(", ")} and ${c.files.length - 3} more`;
+    return `[${c.id}] ${c.type}${c.scope ? `(${c.scope})` : ""}: ${c.message}
+   Files: ${filesPreview}`;
+  }).join("\n\n");
+  const missingFilesList = missingSummaries.map((s) => {
+    const stats = s.binary ? "binary" : `+${s.additions}/-${s.deletions}`;
+    const isNew = s.isNewFile ? "IsNewFile: true" : "IsNewFile: false";
+    return `- ${s.path} (${s.status}, ${stats}, ${isNew})`;
+  }).join("\n");
+  const systemPrompt = `You are analyzing files that were not included in the initial commit plan.
+
+CONTEXT: These files were not classified by the LLM in previous phases. Your task is to determine:
+1. Why they were missed (config files, minor changes, unrelated changes, etc.)
+2. Whether they belong to an EXISTING commit or need a NEW commit
+3. What type of commit they should be (chore, refactor, fix, feat, docs, test, etc.)
+
+CRITICAL: You have TWO actions available:
+
+ACTION 1: extend_existing (PREFER THIS if file is related to existing commit)
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+Use when a file logically belongs to an already created commit.
+
+Example: If existing commit is "feat(fs): add fs adapter" and you see:
+- packages/adapters-fs/src/secure-storage.test.ts (test for fs adapter)
+
+Then use:
+{
+  "action": "extend_existing",
+  "existingCommitId": "c1",
+  "files": ["packages/adapters-fs/src/secure-storage.test.ts"]
+}
+
+The file will be added to commit c1 instead of creating a new commit.
+
+ACTION 2: create_new (use when file is unrelated to existing commits)
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+Use when files don't fit into any existing commit.
+
+DEFAULT to "chore" unless you see clear evidence of feat/fix/refactor.
+
+IMPORTANT: These are leftover files - they are usually:
+- Configuration files (package.json, tsconfig.json, etc.)
+- Minor updates to existing files
+- Test files or documentation
+- Build/tooling changes
+
+CRITICAL: WRITE INFORMATIVE COMMIT MESSAGES (not generic):
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u274C BAD (too generic):
+- "update files"
+- "update configuration"
+- "update additional files"
+- "update 30 files"
+
+\u2705 GOOD (specific and descriptive):
+- "update TypeScript and ESLint configuration for strict mode"
+- "update package dependencies for security patches"
+- "update build configuration to support ESM modules"
+
+Guidelines:
+- Include WHAT was changed (specific files/components)
+- Include WHY if relevant (context about the change)
+- Use concrete nouns (not "files", "additional files")
+- Add context that helps reviewers understand the change`;
+  const userPrompt = `Existing commits (you can add files to these using extend_existing action):
+${existingCommitsContext}
+
+Files that need classification (${missingSummaries.length} remaining):
+${missingFilesList}
+
+IMPORTANT: You don't need to classify ALL files in one response if there are too many.
+- If you can confidently classify some files \u2192 do it
+- If you're unsure about some files \u2192 skip them (they'll be processed in next iteration)
+- Focus on files you can group logically
+
+For each file, choose the appropriate action:
+1. extend_existing - if file belongs to an existing commit (e.g., test file for fs adapter \u2192 add to "feat(fs): add fs adapter")
+2. create_new - if file doesn't fit into any existing commit
+
+You may create:
+- ONE new commit if all remaining files are related (same purpose, same change type)
+- MULTIPLE new commits if files have different purposes (e.g., separate config changes from test updates)
+- MIX of extend_existing and create_new actions (recommended!)
+
+CRITICAL: Be specific in each commit message - describe WHAT is being changed, not just "update files".
+PREFER extend_existing when possible to avoid creating unnecessary commits.`;
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+  try {
+    onProgress?.("Classifying remaining files (Phase 3)...");
+    const response = await llm.chatWithTools(messages, {
+      tools: [COMMIT_PLAN_TOOL_PHASE3],
+      toolChoice: {
+        type: "function",
+        function: { name: "generate_commit_plan" }
+      },
+      temperature: 0.3
+    });
+    const toolCall = response.toolCalls?.[0];
+    if (!toolCall || toolCall.name !== "generate_commit_plan") {
+      await logger.warn("Phase 3: LLM did not call tool, using fallback");
+      return null;
+    }
+    const toolArgs = toolCall.input;
+    if (!toolArgs.commits || toolArgs.commits.length === 0) {
+      await logger.warn("Phase 3: LLM returned empty commits, using fallback");
+      return null;
+    }
+    const newCommits = [];
+    let extendedCount = 0;
+    let createdCount = 0;
+    for (const commit of toolArgs.commits) {
+      if (!Array.isArray(commit.files) || commit.files.length === 0) {
+        await logger.warn("Phase 3: Skipping commit action with empty files", {
+          action: commit.action,
+          existingCommitId: commit.existingCommitId
+        });
+        continue;
+      }
+      const action = commit.action || "create_new";
+      if (action === "extend_existing") {
+        const normalizedRequestedId = normalizeCommitId(commit.existingCommitId);
+        const existingCommit = existingCommits.find((c) => normalizeCommitId(c.id) === normalizedRequestedId);
+        if (existingCommit) {
+          existingCommit.files.push(...commit.files);
+          extendedCount++;
+          await logger.debug("Phase 3: Extended existing commit", {
+            commitId: existingCommit.id,
+            message: existingCommit.message,
+            addedFiles: commit.files.length
+          });
+        } else {
+          await logger.warn("Phase 3: Commit ID not found, creating new instead", {
+            requestedId: commit.existingCommitId,
+            normalizedRequestedId,
+            availableIds: existingCommits.map((c) => c.id).slice(0, 10)
+          });
+          const safeCommit = toSafeCommitGroup(
+            commit,
+            `c${existingCommits.length + newCommits.length + 1}`
+          );
+          if (safeCommit) {
+            newCommits.push(safeCommit);
+            createdCount++;
+          } else {
+            await logger.warn("Phase 3: Fallback commit had no valid files, skipped", {
+              requestedId: commit.existingCommitId
+            });
+          }
+        }
+      } else {
+        const safeCommit = toSafeCommitGroup(
+          commit,
+          `c${existingCommits.length + newCommits.length + 1}`
+        );
+        if (safeCommit) {
+          newCommits.push(safeCommit);
+          createdCount++;
+        } else {
+          await logger.warn("Phase 3: create_new action had no valid files, skipped");
+        }
+      }
+    }
+    await logger.debug("Phase 3: Processed commits", {
+      total: toolArgs.commits.length,
+      extended: extendedCount,
+      created: createdCount,
+      newCommitsCount: newCommits.length
+    });
+    return newCommits;
+  } catch (error) {
+    await logger.warn("Phase 3 failed, using fallback", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function generateWithNativeToolsPhase2(llm, summaries, diffs, recentCommits, logger, _onProgress) {
+  if (!llm || !llm.chatWithTools) {
+    throw new Error("LLM does not support native tools (chatWithTools)");
+  }
+  const userPrompt = buildPromptWithDiff(summaries, diffs, recentCommits);
+  const messages = [
+    {
+      role: "system",
+      content: SYSTEM_PROMPT_WITH_DIFF
+    },
+    {
+      role: "user",
+      content: userPrompt
+    }
+  ];
+  const response = await llm.chatWithTools(messages, {
+    tools: [COMMIT_PLAN_TOOL],
+    toolChoice: {
+      type: "function",
+      function: { name: "generate_commit_plan" }
+    },
+    temperature: 0.3
+  });
+  const toolCall = response.toolCalls?.[0];
+  if (!toolCall || toolCall.name !== "generate_commit_plan") {
+    throw new Error("LLM did not call generate_commit_plan tool in Phase 2");
+  }
+  const toolArgs = toolCall.input;
+  const totalConfidence = toolArgs.commits.reduce((sum, c) => {
+    const confidence = c.reasoning?.confidence ?? 0.5;
+    return sum + confidence;
+  }, 0);
+  const averageConfidence = toolArgs.commits.length > 0 ? totalConfidence / toolArgs.commits.length : 0;
+  await logger.debug("Native tools Phase 2 result", {
+    commitsCount: toolArgs.commits.length,
+    averageConfidence
+  });
+  return {
+    parsed: {
+      needsMoreContext: false,
+      // Phase 2 is final, no more escalation
+      requestedFiles: [],
+      commits: toolArgs.commits,
+      averageConfidence
+    },
+    tokensUsed: response.usage ? response.usage.promptTokens + response.usage.completionTokens : void 0
+  };
+}
+async function validateAndFixCommits(commits, summaries, llm, llmUsed, logger, onProgress) {
+  const realFiles = new Set(summaries.map((s) => s.path));
+  for (const commit of commits) {
+    const validFiles = [];
+    for (const file of commit.files) {
+      if (realFiles.has(file)) {
+        validFiles.push(file);
+      }
+    }
+    commit.files = validFiles;
+  }
+  let nonEmptyCommits = commits.filter((c) => c.files.length > 0);
+  const seenFiles = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  for (const commit of nonEmptyCommits) {
+    const uniqueFiles = [];
+    for (const file of commit.files) {
+      if (!seenFiles.has(file)) {
+        uniqueFiles.push(file);
+        seenFiles.add(file);
+      } else {
+        duplicates.push({ file, commit: commit.id });
+      }
+    }
+    commit.files = uniqueFiles;
+  }
+  if (duplicates.length > 0) {
+    logger.warn(`LLM returned ${duplicates.length} duplicate file(s) across commits - removed duplicates`, {
+      duplicateCount: duplicates.length,
+      samples: duplicates.slice(0, 5).map((d) => `${d.file} in ${d.commit}`)
+    });
+  }
+  nonEmptyCommits = nonEmptyCommits.filter((c) => c.files.length > 0);
+  const MAX_PHASE3_ITERATIONS = 5;
+  let phase3Iteration = 0;
+  while (phase3Iteration < MAX_PHASE3_ITERATIONS) {
+    const allFilesInCommits = new Set(nonEmptyCommits.flatMap((c) => c.files));
+    const missingFiles = summaries.map((s) => s.path).filter((f) => !allFilesInCommits.has(f));
+    if (missingFiles.length === 0) {
+      if (phase3Iteration > 0) {
+        await logger.info("Phase 3: All files classified", {
+          totalIterations: phase3Iteration,
+          totalCommits: nonEmptyCommits.length
+        });
+      }
+      break;
+    }
+    phase3Iteration++;
+    await logger.debug(`Phase 3 iteration ${phase3Iteration}/${MAX_PHASE3_ITERATIONS}`, {
+      missingFiles: missingFiles.length,
+      processedSoFar: summaries.length - missingFiles.length,
+      totalFiles: summaries.length,
+      progress: `${Math.round((summaries.length - missingFiles.length) / summaries.length * 100)}%`
+    });
+    if (onProgress) {
+      const progress = Math.round((summaries.length - missingFiles.length) / summaries.length * 100);
+      onProgress(`Classifying remaining files (Phase 3, iteration ${phase3Iteration}, ${progress}%)...`);
+    }
+    const missingSummaries = summaries.filter((s) => missingFiles.includes(s.path));
+    let missingCommits = null;
+    if (llmUsed && llm) {
+      missingCommits = await generateMissingFilesCommit(
+        llm,
+        missingSummaries,
+        nonEmptyCommits,
+        // ← pass updated commits list (includes previous iterations)
+        logger,
+        onProgress
+      );
+      if (missingCommits && missingCommits.length > 0) {
+        await logger.debug(`Phase 3 iteration ${phase3Iteration}: Processed commits`, {
+          commitCount: missingCommits.length,
+          filesCount: missingCommits.reduce((sum, c) => sum + c.files.length, 0)
+        });
+        nonEmptyCommits.push(...missingCommits);
+      }
+    }
+    const newMissingFiles = summaries.map((s) => s.path).filter((f) => !new Set(nonEmptyCommits.flatMap((c) => c.files)).has(f));
+    if (newMissingFiles.length === missingFiles.length) {
+      await logger.warn("Phase 3: LLM made no progress, stopping iterations", {
+        iteration: phase3Iteration,
+        stillMissing: newMissingFiles.length
+      });
+      break;
+    }
+    if (newMissingFiles.length <= 3 && phase3Iteration >= 2) {
+      await logger.debug("Phase 3: Few files left, proceeding to fallback");
+      break;
+    }
+  }
+  const finalMissingFiles = summaries.map((s) => s.path).filter((f) => !new Set(nonEmptyCommits.flatMap((c) => c.files)).has(f));
+  if (finalMissingFiles.length > 0) {
+    await logger.warn("Phase 3: Max iterations reached or LLM struggled, using fallback", {
+      totalIterations: phase3Iteration,
+      remainingFiles: finalMissingFiles.length
+    });
+    const firstFile = finalMissingFiles[0];
+    const fileName = firstFile ? firstFile.split("/").pop() ?? firstFile : "files";
+    const commitMessage = finalMissingFiles.length === 1 ? `update ${fileName}` : `update ${finalMissingFiles.length} remaining files`;
+    const fallbackCommit = {
+      id: `c${nonEmptyCommits.length + 1}`,
+      type: "chore",
+      message: commitMessage,
+      files: finalMissingFiles,
+      releaseHint: "none",
+      breaking: false,
+      reasoning: {
+        newBehavior: false,
+        fixesBug: false,
+        internalOnly: true,
+        explanation: `Files not classified after ${phase3Iteration} Phase 3 iteration(s): ${finalMissingFiles.slice(0, 3).join(", ")}${finalMissingFiles.length > 3 ? ` and ${finalMissingFiles.length - 3} more` : ""}`,
+        confidence: 0.3
+      }
+    };
+    nonEmptyCommits.push(fallbackCommit);
+  }
+  return nonEmptyCommits;
+}
+async function retryLLMCall(llmFn, phase, logger, onProgress) {
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_LLM_RETRIES; attempt++) {
+    try {
+      const result = await llmFn();
+      parseResponse(result.content);
+      if (attempt > 1) {
+        await logger.debug(`${phase} succeeded on attempt ${attempt}/${MAX_LLM_RETRIES}`);
+      }
+      return result;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      await logger.error(`\u{1F50D} LLM call failed (attempt ${attempt})`, lastError, {
+        errorName: lastError.name,
+        errorMessage: lastError.message,
+        errorStack: lastError.stack
+      });
+      const errorType = getErrorType(lastError);
+      if (attempt < MAX_LLM_RETRIES) {
+        await logger.warn(`${phase} failed (attempt ${attempt}/${MAX_LLM_RETRIES}): ${errorType}`, {
+          errorMessage: lastError.message,
+          errorType,
+          attempt,
+          stack: lastError.stack?.split("\n").slice(0, 3).join("\n")
+          // First 3 lines only
+        });
+        onProgress?.(`${phase} ${errorType}, retrying (${attempt}/${MAX_LLM_RETRIES})...`);
+        await new Promise((resolve) => {
+          setTimeout(resolve, 1e3 * Math.pow(2, attempt - 1));
+        });
+      } else {
+        await logger.error(`${phase} failed after ${MAX_LLM_RETRIES} attempts: ${errorType}`, lastError, {
+          errorType
+        });
+      }
+    }
+  }
+  throw lastError || new Error(`${phase} failed after ${MAX_LLM_RETRIES} attempts`);
+}
+function getErrorType(error) {
+  const message = error.message.toLowerCase();
+  if (message.includes("429") || message.includes("rate limit") || message.includes("too many requests")) {
+    return "rate limited (429)";
+  }
+  if (message.includes("500") || message.includes("502") || message.includes("503")) {
+    return "server error (5xx)";
+  }
+  if (message.includes("timeout") || message.includes("timed out")) {
+    return "timeout";
+  }
+  if (message.includes("network") || message.includes("econnrefused") || message.includes("enotfound")) {
+    return "network error";
+  }
+  if (message.includes("json") || message.includes("parse") || message.includes("unexpected token")) {
+    return "invalid JSON";
+  }
+  if (message.includes("missing") || message.includes("missing required field")) {
+    return "invalid structure";
+  }
+  const preview = error.message.substring(0, 50).replace(/\n/g, " ");
+  return `error: ${preview}${error.message.length > 50 ? "..." : ""}`;
+}
+
+export { COMMIT_PLAN_TOOL, COMMIT_PLAN_TOOL_PHASE3, SYSTEM_PROMPT, SYSTEM_PROMPT_WITH_DIFF, buildPrompt, buildPromptWithDiff, generateCommitPlan, generateHeuristicPlan, parseResponse };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map