git-coco 0.43.0 → 0.44.0

package/dist/index.d.ts

@@ -472,6 +472,7 @@ type LlmCallMetadata = {
     provider?: string;
     model?: string;
     retryAttempt?: number;
+    planAttempt?: number;
     parserType?: string;
     variableKeys?: string[];
     promptTokens?: number;

package/dist/index.esm.mjs

@@ -54,7 +54,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.43.0";
+const BUILD_VERSION = "0.44.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -12415,6 +12415,164 @@ const CommitSplitPlanSchema = objectType({
     }))
         .min(1),
 });
+
+const getGroupFiles$1 = (group) => group.files || [];
+const getGroupHunks$1 = (group) => group.hunks || [];
+function getPlanValidationIssues(plan, staged, hunkInventory) {
+    const stagedFiles = new Set(staged.map((change) => change.filePath));
+    const seen = new Set();
+    const seenHunks = new Set();
+    const unknownFiles = [];
+    const duplicateFiles = [];
+    const unknownHunks = [];
+    const duplicateHunks = [];
+    plan.groups.forEach((group) => {
+        getGroupFiles$1(group).forEach((file) => {
+            if (!stagedFiles.has(file)) {
+                unknownFiles.push(file);
+                return;
+            }
+            if (seen.has(file)) {
+                duplicateFiles.push(file);
+                return;
+            }
+            seen.add(file);
+        });
+        getGroupHunks$1(group).forEach((hunkId) => {
+            const hunk = hunkInventory?.byId.get(hunkId);
+            if (!hunk) {
+                unknownHunks.push(hunkId);
+                return;
+            }
+            if (seenHunks.has(hunkId)) {
+                duplicateHunks.push(hunkId);
+                return;
+            }
+            seenHunks.add(hunkId);
+        });
+    });
+    const hunkCoveredFiles = new Set([...seenHunks].map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath));
+    const mixedFiles = [...seen].filter((file) => hunkCoveredFiles.has(file));
+    const partiallyCoveredFiles = [...hunkCoveredFiles]
+        .filter((file) => Boolean(file))
+        .filter((file) => {
+        const fileHunks = hunkInventory?.byFile.get(file) || [];
+        return fileHunks.some((hunk) => !seenHunks.has(hunk.id));
+    });
+    const missingFiles = [...stagedFiles].filter((file) => !seen.has(file) && !hunkCoveredFiles.has(file));
+    return {
+        unknownFiles,
+        duplicateFiles,
+        unknownHunks,
+        duplicateHunks,
+        mixedFiles,
+        partiallyCoveredFiles,
+        missingFiles,
+    };
+}
+function hasPlanValidationIssues(issues) {
+    return (issues.unknownFiles.length > 0 ||
+        issues.duplicateFiles.length > 0 ||
+        issues.unknownHunks.length > 0 ||
+        issues.duplicateHunks.length > 0 ||
+        issues.mixedFiles.length > 0 ||
+        issues.partiallyCoveredFiles.length > 0 ||
+        issues.missingFiles.length > 0);
+}
+function formatPlanValidationIssuesError(issues) {
+    return [
+        issues.unknownFiles.length ? `unknown files: ${issues.unknownFiles.join(', ')}` : undefined,
+        issues.duplicateFiles.length
+            ? `duplicate files: ${issues.duplicateFiles.join(', ')}`
+            : undefined,
+        issues.unknownHunks.length ? `unknown hunks: ${issues.unknownHunks.join(', ')}` : undefined,
+        issues.duplicateHunks.length
+            ? `duplicate hunks: ${issues.duplicateHunks.join(', ')}`
+            : undefined,
+        issues.mixedFiles.length
+            ? `files assigned both as whole files and hunks: ${issues.mixedFiles.join(', ')}`
+            : undefined,
+        issues.partiallyCoveredFiles.length
+            ? `files with only some hunks assigned: ${issues.partiallyCoveredFiles.join(', ')}`
+            : undefined,
+        issues.missingFiles.length ? `missing files: ${issues.missingFiles.join(', ')}` : undefined,
+    ]
+        .filter(Boolean)
+        .join('; ');
+}
+function formatPlanValidationFeedback(issues) {
+    const sections = [];
+    if (issues.unknownFiles.length) {
+        sections.push(`Files referenced that are NOT in the staged file inventory (remove or replace): ${issues.unknownFiles.join(', ')}`);
+    }
+    if (issues.duplicateFiles.length) {
+        sections.push(`Files assigned to more than one group (each file may appear at most once): ${issues.duplicateFiles.join(', ')}`);
+    }
+    if (issues.unknownHunks.length) {
+        sections.push(`Hunk IDs referenced that are NOT in the staged hunk inventory: ${issues.unknownHunks.join(', ')}`);
+    }
+    if (issues.duplicateHunks.length) {
+        sections.push(`Hunk IDs assigned to more than one group (each hunk may appear at most once): ${issues.duplicateHunks.join(', ')}`);
+    }
+    if (issues.mixedFiles.length) {
+        sections.push(`Files assigned BOTH as whole files and via hunks (pick one mode per file): ${issues.mixedFiles.join(', ')}`);
+    }
+    if (issues.partiallyCoveredFiles.length) {
+        sections.push(`Files with only some hunks assigned (every hunk for these files must be covered): ${issues.partiallyCoveredFiles.join(', ')}`);
+    }
+    if (issues.missingFiles.length) {
+        sections.push(`Staged files missing from every group (must appear exactly once): ${issues.missingFiles.join(', ')}`);
+    }
+    return sections.map((section) => `- ${section}`).join('\n');
+}
+
+const NO_PREVIOUS_FEEDBACK_PLACEHOLDER = 'None — this is the first attempt.';
+const DEFAULT_MAX_PLAN_ATTEMPTS = 3;
+/**
+ * Generate a commit-split plan with self-correcting retries on validator failures.
+ *
+ * The first attempt runs as normal. If `validatePlanForStagedFiles` rejects the result,
+ * the validator's complaints are formatted as natural-language feedback and fed back
+ * into the same prompt template (`previous_attempt_feedback` slot) so the model can
+ * fix its own mistakes without re-running pre-processing.
+ */
+async function generateValidatedCommitSplitPlan({ llm, prompt, variables, staged, hunkInventory, logger, tokenizer, metadata = {}, maxAttempts = DEFAULT_MAX_PLAN_ATTEMPTS, }) {
+    let lastIssues = null;
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+        attempt++;
+        const previousFeedback = lastIssues
+            ? formatPlanValidationFeedback(lastIssues)
+            : NO_PREVIOUS_FEEDBACK_PLACEHOLDER;
+        const plan = await executeChainWithSchema(CommitSplitPlanSchema, llm, prompt, {
+            ...variables,
+            previous_attempt_feedback: previousFeedback,
+        }, {
+            logger,
+            tokenizer,
+            metadata: {
+                task: 'commit-split-plan',
+                ...metadata,
+                planAttempt: attempt,
+            },
+        });
+        const issues = getPlanValidationIssues(plan, staged, hunkInventory);
+        if (!hasPlanValidationIssues(issues)) {
+            if (attempt > 1 && logger) {
+                logger.verbose(`Plan validated after ${attempt} attempts.`, { color: 'green' });
+            }
+            return { plan, attempts: attempt };
+        }
+        lastIssues = issues;
+        if (logger) {
+            logger.verbose(`Plan attempt ${attempt}/${maxAttempts} failed validation: ${formatPlanValidationIssuesError(issues)}`, { color: 'yellow' });
+        }
+    }
+    throw new Error(lastIssues
+        ? `Failed to produce a valid commit-split plan after ${maxAttempts} attempts. Final validator issues: ${formatPlanValidationIssuesError(lastIssues)}`
+        : `Failed to produce a valid commit-split plan after ${maxAttempts} attempts.`);
+}
+
 const COMMIT_SPLIT_PROMPT = PromptTemplate.fromTemplate(`You are helping split staged git changes into a small sequence of coherent commits.
 
 Return ONLY valid JSON matching this schema:
@@ -12431,14 +12589,13 @@ Return ONLY valid JSON matching this schema:
 }}
 
 Rules:
-- Use each staged file exactly once.
-- If a file has hunk IDs and contains unrelated changes, assign every hunk ID exactly once instead of assigning the whole file.
-- Do not list the same file in "files" when assigning that file through "hunks".
-- Only use file paths listed in the staged file inventory.
-- Only use hunk IDs listed in the staged hunk inventory.
+- Every staged file MUST be assigned exactly once across all groups, either via "files" OR via every one of its hunk IDs (never both).
+- If you assign any hunk for a file, you MUST assign EVERY hunk for that file across the groups — partial coverage is invalid.
+- Do not list the same file in "files" of more than one group, and do not assign the same hunk ID to more than one group.
+- Only use file paths listed in the staged file inventory. Do not invent files.
+- Only use hunk IDs listed in the staged hunk inventory. Do not invent hunk IDs.
 - Prefer 2-5 commits unless the changes are truly all one topic.
 - Keep commit titles concise and understandable.
-- Do not invent files.
 
 Staged file inventory:
 {file_inventory}
@@ -12450,7 +12607,10 @@ Condensed staged diff:
 {summary}
 
 Additional context:
-{additional_context}`);
+{additional_context}
+
+Feedback on previous attempt (fix every item before responding):
+{previous_attempt_feedback}`);
 function isCommitSplitCommand(argv) {
     return Boolean(argv.split || argv.plan || argv.apply || argv._.includes('split'));
 }
@@ -12469,9 +12629,6 @@ function formatCommitSplitPlan(plan) {
     })
         .join('\n\n---\n\n');
 }
-function getStagedFileSet(changes) {
-    return new Set(changes.map((change) => change.filePath));
-}
 function getGroupFiles(group) {
     return group.files || [];
 }
@@ -12528,67 +12685,9 @@ function formatHunkInventory(inventory) {
         .join('\n');
 }
 function validatePlanForStagedFiles(plan, staged, hunkInventory) {
-    const stagedFiles = getStagedFileSet(staged);
-    const seen = new Set();
-    const seenHunks = new Set();
-    const unknown = [];
-    const duplicate = [];
-    const unknownHunks = [];
-    const duplicateHunks = [];
-    plan.groups.forEach((group) => {
-        getGroupFiles(group).forEach((file) => {
-            if (!stagedFiles.has(file)) {
-                unknown.push(file);
-                return;
-            }
-            if (seen.has(file)) {
-                duplicate.push(file);
-                return;
-            }
-            seen.add(file);
-        });
-        getGroupHunks(group).forEach((hunkId) => {
-            const hunk = hunkInventory?.byId.get(hunkId);
-            if (!hunk) {
-                unknownHunks.push(hunkId);
-                return;
-            }
-            if (seenHunks.has(hunkId)) {
-                duplicateHunks.push(hunkId);
-                return;
-            }
-            seenHunks.add(hunkId);
-        });
-    });
-    const hunkCoveredFiles = new Set([...seenHunks].map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath));
-    const mixedFiles = [...seen].filter((file) => hunkCoveredFiles.has(file));
-    const partiallyCoveredFiles = [...hunkCoveredFiles]
-        .filter((file) => Boolean(file))
-        .filter((file) => {
-        const fileHunks = hunkInventory?.byFile.get(file) || [];
-        return fileHunks.some((hunk) => !seenHunks.has(hunk.id));
-    });
-    const missing = [...stagedFiles].filter((file) => !seen.has(file) && !hunkCoveredFiles.has(file));
-    if (unknown.length ||
-        duplicate.length ||
-        unknownHunks.length ||
-        duplicateHunks.length ||
-        mixedFiles.length ||
-        partiallyCoveredFiles.length ||
-        missing.length) {
-        throw new Error([
-            unknown.length ? `unknown files: ${unknown.join(', ')}` : undefined,
-            duplicate.length ? `duplicate files: ${duplicate.join(', ')}` : undefined,
-            unknownHunks.length ? `unknown hunks: ${unknownHunks.join(', ')}` : undefined,
-            duplicateHunks.length ? `duplicate hunks: ${duplicateHunks.join(', ')}` : undefined,
-            mixedFiles.length ? `files assigned both as whole files and hunks: ${mixedFiles.join(', ')}` : undefined,
-            partiallyCoveredFiles.length
-                ? `files with only some hunks assigned: ${partiallyCoveredFiles.join(', ')}`
-                : undefined,
-            missing.length ? `missing files: ${missing.join(', ')}` : undefined,
-        ]
-            .filter(Boolean)
-            .join('; '));
+    const issues = getPlanValidationIssues(plan, staged, hunkInventory);
+    if (hasPlanValidationIssues(issues)) {
+        throw new Error(formatPlanValidationIssuesError(issues));
     }
 }
 function assertNoUnstagedOverlap(plan, changes, hunkInventory) {
@@ -12692,22 +12791,26 @@ async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, })
         .map((change) => `- ${change.filePath}: ${change.status} - ${change.summary}`)
         .join('\n');
     const hunkInventoryText = formatHunkInventory(hunkInventory);
-    const plan = await executeChainWithSchema(CommitSplitPlanSchema, llm, COMMIT_SPLIT_PROMPT, {
-        file_inventory: fileInventory,
-        hunk_inventory: hunkInventoryText,
-        summary,
-        additional_context: argv.additional || '',
-    }, {
+    const { plan } = await generateValidatedCommitSplitPlan({
+        llm,
+        prompt: COMMIT_SPLIT_PROMPT,
+        variables: {
+            file_inventory: fileInventory,
+            hunk_inventory: hunkInventoryText,
+            summary,
+            additional_context: argv.additional || '',
+        },
+        staged: changes.staged,
+        hunkInventory,
         logger,
         tokenizer,
         metadata: {
-            task: 'commit-split-plan',
             command: 'commit',
             provider: config.service.provider,
             model: String(config.service.model),
         },
+        maxAttempts: DEFAULT_MAX_PLAN_ATTEMPTS,
     });
-    validatePlanForStagedFiles(plan, changes.staged, hunkInventory);
     if (argv.apply) {
         return await applyCommitSplitPlan({
             plan,

package/dist/index.js

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.43.0";
+const BUILD_VERSION = "0.44.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -12439,6 +12439,164 @@ const CommitSplitPlanSchema = objectType({
     }))
         .min(1),
 });
+
+const getGroupFiles$1 = (group) => group.files || [];
+const getGroupHunks$1 = (group) => group.hunks || [];
+function getPlanValidationIssues(plan, staged, hunkInventory) {
+    const stagedFiles = new Set(staged.map((change) => change.filePath));
+    const seen = new Set();
+    const seenHunks = new Set();
+    const unknownFiles = [];
+    const duplicateFiles = [];
+    const unknownHunks = [];
+    const duplicateHunks = [];
+    plan.groups.forEach((group) => {
+        getGroupFiles$1(group).forEach((file) => {
+            if (!stagedFiles.has(file)) {
+                unknownFiles.push(file);
+                return;
+            }
+            if (seen.has(file)) {
+                duplicateFiles.push(file);
+                return;
+            }
+            seen.add(file);
+        });
+        getGroupHunks$1(group).forEach((hunkId) => {
+            const hunk = hunkInventory?.byId.get(hunkId);
+            if (!hunk) {
+                unknownHunks.push(hunkId);
+                return;
+            }
+            if (seenHunks.has(hunkId)) {
+                duplicateHunks.push(hunkId);
+                return;
+            }
+            seenHunks.add(hunkId);
+        });
+    });
+    const hunkCoveredFiles = new Set([...seenHunks].map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath));
+    const mixedFiles = [...seen].filter((file) => hunkCoveredFiles.has(file));
+    const partiallyCoveredFiles = [...hunkCoveredFiles]
+        .filter((file) => Boolean(file))
+        .filter((file) => {
+        const fileHunks = hunkInventory?.byFile.get(file) || [];
+        return fileHunks.some((hunk) => !seenHunks.has(hunk.id));
+    });
+    const missingFiles = [...stagedFiles].filter((file) => !seen.has(file) && !hunkCoveredFiles.has(file));
+    return {
+        unknownFiles,
+        duplicateFiles,
+        unknownHunks,
+        duplicateHunks,
+        mixedFiles,
+        partiallyCoveredFiles,
+        missingFiles,
+    };
+}
+function hasPlanValidationIssues(issues) {
+    return (issues.unknownFiles.length > 0 ||
+        issues.duplicateFiles.length > 0 ||
+        issues.unknownHunks.length > 0 ||
+        issues.duplicateHunks.length > 0 ||
+        issues.mixedFiles.length > 0 ||
+        issues.partiallyCoveredFiles.length > 0 ||
+        issues.missingFiles.length > 0);
+}
+function formatPlanValidationIssuesError(issues) {
+    return [
+        issues.unknownFiles.length ? `unknown files: ${issues.unknownFiles.join(', ')}` : undefined,
+        issues.duplicateFiles.length
+            ? `duplicate files: ${issues.duplicateFiles.join(', ')}`
+            : undefined,
+        issues.unknownHunks.length ? `unknown hunks: ${issues.unknownHunks.join(', ')}` : undefined,
+        issues.duplicateHunks.length
+            ? `duplicate hunks: ${issues.duplicateHunks.join(', ')}`
+            : undefined,
+        issues.mixedFiles.length
+            ? `files assigned both as whole files and hunks: ${issues.mixedFiles.join(', ')}`
+            : undefined,
+        issues.partiallyCoveredFiles.length
+            ? `files with only some hunks assigned: ${issues.partiallyCoveredFiles.join(', ')}`
+            : undefined,
+        issues.missingFiles.length ? `missing files: ${issues.missingFiles.join(', ')}` : undefined,
+    ]
+        .filter(Boolean)
+        .join('; ');
+}
+function formatPlanValidationFeedback(issues) {
+    const sections = [];
+    if (issues.unknownFiles.length) {
+        sections.push(`Files referenced that are NOT in the staged file inventory (remove or replace): ${issues.unknownFiles.join(', ')}`);
+    }
+    if (issues.duplicateFiles.length) {
+        sections.push(`Files assigned to more than one group (each file may appear at most once): ${issues.duplicateFiles.join(', ')}`);
+    }
+    if (issues.unknownHunks.length) {
+        sections.push(`Hunk IDs referenced that are NOT in the staged hunk inventory: ${issues.unknownHunks.join(', ')}`);
+    }
+    if (issues.duplicateHunks.length) {
+        sections.push(`Hunk IDs assigned to more than one group (each hunk may appear at most once): ${issues.duplicateHunks.join(', ')}`);
+    }
+    if (issues.mixedFiles.length) {
+        sections.push(`Files assigned BOTH as whole files and via hunks (pick one mode per file): ${issues.mixedFiles.join(', ')}`);
+    }
+    if (issues.partiallyCoveredFiles.length) {
+        sections.push(`Files with only some hunks assigned (every hunk for these files must be covered): ${issues.partiallyCoveredFiles.join(', ')}`);
+    }
+    if (issues.missingFiles.length) {
+        sections.push(`Staged files missing from every group (must appear exactly once): ${issues.missingFiles.join(', ')}`);
+    }
+    return sections.map((section) => `- ${section}`).join('\n');
+}
+
+const NO_PREVIOUS_FEEDBACK_PLACEHOLDER = 'None — this is the first attempt.';
+const DEFAULT_MAX_PLAN_ATTEMPTS = 3;
+/**
+ * Generate a commit-split plan with self-correcting retries on validator failures.
+ *
+ * The first attempt runs as normal. If `validatePlanForStagedFiles` rejects the result,
+ * the validator's complaints are formatted as natural-language feedback and fed back
+ * into the same prompt template (`previous_attempt_feedback` slot) so the model can
+ * fix its own mistakes without re-running pre-processing.
+ */
+async function generateValidatedCommitSplitPlan({ llm, prompt, variables, staged, hunkInventory, logger, tokenizer, metadata = {}, maxAttempts = DEFAULT_MAX_PLAN_ATTEMPTS, }) {
+    let lastIssues = null;
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+        attempt++;
+        const previousFeedback = lastIssues
+            ? formatPlanValidationFeedback(lastIssues)
+            : NO_PREVIOUS_FEEDBACK_PLACEHOLDER;
+        const plan = await executeChainWithSchema(CommitSplitPlanSchema, llm, prompt, {
+            ...variables,
+            previous_attempt_feedback: previousFeedback,
+        }, {
+            logger,
+            tokenizer,
+            metadata: {
+                task: 'commit-split-plan',
+                ...metadata,
+                planAttempt: attempt,
+            },
+        });
+        const issues = getPlanValidationIssues(plan, staged, hunkInventory);
+        if (!hasPlanValidationIssues(issues)) {
+            if (attempt > 1 && logger) {
+                logger.verbose(`Plan validated after ${attempt} attempts.`, { color: 'green' });
+            }
+            return { plan, attempts: attempt };
+        }
+        lastIssues = issues;
+        if (logger) {
+            logger.verbose(`Plan attempt ${attempt}/${maxAttempts} failed validation: ${formatPlanValidationIssuesError(issues)}`, { color: 'yellow' });
+        }
+    }
+    throw new Error(lastIssues
+        ? `Failed to produce a valid commit-split plan after ${maxAttempts} attempts. Final validator issues: ${formatPlanValidationIssuesError(lastIssues)}`
+        : `Failed to produce a valid commit-split plan after ${maxAttempts} attempts.`);
+}
+
 const COMMIT_SPLIT_PROMPT = prompts.PromptTemplate.fromTemplate(`You are helping split staged git changes into a small sequence of coherent commits.
 
 Return ONLY valid JSON matching this schema:
@@ -12455,14 +12613,13 @@ Return ONLY valid JSON matching this schema:
 }}
 
 Rules:
-- Use each staged file exactly once.
-- If a file has hunk IDs and contains unrelated changes, assign every hunk ID exactly once instead of assigning the whole file.
-- Do not list the same file in "files" when assigning that file through "hunks".
-- Only use file paths listed in the staged file inventory.
-- Only use hunk IDs listed in the staged hunk inventory.
+- Every staged file MUST be assigned exactly once across all groups, either via "files" OR via every one of its hunk IDs (never both).
+- If you assign any hunk for a file, you MUST assign EVERY hunk for that file across the groups — partial coverage is invalid.
+- Do not list the same file in "files" of more than one group, and do not assign the same hunk ID to more than one group.
+- Only use file paths listed in the staged file inventory. Do not invent files.
+- Only use hunk IDs listed in the staged hunk inventory. Do not invent hunk IDs.
 - Prefer 2-5 commits unless the changes are truly all one topic.
 - Keep commit titles concise and understandable.
-- Do not invent files.
 
 Staged file inventory:
 {file_inventory}
@@ -12474,7 +12631,10 @@ Condensed staged diff:
 {summary}
 
 Additional context:
-{additional_context}`);
+{additional_context}
+
+Feedback on previous attempt (fix every item before responding):
+{previous_attempt_feedback}`);
 function isCommitSplitCommand(argv) {
     return Boolean(argv.split || argv.plan || argv.apply || argv._.includes('split'));
 }
@@ -12493,9 +12653,6 @@ function formatCommitSplitPlan(plan) {
     })
         .join('\n\n---\n\n');
 }
-function getStagedFileSet(changes) {
-    return new Set(changes.map((change) => change.filePath));
-}
 function getGroupFiles(group) {
     return group.files || [];
 }
@@ -12552,67 +12709,9 @@ function formatHunkInventory(inventory) {
         .join('\n');
 }
 function validatePlanForStagedFiles(plan, staged, hunkInventory) {
-    const stagedFiles = getStagedFileSet(staged);
-    const seen = new Set();
-    const seenHunks = new Set();
-    const unknown = [];
-    const duplicate = [];
-    const unknownHunks = [];
-    const duplicateHunks = [];
-    plan.groups.forEach((group) => {
-        getGroupFiles(group).forEach((file) => {
-            if (!stagedFiles.has(file)) {
-                unknown.push(file);
-                return;
-            }
-            if (seen.has(file)) {
-                duplicate.push(file);
-                return;
-            }
-            seen.add(file);
-        });
-        getGroupHunks(group).forEach((hunkId) => {
-            const hunk = hunkInventory?.byId.get(hunkId);
-            if (!hunk) {
-                unknownHunks.push(hunkId);
-                return;
-            }
-            if (seenHunks.has(hunkId)) {
-                duplicateHunks.push(hunkId);
-                return;
-            }
-            seenHunks.add(hunkId);
-        });
-    });
-    const hunkCoveredFiles = new Set([...seenHunks].map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath));
-    const mixedFiles = [...seen].filter((file) => hunkCoveredFiles.has(file));
-    const partiallyCoveredFiles = [...hunkCoveredFiles]
-        .filter((file) => Boolean(file))
-        .filter((file) => {
-        const fileHunks = hunkInventory?.byFile.get(file) || [];
-        return fileHunks.some((hunk) => !seenHunks.has(hunk.id));
-    });
-    const missing = [...stagedFiles].filter((file) => !seen.has(file) && !hunkCoveredFiles.has(file));
-    if (unknown.length ||
-        duplicate.length ||
-        unknownHunks.length ||
-        duplicateHunks.length ||
-        mixedFiles.length ||
-        partiallyCoveredFiles.length ||
-        missing.length) {
-        throw new Error([
-            unknown.length ? `unknown files: ${unknown.join(', ')}` : undefined,
-            duplicate.length ? `duplicate files: ${duplicate.join(', ')}` : undefined,
-            unknownHunks.length ? `unknown hunks: ${unknownHunks.join(', ')}` : undefined,
-            duplicateHunks.length ? `duplicate hunks: ${duplicateHunks.join(', ')}` : undefined,
-            mixedFiles.length ? `files assigned both as whole files and hunks: ${mixedFiles.join(', ')}` : undefined,
-            partiallyCoveredFiles.length
-                ? `files with only some hunks assigned: ${partiallyCoveredFiles.join(', ')}`
-                : undefined,
-            missing.length ? `missing files: ${missing.join(', ')}` : undefined,
-        ]
-            .filter(Boolean)
-            .join('; '));
+    const issues = getPlanValidationIssues(plan, staged, hunkInventory);
+    if (hasPlanValidationIssues(issues)) {
+        throw new Error(formatPlanValidationIssuesError(issues));
     }
 }
 function assertNoUnstagedOverlap(plan, changes, hunkInventory) {
@@ -12716,22 +12815,26 @@ async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, })
         .map((change) => `- ${change.filePath}: ${change.status} - ${change.summary}`)
         .join('\n');
     const hunkInventoryText = formatHunkInventory(hunkInventory);
-    const plan = await executeChainWithSchema(CommitSplitPlanSchema, llm, COMMIT_SPLIT_PROMPT, {
-        file_inventory: fileInventory,
-        hunk_inventory: hunkInventoryText,
-        summary,
-        additional_context: argv.additional || '',
-    }, {
+    const { plan } = await generateValidatedCommitSplitPlan({
+        llm,
+        prompt: COMMIT_SPLIT_PROMPT,
+        variables: {
+            file_inventory: fileInventory,
+            hunk_inventory: hunkInventoryText,
+            summary,
+            additional_context: argv.additional || '',
+        },
+        staged: changes.staged,
+        hunkInventory,
         logger,
         tokenizer,
         metadata: {
-            task: 'commit-split-plan',
             command: 'commit',
             provider: config.service.provider,
             model: String(config.service.model),
         },
+        maxAttempts: DEFAULT_MAX_PLAN_ATTEMPTS,
     });
-    validatePlanForStagedFiles(plan, changes.staged, hunkInventory);
     if (argv.apply) {
         return await applyCommitSplitPlan({
             plan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",