wiggum-cli 0.13.2 → 0.15.0

package/dist/tui/utils/git-summary.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Git utilities for enhanced run summary.
+ */
+export interface FileDiffStat {
+    path: string;
+    added: number;
+    removed: number;
+}
+/**
+ * Get the current commit hash (HEAD).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @returns Short commit hash, or null if not available
+ */
+export declare function getCurrentCommitHash(projectRoot: string): string | null;
+/**
+ * Get diff stats between two commits.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash
+ * @param toHash - Ending commit hash
+ * @returns Array of file diff stats, or null if not available
+ */
+export declare function getDiffStats(projectRoot: string, fromHash: string, toHash: string): FileDiffStat[] | null;

package/dist/tui/utils/git-summary.js

@@ -0,0 +1,63 @@
+/**
+ * Git utilities for enhanced run summary.
+ */
+import { execFileSync } from 'node:child_process';
+import { logger } from '../../utils/logger.js';
+/**
+ * Get the current commit hash (HEAD).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @returns Short commit hash, or null if not available
+ */
+export function getCurrentCommitHash(projectRoot) {
+    try {
+        const hash = execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        return hash || null;
+    }
+    catch (err) {
+        logger.warn(`getCurrentCommitHash failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Get diff stats between two commits.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash
+ * @param toHash - Ending commit hash
+ * @returns Array of file diff stats, or null if not available
+ */
+export function getDiffStats(projectRoot, fromHash, toHash) {
+    try {
+        const output = execFileSync('git', ['diff', '--numstat', `${fromHash}..${toHash}`], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        if (!output) {
+            return [];
+        }
+        const stats = [];
+        const lines = output.split('\n');
+        for (const line of lines) {
+            // Format: <added>\t<removed>\t<path>
+            const parts = line.split('\t');
+            if (parts.length !== 3)
+                continue;
+            const [addedStr, removedStr, path] = parts;
+            // Binary files show '-' for added/removed
+            const added = addedStr === '-' ? 0 : parseInt(addedStr, 10) || 0;
+            const removed = removedStr === '-' ? 0 : parseInt(removedStr, 10) || 0;
+            stats.push({ path, added, removed });
+        }
+        return stats;
+    }
+    catch (err) {
+        logger.warn(`getDiffStats failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/tui/utils/input-utils.d.ts

@@ -104,6 +104,26 @@ export declare function deleteCharAfter(value: string, cursorIndex: number): Cur
  * moveCursorByWordLeft("test", 0) // => 0 (no-op at start)
  * ```
  */
+/**
+ * Deletes the word before the cursor (Ctrl+W behavior)
+ *
+ * Skips trailing whitespace, then deletes the preceding word.
+ * Uses moveCursorByWordLeft to find the word boundary.
+ *
+ * @param value - Current input value
+ * @param cursorIndex - Current cursor position
+ * @returns New value and cursor index after deletion
+ *
+ * @example
+ * ```ts
+ * deleteWordBefore("hello world", 11)
+ * // => { newValue: "hello ", newCursorIndex: 6 }
+ *
+ * deleteWordBefore("hello world", 0)
+ * // => { newValue: "hello world", newCursorIndex: 0 } (no-op at start)
+ * ```
+ */
+export declare function deleteWordBefore(value: string, cursorIndex: number): CursorManipulationResult;
 export declare function moveCursorByWordLeft(value: string, cursorIndex: number): number;
 /**
  * Moves cursor to the end of the next word (word-right navigation)

package/dist/tui/utils/input-utils.js

@@ -134,6 +134,33 @@ export function deleteCharAfter(value, cursorIndex) {
  * moveCursorByWordLeft("test", 0) // => 0 (no-op at start)
  * ```
  */
+/**
+ * Deletes the word before the cursor (Ctrl+W behavior)
+ *
+ * Skips trailing whitespace, then deletes the preceding word.
+ * Uses moveCursorByWordLeft to find the word boundary.
+ *
+ * @param value - Current input value
+ * @param cursorIndex - Current cursor position
+ * @returns New value and cursor index after deletion
+ *
+ * @example
+ * ```ts
+ * deleteWordBefore("hello world", 11)
+ * // => { newValue: "hello ", newCursorIndex: 6 }
+ *
+ * deleteWordBefore("hello world", 0)
+ * // => { newValue: "hello world", newCursorIndex: 0 } (no-op at start)
+ * ```
+ */
+export function deleteWordBefore(value, cursorIndex) {
+    if (cursorIndex <= 0) {
+        return { newValue: value, newCursorIndex: 0 };
+    }
+    const newCursorIndex = moveCursorByWordLeft(value, cursorIndex);
+    const newValue = value.slice(0, newCursorIndex) + value.slice(cursorIndex);
+    return { newValue, newCursorIndex };
+}
 export function moveCursorByWordLeft(value, cursorIndex) {
     let idx = cursorIndex;
     // Skip trailing whitespace

package/dist/tui/utils/polishGoal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * polishGoal — Pure utility functions for generating a polished, imperative
+ * single-sentence Goal line in the spec completion summary.
+ *
+ * No AI calls, no side-effects. Deterministic string transformations only.
+ */
+/**
+ * selectGoalSource — Choose the best source for the goal line from a
+ * structured set of candidates, applying the spec's 3-tier fallback chain:
+ *   1. AI recap (if non-empty/non-whitespace)
+ *   2. Key decisions (if non-empty/non-whitespace after normalisation)
+ *   3. User request (fallback)
+ *
+ * For `keyDecisions`, bullet prefixes are stripped and fragments joined with `; `.
+ */
+export declare function selectGoalSource(opts: {
+    aiRecap: string;
+    keyDecisions: string | string[];
+    userRequest: string;
+}): {
+    source: 'ai' | 'decisions' | 'user';
+    text: string;
+};
+/**
+ * polishGoalSentence — Transform any goal source text into a polished,
+ * imperative, single-sentence string ending with a period.
+ *
+ * Steps applied (all deterministic):
+ *  1. Whitespace normalization
+ *  2. Strip trailing ellipses
+ *  3. Remove leading framing phrases ("I want to …", "We will …", etc.)
+ *  4. Single-sentence enforcement (take first sentence)
+ *  5. Imperative verb enforcement (prepend "Implement " if needed)
+ *  6. Capitalise first letter
+ *  7. Ensure exactly one trailing period
+ */
+export declare function polishGoalSentence(text: string): string;

package/dist/tui/utils/polishGoal.js

@@ -0,0 +1,170 @@
+/**
+ * polishGoal — Pure utility functions for generating a polished, imperative
+ * single-sentence Goal line in the spec completion summary.
+ *
+ * No AI calls, no side-effects. Deterministic string transformations only.
+ */
+/** Allowed imperative verbs that may begin a polished goal sentence. */
+const IMPERATIVE_VERBS = [
+    'Implement',
+    'Add',
+    'Improve',
+    'Fix',
+    'Refactor',
+    'Support',
+    'Enable',
+    'Create',
+    'Update',
+    'Build',
+    'Extend',
+    'Migrate',
+    'Remove',
+    'Replace',
+    'Integrate',
+    'Define',
+    'Achieve',
+    'Allow',
+    'Complete',
+    'Configure',
+    'Deploy',
+    'Design',
+    'Ensure',
+    'Generate',
+    'Handle',
+    'Introduce',
+    'Make',
+    'Optimize',
+    'Provide',
+    'Redesign',
+    'Restructure',
+    'Set',
+    'Show',
+    'Use',
+];
+const IMPERATIVE_VERB_PATTERN = new RegExp(`^(${IMPERATIVE_VERBS.join('|')})\\b`, 'i');
+/** Leading framing-phrase patterns to strip/rewrite, each returning a cleaned fragment. */
+const FRAMING_PATTERNS = [
+    [/^i want to\s*/i, ''],
+    [/^i'd like to\s*/i, ''],
+    [/^i would like to\s*/i, ''],
+    [/^we will\s*/i, ''],
+    [/^we want to\s*/i, ''],
+    [/^we need to\s*/i, ''],
+    [/^you're\s+\w+ing\s+to\s*/i, ''],
+    [/^you'd like to\s*/i, ''],
+    [/^you want to\s*/i, ''],
+    [/^you need to\s*/i, ''],
+    [/^this spec covers\s*/i, ''],
+    [/^this spec describes\s*/i, ''],
+    [/^the goal is to\s*/i, ''],
+    // Handles normalizeRecap output like "To build …" (stripped "you want" prefix)
+    [/^to\s+/i, ''],
+];
+/** Strip bullet prefixes (`-`, `*`, `1.`, `•`) from a single line. */
+function stripBulletPrefix(line) {
+    return line.replace(/^(\s*[-*•]|\s*\d+[.)]\s*)\s*/, '').trim();
+}
+/** Collapse multi-space/newline whitespace to a single space and trim. */
+function normalizeWhitespace(text) {
+    return text.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+}
+/** Return true if this part looks like an abbreviation fragment (e.g. "e.g", "i.e", "vs"). */
+function looksLikeAbbreviation(fragment) {
+    return /^(e\.g|i\.e|etc|vs|mr|mrs|dr|prof|no|vol|fig|ch|approx|est)$/i.test(fragment.trim());
+}
+/**
+ * Enforce single-sentence: split conservatively on `. ` boundaries, skipping
+ * abbreviation-like fragments, then return only the first sentence.
+ */
+function toOneSentence(text) {
+    // Split on ". " followed by an uppercase letter — conservative heuristic
+    const parts = text.split(/(?<=\b\w{3,})\. (?=[A-Z])/);
+    if (parts.length <= 1)
+        return text;
+    // Take first part only
+    const first = parts[0];
+    // Guard against abbreviations causing false splits
+    if (looksLikeAbbreviation(first))
+        return text;
+    return first;
+}
+/**
+ * selectGoalSource — Choose the best source for the goal line from a
+ * structured set of candidates, applying the spec's 3-tier fallback chain:
+ *   1. AI recap (if non-empty/non-whitespace)
+ *   2. Key decisions (if non-empty/non-whitespace after normalisation)
+ *   3. User request (fallback)
+ *
+ * For `keyDecisions`, bullet prefixes are stripped and fragments joined with `; `.
+ */
+export function selectGoalSource(opts) {
+    const { aiRecap, keyDecisions, userRequest } = opts;
+    // 1. AI recap
+    const normalizedAi = normalizeWhitespace(aiRecap);
+    if (normalizedAi.length > 0) {
+        return { source: 'ai', text: normalizedAi };
+    }
+    // 2. Key decisions
+    const decisionsArr = Array.isArray(keyDecisions)
+        ? keyDecisions
+        : keyDecisions
+            ? [keyDecisions]
+            : [];
+    const cleanedDecisions = decisionsArr
+        .map((d) => stripBulletPrefix(normalizeWhitespace(d)))
+        .filter((d) => d.length > 0);
+    if (cleanedDecisions.length > 0) {
+        const joined = cleanedDecisions.join('; ');
+        return { source: 'decisions', text: joined };
+    }
+    // 3. User request
+    return { source: 'user', text: normalizeWhitespace(userRequest) };
+}
+/**
+ * polishGoalSentence — Transform any goal source text into a polished,
+ * imperative, single-sentence string ending with a period.
+ *
+ * Steps applied (all deterministic):
+ *  1. Whitespace normalization
+ *  2. Strip trailing ellipses
+ *  3. Remove leading framing phrases ("I want to …", "We will …", etc.)
+ *  4. Single-sentence enforcement (take first sentence)
+ *  5. Imperative verb enforcement (prepend "Implement " if needed)
+ *  6. Capitalise first letter
+ *  7. Ensure exactly one trailing period
+ */
+export function polishGoalSentence(text) {
+    if (!text || text.trim().length === 0) {
+        return 'Implement the requested feature.';
+    }
+    // 1. Whitespace normalization
+    let result = normalizeWhitespace(text);
+    // 2. Strip trailing ellipses
+    result = result.replace(/\.{2,}$/, '').replace(/…$/, '').trim();
+    // 3. Remove leading framing phrases iteratively (apply first matching pattern)
+    for (const [pattern, replacement] of FRAMING_PATTERNS) {
+        if (pattern.test(result)) {
+            result = result.replace(pattern, replacement).trim();
+            break;
+        }
+    }
+    // Guard: if stripping left nothing (e.g. "I want to" with no continuation)
+    if (result.length === 0) {
+        return 'Implement the requested feature.';
+    }
+    // 4. Single-sentence enforcement
+    result = toOneSentence(result);
+    // Strip any trailing sentence-ending punctuation before we add our own
+    result = result.replace(/[.!?]+$/, '').trim();
+    // 5. Imperative verb enforcement
+    if (!IMPERATIVE_VERB_PATTERN.test(result)) {
+        // Lowercase first char before prepending to avoid "Implement The thing"
+        result = result.charAt(0).toLowerCase() + result.slice(1);
+        result = `Implement ${result}`;
+    }
+    // 6. Capitalize first letter
+    result = result.charAt(0).toUpperCase() + result.slice(1);
+    // 7. Ensure exactly one trailing period
+    result = `${result}.`;
+    return result;
+}

package/dist/tui/utils/pr-summary.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PR and Issue utilities for enhanced run summary.
+ */
+export interface PrInfo {
+    number: number;
+    url: string;
+    state: string;
+    title: string;
+}
+export interface IssueInfo {
+    number: number;
+    url: string;
+    state: string;
+    title: string;
+}
+/**
+ * Get PR information for a branch.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @returns PR info object, or null if no PR exists for this branch
+ * @throws When gh CLI is unavailable or the command fails
+ */
+export declare function getPrForBranch(projectRoot: string, branchName: string): PrInfo | null;
+/**
+ * Get linked issue for a branch by parsing the PR body for closing keywords
+ * (Closes/Fixes/Resolves #N).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @param prInfo - Optional pre-fetched PR info to avoid redundant gh call
+ * @returns Issue info object, or null if not found or gh not available
+ */
+export declare function getLinkedIssue(projectRoot: string, branchName: string, prInfo?: PrInfo | null): IssueInfo | null;

package/dist/tui/utils/pr-summary.js

@@ -0,0 +1,84 @@
+/**
+ * PR and Issue utilities for enhanced run summary.
+ */
+import { execFileSync } from 'node:child_process';
+import { logger } from '../../utils/logger.js';
+/**
+ * Get PR information for a branch.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @returns PR info object, or null if no PR exists for this branch
+ * @throws When gh CLI is unavailable or the command fails
+ */
+export function getPrForBranch(projectRoot, branchName) {
+    // Use gh pr list to find PR for this branch
+    const output = execFileSync('gh', ['pr', 'list', '--head', branchName, '--state', 'all', '--json', 'number,url,state,title', '--limit', '1'], {
+        cwd: projectRoot,
+        encoding: 'utf-8',
+        timeout: 10_000,
+    }).trim();
+    if (!output) {
+        return null;
+    }
+    const prs = JSON.parse(output);
+    if (!Array.isArray(prs) || prs.length === 0) {
+        return null;
+    }
+    const pr = prs[0];
+    return {
+        number: pr.number,
+        url: pr.url,
+        state: pr.state,
+        title: pr.title,
+    };
+}
+/**
+ * Get linked issue for a branch by parsing the PR body for closing keywords
+ * (Closes/Fixes/Resolves #N).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @param prInfo - Optional pre-fetched PR info to avoid redundant gh call
+ * @returns Issue info object, or null if not found or gh not available
+ */
+export function getLinkedIssue(projectRoot, branchName, prInfo) {
+    try {
+        // Use provided PR info or fetch it
+        const pr = prInfo !== undefined ? prInfo : getPrForBranch(projectRoot, branchName);
+        if (!pr) {
+            return null;
+        }
+        // Get the PR body to look for issue references
+        const prBody = execFileSync('gh', ['pr', 'view', String(pr.number), '--json', 'body'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        const prData = JSON.parse(prBody);
+        const body = prData.body || '';
+        // Look for issue references in PR body (e.g., "Closes #123", "Fixes #456")
+        const issueMatch = body.match(/(?:closes|fixes|resolves)\s+#(\d+)/i);
+        if (!issueMatch) {
+            return null;
+        }
+        const issueNumber = parseInt(issueMatch[1], 10);
+        // Fetch the issue details
+        const issueOutput = execFileSync('gh', ['issue', 'view', String(issueNumber), '--json', 'number,url,state,title'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        const issue = JSON.parse(issueOutput);
+        return {
+            number: issue.number,
+            url: issue.url,
+            state: issue.state,
+            title: issue.title,
+        };
+    }
+    catch (err) {
+        logger.warn(`getLinkedIssue failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/utils/config.d.ts

@@ -48,7 +48,7 @@ export interface LoopConfig {
     maxE2eAttempts: number;
     defaultModel: string;
     planningModel: string;
-    reviewMode: 'manual' | 'auto';
+    reviewMode: 'manual' | 'auto' | 'merge';
 }
 /**
  * Full ralph.config.cjs structure

package/dist/utils/fuzzy-match.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if all characters in `query` appear in `target` in order
+ * (case-insensitive). An empty query always matches.
+ */
+export declare function fuzzyMatch(query: string, target: string): boolean;

package/dist/utils/fuzzy-match.js

@@ -0,0 +1,16 @@
+/**
+ * Returns true if all characters in `query` appear in `target` in order
+ * (case-insensitive). An empty query always matches.
+ */
+export function fuzzyMatch(query, target) {
+    if (query.length === 0)
+        return true;
+    const q = query.toLowerCase();
+    const t = target.toLowerCase();
+    let qi = 0;
+    for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+        if (t[ti] === q[qi])
+            qi++;
+    }
+    return qi === q.length;
+}

package/dist/utils/spec-names.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads top-level .md files from the given directory and returns their names
+ * without the .md extension, sorted alphabetically.
+ * Returns an empty array if the directory does not exist or is unreadable.
+ */
+export declare function listSpecNames(specsDir: string): Promise<string[]>;

package/dist/utils/spec-names.js

@@ -0,0 +1,23 @@
+import { readdir } from 'node:fs/promises';
+import { logger } from './logger.js';
+/**
+ * Reads top-level .md files from the given directory and returns their names
+ * without the .md extension, sorted alphabetically.
+ * Returns an empty array if the directory does not exist or is unreadable.
+ */
+export async function listSpecNames(specsDir) {
+    let entries;
+    try {
+        entries = await readdir(specsDir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {
+            logger.debug(`Failed to list spec names from ${specsDir}: ${err.message}`);
+        }
+        return [];
+    }
+    return entries
+        .filter((e) => e.isFile() && e.name.endsWith('.md'))
+        .map((e) => e.name.slice(0, -3))
+        .sort();
+}

package/dist/utils/summary-file.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Summary File Writer
+ * Persists enhanced run summaries to JSON files for later retrieval
+ */
+import type { RunSummary } from '../tui/screens/RunScreen.js';
+/**
+ * Write enhanced run summary to a JSON file in the temp directory
+ *
+ * @param featureName - The feature name used to construct the file path
+ * @param summary - The complete RunSummary object to persist
+ * @returns Promise that resolves when the file is written, or rejects on error
+ *
+ * Uses RALPH_SUMMARY_TMP_DIR environment variable if set, otherwise os.tmpdir().
+ *
+ * @example
+ * ```ts
+ * await writeRunSummaryFile('my-feature', {
+ *   feature: 'my-feature',
+ *   exitCode: 0,
+ *   // ... other RunSummary fields
+ * });
+ * // Writes to: <tmpdir>/ralph-loop-my-feature.summary.json
+ * ```
+ */
+export declare function writeRunSummaryFile(featureName: string, summary: RunSummary): Promise<void>;

package/dist/utils/summary-file.js

@@ -0,0 +1,37 @@
+/**
+ * Summary File Writer
+ * Persists enhanced run summaries to JSON files for later retrieval
+ */
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { logger } from './logger.js';
+/**
+ * Write enhanced run summary to a JSON file in the temp directory
+ *
+ * @param featureName - The feature name used to construct the file path
+ * @param summary - The complete RunSummary object to persist
+ * @returns Promise that resolves when the file is written, or rejects on error
+ *
+ * Uses RALPH_SUMMARY_TMP_DIR environment variable if set, otherwise os.tmpdir().
+ *
+ * @example
+ * ```ts
+ * await writeRunSummaryFile('my-feature', {
+ *   feature: 'my-feature',
+ *   exitCode: 0,
+ *   // ... other RunSummary fields
+ * });
+ * // Writes to: <tmpdir>/ralph-loop-my-feature.summary.json
+ * ```
+ */
+export async function writeRunSummaryFile(featureName, summary) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(featureName)) {
+        throw new Error(`Invalid feature name: "${featureName}"`);
+    }
+    const dir = process.env.RALPH_SUMMARY_TMP_DIR ?? tmpdir();
+    const filePath = join(dir, `ralph-loop-${featureName}.summary.json`);
+    const jsonContent = JSON.stringify(summary, null, 2);
+    await writeFile(filePath, jsonContent, 'utf8');
+    logger.debug(`Summary written to ${filePath}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiggum-cli",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "AI-powered feature development loop CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -26,11 +26,16 @@
   },
   "keywords": [
     "cli",
-    "ai",
-    "development",
-    "automation",
+    "ai-agent",
+    "autonomous-coding",
+    "ralph-loop",
+    "spec-generation",
+    "claude-code",
+    "codex",
+    "ai-coding",
     "feature-loop",
     "code-generation",
+    "developer-tools",
     "tech-stack-detection"
   ],
   "repository": {

package/src/templates/config/ralph.config.cjs.tmpl

@@ -34,6 +34,6 @@ module.exports = {
     maxE2eAttempts: 5,
     defaultModel: 'sonnet',
     planningModel: 'opus',
-    reviewMode: 'manual', // 'manual' = stop at PR, 'auto' = review + auto-merge
+    reviewMode: 'manual', // 'manual' = stop at PR, 'auto' = review (no merge), 'merge' = review + auto-merge
   },
 };