bueller-wheel 0.3.0 → 0.3.1

package/dist/issue-reader.js

@@ -0,0 +1,92 @@
+import * as fs from 'node:fs/promises';
+/**
+ * Parses an issue markdown file and extracts the conversation history
+ *
+ * @param filePath - Absolute path to the issue file
+ * @returns Parsed issue with message history
+ * @throws Error if file cannot be read or if the format is invalid
+ */
+export async function readIssue(filePath) {
+    let rawContent;
+    try {
+        rawContent = await fs.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read issue file at ${filePath}: ${String(error)}`);
+    }
+    return parseIssueContent(rawContent);
+}
+/**
+ * Parses issue content and extracts the conversation history
+ *
+ * @param content - Raw markdown content of the issue file
+ * @returns Parsed issue with message history
+ */
+export function parseIssueContent(content) {
+    const messages = [];
+    // Split by the separator (---)
+    const sections = content.split(/\n---\n/);
+    let messageIndex = 0;
+    for (const section of sections) {
+        const trimmedSection = section.trim();
+        // Skip empty sections
+        if (!trimmedSection) {
+            continue;
+        }
+        // Check if this section starts with @user: or @claude:
+        const userMatch = trimmedSection.match(/^@user:\s*([\s\S]*)$/);
+        const claudeMatch = trimmedSection.match(/^@claude:\s*([\s\S]*)$/);
+        if (userMatch) {
+            messages.push({
+                index: messageIndex++,
+                author: 'user',
+                content: userMatch[1].trim(),
+            });
+        }
+        else if (claudeMatch) {
+            messages.push({
+                index: messageIndex++,
+                author: 'claude',
+                content: claudeMatch[1].trim(),
+            });
+        }
+        // If no match, skip this section (handles malformed sections)
+    }
+    return {
+        messages,
+        rawContent: content,
+    };
+}
+/**
+ * Gets the latest message from an issue
+ *
+ * @param issue - Parsed issue object
+ * @returns The most recent message, or undefined if no messages exist
+ */
+export function getLatestMessage(issue) {
+    if (issue.messages.length === 0) {
+        return undefined;
+    }
+    return issue.messages[issue.messages.length - 1];
+}
+/**
+ * Gets all messages from a specific author
+ *
+ * @param issue - Parsed issue object
+ * @param author - Author to filter by ('user' or 'claude')
+ * @returns Array of messages from the specified author
+ */
+export function getMessagesByAuthor(issue, author) {
+    return issue.messages.filter((msg) => msg.author === author);
+}
+/**
+ * Formats a message for appending to an issue file
+ *
+ * @param author - Author of the message ('user' or 'claude')
+ * @param content - Content of the message
+ * @returns Formatted message string ready to append to an issue file
+ */
+export function formatMessage(author, content) {
+    return `---\n\n@${author}: ${content}`;
+}
+//# sourceMappingURL=issue-reader.js.map

package/dist/issue-summarize.js

@@ -0,0 +1,236 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parseIssueContent } from './issue-reader.js';
+/**
+ * Searches for an issue file by filename across the issue directories
+ *
+ * @param filename - The issue filename (e.g., "p1-003-read-helper-002.md")
+ * @param issuesDir - Base issues directory
+ * @returns Located issue or null if not found
+ */
+export async function locateIssueFile(filename, issuesDir) {
+    const directories = [
+        { dir: path.join(issuesDir, 'open'), status: 'open' },
+        { dir: path.join(issuesDir, 'review'), status: 'review' },
+        { dir: path.join(issuesDir, 'stuck'), status: 'stuck' },
+    ];
+    for (const { dir, status } of directories) {
+        const filePath = path.join(dir, filename);
+        try {
+            await fs.access(filePath);
+            return {
+                filePath,
+                status,
+                filename,
+            };
+        }
+        catch {
+            // File doesn't exist in this directory, continue searching
+        }
+    }
+    return null;
+}
+/**
+ * Resolves an issue reference (either a full path or filename) to a located issue
+ *
+ * @param reference - File path or filename
+ * @param issuesDir - Base issues directory
+ * @returns Located issue or null if not found
+ */
+export async function resolveIssueReference(reference, issuesDir) {
+    // Check if it looks like a path (contains path separators)
+    if (reference.includes('/') || reference.includes('\\')) {
+        // Treat as a file path (absolute or relative)
+        const absolutePath = path.isAbsolute(reference) ? reference : path.resolve(reference);
+        try {
+            await fs.access(absolutePath);
+            // Determine status from path
+            let status = 'open';
+            if (absolutePath.includes('/review/')) {
+                status = 'review';
+            }
+            else if (absolutePath.includes('/stuck/')) {
+                status = 'stuck';
+            }
+            return {
+                filePath: absolutePath,
+                status,
+                filename: path.basename(absolutePath),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    // Otherwise, treat it as a filename and search for it
+    return locateIssueFile(reference, issuesDir);
+}
+/**
+ * Abbreviates a message based on its position in the conversation
+ *
+ * @param message - The message to abbreviate
+ * @param _position - Position in conversation ('first', 'middle', or 'last')
+ * @param maxLength - Maximum length for the abbreviated content
+ * @returns Abbreviated message
+ */
+function abbreviateMessage(message, _position, maxLength) {
+    const fullContent = message.content;
+    let abbreviated = fullContent;
+    let isAbbreviated = false;
+    if (fullContent.length > maxLength) {
+        abbreviated = fullContent.substring(0, maxLength).trimEnd() + '…';
+        isAbbreviated = true;
+    }
+    return {
+        index: message.index,
+        author: message.author,
+        content: abbreviated,
+        isAbbreviated,
+        fullContent,
+    };
+}
+/**
+ * Creates abbreviated messages from a parsed issue
+ *
+ * @param messages - Array of issue messages
+ * @returns Array of abbreviated messages
+ */
+function createAbbreviatedMessages(messages) {
+    if (messages.length === 0) {
+        return [];
+    }
+    if (messages.length === 1) {
+        // Single message - use 230 char limit
+        return [abbreviateMessage(messages[0], 'first', 230)];
+    }
+    const result = [];
+    // First message - 230 chars
+    result.push(abbreviateMessage(messages[0], 'first', 230));
+    // Middle messages - 70 chars
+    for (let i = 1; i < messages.length - 1; i++) {
+        result.push(abbreviateMessage(messages[i], 'middle', 70));
+    }
+    // Last message - 230 chars
+    result.push(abbreviateMessage(messages[messages.length - 1], 'last', 230));
+    return result;
+}
+/**
+ * Summarizes an issue file with abbreviated messages
+ *
+ * @param locatedIssue - Located issue information
+ * @returns Issue summary
+ */
+export async function summarizeIssue(locatedIssue) {
+    const content = await fs.readFile(locatedIssue.filePath, 'utf-8');
+    const parsed = parseIssueContent(content);
+    const abbreviatedMessages = createAbbreviatedMessages(parsed.messages);
+    return {
+        issue: locatedIssue,
+        abbreviatedMessages,
+        messageCount: parsed.messages.length,
+    };
+}
+/**
+ * Parses index specification (e.g., "3" or "1,3")
+ *
+ * @param indexSpec - Index specification string
+ * @returns Object with indices array and whether it's a single index, or null if invalid
+ */
+export function parseIndexSpec(indexSpec) {
+    const parts = indexSpec.split(',').map((s) => s.trim());
+    if (parts.length === 1) {
+        // Single index
+        const index = parseInt(parts[0], 10);
+        if (isNaN(index) || index < 0) {
+            return null;
+        }
+        return { indices: [index], isSingleIndex: true };
+    }
+    if (parts.length === 2) {
+        // Range
+        const start = parseInt(parts[0], 10);
+        const end = parseInt(parts[1], 10);
+        if (isNaN(start) || isNaN(end) || start < 0 || end < start) {
+            return null;
+        }
+        const indices = [];
+        for (let i = start; i <= end; i++) {
+            indices.push(i);
+        }
+        return { indices, isSingleIndex: false };
+    }
+    return null;
+}
+/**
+ * Expands specific messages in a summary based on index specification
+ *
+ * @param summary - Issue summary
+ * @param indexSpec - Index specification (e.g., "3" or "1,3")
+ * @returns New summary with expanded messages and filter info
+ */
+export function expandMessages(summary, indexSpec) {
+    const parsed = parseIndexSpec(indexSpec);
+    if (!parsed) {
+        return summary;
+    }
+    const { indices, isSingleIndex } = parsed;
+    const expandedMessages = summary.abbreviatedMessages.map((msg) => {
+        if (indices.includes(msg.index)) {
+            return {
+                ...msg,
+                content: msg.fullContent,
+                isAbbreviated: false,
+            };
+        }
+        return msg;
+    });
+    return {
+        ...summary,
+        abbreviatedMessages: expandedMessages,
+        filterToIndices: indices,
+        isSingleIndex,
+    };
+}
+/**
+ * Condenses text by trimming lines and replacing newlines with single spaces
+ *
+ * @param text - Text to condense
+ * @returns Condensed text
+ */
+function condenseText(text) {
+    return text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .join(' ');
+}
+/**
+ * Formats an issue summary for console output
+ *
+ * @param summary - Issue summary (may include filterToIndices and isSingleIndex)
+ * @param indexSpec - Optional index specification for filtering display
+ * @returns Formatted string
+ */
+export function formatIssueSummary(summary, indexSpec) {
+    const lines = [];
+    // Header
+    const directory = `${summary.issue.status}/`;
+    const filename = summary.issue.filename;
+    lines.push(`${directory}${filename}`);
+    // Determine which messages to show
+    const messagesToShow = summary.filterToIndices
+        ? summary.abbreviatedMessages.filter((msg) => summary.filterToIndices.includes(msg.index))
+        : summary.abbreviatedMessages;
+    // Messages
+    for (const msg of messagesToShow) {
+        const content = msg.isAbbreviated ? condenseText(msg.content) : msg.content;
+        lines.push(`[${msg.index}] @${msg.author}: ${content}`);
+    }
+    // Add follow-up action hint if not showing specific indices
+    if (!indexSpec || !summary.isSingleIndex) {
+        lines.push('');
+        lines.push('Pass `--index N` or `--index M,N` to see more.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=issue-summarize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bueller-wheel",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"description": "Headless Claude Code issue processor - A wrapper that runs Claude Code in a loop to process issues from a directory queue",
 	"type": "module",
 	"main": "dist/index.js",
@@ -8,7 +8,7 @@
 		"bueller-wheel": "dist/index.js"
 	},
 	"scripts": {
-		"build": "rm -rf dist out && tsc && mkdir -p dist && cp out/src/index.js dist/index.js && echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.tmp && mv dist/index.tmp dist/index.js && chmod +x dist/index.js",
+		"build": "rm -rf dist out && tsc && mkdir -p dist && cp out/src/*.js dist/ && echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.tmp && mv dist/index.tmp dist/index.js && chmod +x dist/index.js",
 		"dev": "tsx src/index.ts",
 		"start": "node dist/index.js",
 		"test": "tsx tests/test-runner.ts",
@@ -37,7 +37,7 @@
 	},
 	"homepage": "https://github.com/fongandrew/bueller-wheel#readme",
 	"files": [
-		"dist/index.js",
+		"dist/*.js",
 		"README.md",
 		"LICENSE"
 	],