@promptbook/cli 0.113.0-6 → 0.113.0-7

package/esm/index.es.js

@@ -59,7 +59,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.113.0-6';
+const PROMPTBOOK_ENGINE_VERSION = '0.113.0-7';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -40286,6 +40286,30 @@ function createLineCountLimits(maxLineCount) {
 }
 // Note: [🟡] Code for repository script [RefactorCandidateLevel](scripts/find-refactor-candidates/RefactorCandidateLevel.ts) should never be published outside of `@promptbook/cli`
 
+/**
+ * Creates a Commander argument parser that accepts only positive integers.
+ *
+ * The returned parser is meant to be passed as the coercion callback of `command.option(...)`.
+ * It throws a branded `NotAllowed` error with a clear message referencing the given option name
+ * when the provided value is not a positive integer.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+function createPositiveIntegerOptionParser(optionName) {
+    return (value) => {
+        const parsedValue = Number(value);
+        if (!Number.isInteger(parsedValue) || parsedValue <= 0) {
+            throw new NotAllowed(spaceTrim$1(`
+                    Invalid value for \`${optionName}\`: \`${value}\`.
+
+                    Use a positive integer.
+                `));
+        }
+        return parsedValue;
+    };
+}
+// Note: [🟡] Code for CLI option parser [createPositiveIntegerOptionParser](src/cli/cli-commands/common/createPositiveIntegerOptionParser.ts) should never be published outside of `@promptbook/cli`
+
 /**
  * Initializes `coder find-refactor-candidates` command for Promptbook CLI utilities
  *
@@ -40306,12 +40330,13 @@ function $initializeCoderFindRefactorCandidatesCommand(program) {
     command.addOption(new Option('--level <level>', `Set scan aggressiveness (${REFACTOR_CANDIDATE_LEVEL_VALUES.join(', ')})`)
         .choices([...REFACTOR_CANDIDATE_LEVEL_VALUES])
         .default(DEFAULT_REFACTOR_CANDIDATE_LEVEL));
+    command.option('--limit <candidate-count>', 'Create at most this many refactor prompts, keeping the most important candidates', createPositiveIntegerOptionParser('--limit'));
     command.action(handleActionErrors(async (cliOptions) => {
-        const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL } = cliOptions;
+        const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL, limit } = cliOptions;
         // Note: Import the function dynamically to avoid loading heavy dependencies until needed
         const { findRefactorCandidates } = await Promise.resolve().then(function () { return findRefactorCandidates$1; });
         try {
-            await findRefactorCandidates({ level });
+            await findRefactorCandidates({ level, limit });
         }
         catch (error) {
             assertsError(error);
@@ -41460,7 +41485,7 @@ function $initializeCoderRunCommand(program) {
     command.option('--preserve-logs', 'Keep generated temp prompt/log artifacts after successful rounds for debugging and analytics', false);
     addPromptRunnerExecutionOptions(command);
     command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption$1, 0);
-    command.option('--limit <run-count>', 'Stop after processing this many prompt runs', parsePositiveIntegerOption);
+    command.option('--limit <run-count>', 'Stop after processing this many prompt runs', createPositiveIntegerOptionParser('--limit'));
     command.option('--wait-after-prompt <duration>', spaceTrim$1(`
             Wait this long after each prompt has been implemented, verified and committed before starting the next prompt.
             Accepts durations like 1h, 30m, 5s. Defaults to 0 (no wait).
@@ -41547,22 +41572,6 @@ function parseIntOption$1(value) {
     }
     return parsed;
 }
-/**
- * Parses a positive integer option value.
- *
- * @private internal utility of `coder run` command
- */
-function parsePositiveIntegerOption(value) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new NotAllowed(spaceTrim$1(`
-                Invalid value for \`--limit\`: \`${value}\`.
-
-                Use a positive integer.
-            `));
-    }
-    return parsed;
-}
 /**
  * Joins one Commander option that may be parsed either as a single string or a variadic token array.
  *
@@ -69835,23 +69844,28 @@ async function analyzeSourceFileForRefactorCandidate(options) {
     const extension = extname(filePath).toLowerCase();
     const relativePath = normalizeRefactorCandidatePath(relative(rootDir, filePath));
     const reasons = [];
+    let severityScore = 0;
     if (!lineCountExemptPaths.has(normalizedAbsolutePath)) {
         const lineCount = countLines(content);
         const maxLines = getMaxLinesForExtension(extension, heuristics);
         if (lineCount > maxLines) {
             reasons.push(`lines ${lineCount}/${maxLines}`);
+            severityScore += lineCount / maxLines;
         }
     }
     if (STRUCTURAL_ANALYSIS_EXTENSIONS.includes(extension)) {
         const structureSummary = summarizeSourceFileStructure(content, extension, filePath);
         if (structureSummary.entityCount > heuristics.maxEntityCountPerFile) {
             reasons.push(`entities ${structureSummary.entityCount}/${heuristics.maxEntityCountPerFile}`);
+            severityScore += structureSummary.entityCount / heuristics.maxEntityCountPerFile;
         }
         if (structureSummary.functionCount > heuristics.maxFunctionCountPerFile) {
             reasons.push(`functions ${structureSummary.functionCount}/${heuristics.maxFunctionCountPerFile}`);
+            severityScore += structureSummary.functionCount / heuristics.maxFunctionCountPerFile;
         }
         if (structureSummary.maxFunctionComplexity > heuristics.maxFunctionComplexity) {
             reasons.push(buildComplexityReason(structureSummary, heuristics.maxFunctionComplexity));
+            severityScore += structureSummary.maxFunctionComplexity / heuristics.maxFunctionComplexity;
         }
     }
     if (reasons.length === 0) {
@@ -69861,6 +69875,7 @@ async function analyzeSourceFileForRefactorCandidate(options) {
         absolutePath: filePath,
         relativePath,
         reasons,
+        severityScore,
     };
 }
 /**
@@ -70320,6 +70335,37 @@ async function isExistingFile(filePath) {
 }
 // Note: [🟡] Code for repository script [resolveRefactorCandidateProject](scripts/find-refactor-candidates/resolveRefactorCandidateProject.ts) should never be published outside of `@promptbook/cli`
 
+/**
+ * Keeps at most `limit` refactor candidates, preferring the most important ones.
+ *
+ * When there are more candidates than `limit`, only the highest-severity candidates are kept
+ * (ties broken by relative path for determinism). When `limit` is `undefined` or there are fewer
+ * candidates than the limit, every candidate is returned. The original input order is preserved
+ * among the kept candidates, so `limit` acts purely as a filter and never reorders prompts.
+ *
+ * @private function of findRefactorCandidates
+ */
+function selectMostImportantRefactorCandidates(candidates, limit) {
+    if (limit === undefined || candidates.length <= limit) {
+        return candidates;
+    }
+    const candidatesRankedByImportance = [...candidates].sort(compareRefactorCandidatesByImportance);
+    const keptRelativePaths = new Set(candidatesRankedByImportance.slice(0, limit).map((candidate) => candidate.relativePath));
+    return candidates.filter((candidate) => keptRelativePaths.has(candidate.relativePath));
+}
+/**
+ * Orders refactor candidates from most to least important.
+ *
+ * @private function of selectMostImportantRefactorCandidates
+ */
+function compareRefactorCandidatesByImportance(candidateA, candidateB) {
+    if (candidateB.severityScore !== candidateA.severityScore) {
+        return candidateB.severityScore - candidateA.severityScore;
+    }
+    return candidateA.relativePath.localeCompare(candidateB.relativePath);
+}
+// Note: [🟡] Code for repository script [selectMostImportantRefactorCandidates](scripts/find-refactor-candidates/selectMostImportantRefactorCandidates.ts) should never be published outside of `@promptbook/cli`
+
 /**
  * Calculates the next available prompt numbering sequence for a month.
  */
@@ -70643,7 +70689,7 @@ function initializeFindRefactorCandidatesRun() {
  * @public exported from `@promptbook/cli`
  */
 async function findRefactorCandidates(options = {}) {
-    const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL } = options;
+    const { level = DEFAULT_REFACTOR_CANDIDATE_LEVEL, limit } = options;
     const heuristics = getRefactorCandidateLevelConfiguration(level);
     initializeFindRefactorCandidatesRun();
     console.info(colors.cyan('⚡🏭 Find refactor candidates'));
@@ -70667,8 +70713,10 @@ async function findRefactorCandidates(options = {}) {
         console.info(colors.green('All candidates already have prompts.'));
         return;
     }
+    const selectedCandidatesToWrite = selectMostImportantRefactorCandidates(candidatesToWrite, limit);
+    const skippedByLimit = candidatesToWrite.length - selectedCandidatesToWrite.length;
     const createdPrompts = await writeRefactorCandidatePrompts({
-        candidates: candidatesToWrite,
+        candidates: selectedCandidatesToWrite,
         rootDir,
         promptsDir,
     });
@@ -70676,6 +70724,9 @@ async function findRefactorCandidates(options = {}) {
     if (alreadyTracked > 0) {
         console.info(colors.gray(`Skipped ${alreadyTracked} candidate(s) with existing prompts.`));
     }
+    if (skippedByLimit > 0) {
+        console.info(colors.gray(`Skipped ${skippedByLimit} lower-priority candidate(s) because of \`--limit ${limit}\`.`));
+    }
 }
 /**
  * Prints discovered refactor candidates with their reasons.