pi-harness-runtime 0.10.13 → 0.10.15

package/packages/todo-bd-sync/src/sync.js

@@ -0,0 +1,289 @@
+/**
+ * Two-way sync between rpiv-todo and bd
+ *
+ * This module handles:
+ * 1. rpiv-todo → bd: When todo tool is called, sync to bd
+ * 2. bd → rpiv-todo: When bd commands are executed, sync to todo
+ * 3. Session start: Load existing bd issues into todo
+ */
+import { execSync } from "node:child_process";
+import { IdMappingRegistry, STATUS_MAP } from "./types.js";
+// Mapping registry singleton
+const mappingRegistry = new IdMappingRegistry();
+/**
+ * Execute a bd command and return the output
+ */
+export function execBdCommand(command) {
+    try {
+        return execSync(command, {
+            encoding: "utf8",
+            timeout: 10000,
+            cwd: process.cwd(),
+        });
+    }
+    catch (error) {
+        const err = error;
+        return err.stderr || err.message || "";
+    }
+}
+/**
+ * Extract bd ID from command or output
+ */
+export function extractBdId(input) {
+    // Match patterns like: bd-a1b2, bd-a1b2.1, BD-a1b2, etc.
+    const match = input.match(/bd-[a-z0-9]+(\.[0-9]+)?/i);
+    return match ? match[0].toLowerCase() : null;
+}
+/**
+ * Get all open bd issues
+ */
+export function getOpenBdIssues() {
+    try {
+        const output = execBdCommand("bd ready --json");
+        const issues = JSON.parse(output);
+        return issues.map((issue) => ({
+            id: issue.id,
+            title: issue.title,
+            status: issue.status,
+            priority: issue.priority,
+            createdAt: issue.created_at,
+            updatedAt: issue.updated_at,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get all bd issues (including closed)
+ */
+export function getAllBdIssues() {
+    try {
+        const output = execBdCommand("bd list --json");
+        const issues = JSON.parse(output);
+        return issues.map((issue) => ({
+            id: issue.id,
+            title: issue.title,
+            status: issue.status,
+            priority: issue.priority,
+            createdAt: issue.created_at,
+            updatedAt: issue.updated_at,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Create a bd issue from a todo task
+ */
+export function createBdFromTodo(task) {
+    const priority = inferPriorityFromTask(task);
+    try {
+        const command = `bd create "${escapeShell(task.subject)}" -p ${priority} --json`;
+        const output = execBdCommand(command);
+        // Try to extract bd ID from output
+        let bdId = extractBdId(output);
+        // If not found in output, try to get it from the created issue
+        if (!bdId) {
+            const issues = getOpenBdIssues();
+            // Match by title (not ideal but fallback)
+            const match = issues.find((i) => i.title === task.subject);
+            bdId = match?.id || null;
+        }
+        if (bdId) {
+            mappingRegistry.set(task.id, bdId);
+        }
+        return {
+            success: true,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            bdId: bdId || undefined,
+            action: "create",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            action: "create",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Update a bd issue from a todo task update
+ */
+export function updateBdFromTodo(task) {
+    const mapping = mappingRegistry.getByTodoId(task.id);
+    if (!mapping) {
+        // No mapping exists, create new bd issue
+        return createBdFromTodo(task);
+    }
+    try {
+        const bdStatus = STATUS_MAP[task.status];
+        const command = `bd update ${mapping.bdId} --status ${bdStatus} --json`;
+        execBdCommand(command);
+        // Update last sync timestamp
+        mappingRegistry.updateLastSync(task.id);
+        return {
+            success: true,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            bdId: mapping.bdId,
+            action: "update",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            bdId: mapping.bdId,
+            action: "update",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Close/delete a bd issue when todo is deleted
+ */
+export function closeBdFromTodo(task) {
+    const mapping = mappingRegistry.getByTodoId(task.id);
+    if (!mapping) {
+        return {
+            success: true, // Nothing to close
+            direction: "todo_to_bd",
+            taskId: task.id,
+            action: "delete",
+        };
+    }
+    try {
+        const command = `bd close ${mapping.bdId} --reason "Closed from todo" --json`;
+        execBdCommand(command);
+        // Remove mapping
+        mappingRegistry.delete(task.id);
+        return {
+            success: true,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            bdId: mapping.bdId,
+            action: "delete",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            direction: "todo_to_bd",
+            taskId: task.id,
+            bdId: mapping.bdId,
+            action: "delete",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Infer priority from task metadata
+ */
+function inferPriorityFromTask(task) {
+    if (task.metadata?.priority !== undefined) {
+        return task.metadata.priority;
+    }
+    // Default priority 2 (medium)
+    return 2;
+}
+/**
+ * Parse bd create output to extract created issue
+ */
+export function parseBdCreateOutput(output) {
+    try {
+        const json = JSON.parse(output);
+        if (json.id) {
+            return {
+                bdId: json.id,
+                title: json.title || "",
+            };
+        }
+    }
+    catch {
+        // Not JSON, try text extraction
+    }
+    const bdId = extractBdId(output);
+    if (bdId) {
+        return { bdId, title: "" };
+    }
+    return null;
+}
+/**
+ * Detect if a bash command is a bd command
+ */
+export function isBdCommand(command) {
+    const trimmed = command.trim().toLowerCase();
+    return (trimmed.startsWith("bd ") ||
+        trimmed.startsWith("beads ") ||
+        trimmed.includes("bd create") ||
+        trimmed.includes("bd update") ||
+        trimmed.includes("bd close") ||
+        trimmed.includes("bd ready") ||
+        trimmed.includes("bd list"));
+}
+/**
+ * Extract bd ID from a command
+ */
+export function extractBdIdFromCommand(command) {
+    return extractBdId(command);
+}
+/**
+ * Get the mapping registry for external access
+ */
+export function getMappingRegistry() {
+    return mappingRegistry;
+}
+/**
+ * Clear all mappings (for testing or reset)
+ */
+export function clearMappings() {
+    mappingRegistry.clear();
+}
+/**
+ * Escape shell arguments
+ */
+function escapeShell(str) {
+    // Escape double quotes and backslashes
+    return str.replace(/["\\]/g, "\\$&");
+}
+/**
+ * Sync from todo action to bd
+ * Called when todo tool is executed
+ */
+export function syncTodoToBd(action, task) {
+    switch (action) {
+        case "create":
+            return createBdFromTodo(task);
+        case "update":
+            return updateBdFromTodo(task);
+        case "delete":
+            return closeBdFromTodo(task);
+        default:
+            return {
+                success: true,
+                direction: "todo_to_bd",
+                taskId: task.id,
+                action,
+            };
+    }
+}
+/**
+ * Parse todo task from tool event
+ * This is a simplified parser - actual implementation depends on event structure
+ */
+export function parseTodoTaskFromEvent(event) {
+    // The event structure depends on how pi-coding-agent exposes it
+    // This is a placeholder - actual implementation needs event inspection
+    const task = event.task;
+    if (!task || typeof task.id !== "number") {
+        return null;
+    }
+    return task;
+}

package/packages/todo-bd-sync/src/task-analyzer.js

@@ -0,0 +1,239 @@
+/**
+ * Smart Auto-Todo Task Analyzer
+ *
+ * Decides when to automatically create bd issues based on:
+ * 1. Task complexity signals
+ * 2. Session state (pending task count)
+ *
+ * Philosophy:
+ * - Simple tasks (grep, quick edit) -> NO todo (avoid noise)
+ * - Complex tasks OR multiple pending tasks -> AUTO-CREATE todo
+ */
+import { getOpenBdIssues } from "./sync.js";
+const COMPLEX_KEYWORDS = [
+    "complicated",
+    "complex",
+    "tricky",
+    "difficult",
+    "refactor",
+    "architecture",
+    "design",
+    "implement from scratch",
+    "rewrite",
+    "investigate",
+    "debug",
+    "fix the bug",
+    "performance",
+];
+const RESEARCH_KEYWORDS = [
+    "search",
+    "look up",
+    "find",
+    "research",
+    "check",
+    "verify",
+    "how to",
+    "best practice",
+    "compare",
+    "evaluate",
+    "review",
+];
+const SUBTASK_KEYWORDS = [
+    "also",
+    "plus",
+    "and also",
+    "while you're at it",
+    "on top of that",
+    "additionally",
+    "another thing",
+    "don't forget",
+    "should also",
+];
+/**
+ * Analyze user request text for complexity signals
+ */
+export function analyzeTaskSignals(userMessage) {
+    const lower = userMessage.toLowerCase();
+    // Count implied steps from action verbs
+    const actionVerbs = [
+        "create",
+        "build",
+        "implement",
+        "design",
+        "setup",
+        "configure",
+        "migrate",
+        "convert",
+        "refactor",
+        "optimize",
+        "fix",
+        "update",
+        "add",
+        "remove",
+        "delete",
+        "modify",
+        "change",
+        "replace",
+    ];
+    const stepCount = Math.max(1, actionVerbs.filter((v) => lower.includes(v)).length);
+    // Estimate file count from file paths and extensions
+    const filePatterns = /[\w-]+\.(ts|js|py|json|md|yaml|yml|tsx|jsx|html|css|sql)/g;
+    const fileMatches = userMessage.match(filePatterns) || [];
+    const explicitFiles = fileMatches.length;
+    // Check for directory patterns
+    const dirPatterns = /(?:src|lib|packages|apps|components|hooks|utils|api)\/[\w/-]+/g;
+    const dirMatches = userMessage.match(dirPatterns) || [];
+    // Count "and", "also", "+" for multi-task indicators
+    const multiTaskIndicator = (lower.match(/and also|also|\+/g) || []).length;
+    const estimatedFiles = Math.max(1, explicitFiles + dirMatches.length + multiTaskIndicator);
+    return {
+        stepCount,
+        fileCount: estimatedFiles,
+        needsResearch: RESEARCH_KEYWORDS.some((k) => lower.includes(k)),
+        createsFiles: lower.includes("create") ||
+            lower.includes("add") ||
+            lower.includes("new"),
+        explicitlyComplex: COMPLEX_KEYWORDS.some((k) => lower.includes(k)),
+        likelySubtasks: SUBTASK_KEYWORDS.some((k) => lower.includes(k)) ||
+            multiTaskIndicator >= 2,
+    };
+}
+/**
+ * Decide whether to auto-create a todo for the given task
+ */
+export function decideAutoTodo(userMessage, options = {}) {
+    const signals = analyzeTaskSignals(userMessage);
+    const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
+    const pendingCount = pendingTasks.length;
+    // ── Skip Conditions ────────────────────────────────────────────────────
+    // Never create todos for these
+    const simplePatterns = [
+        /^simply\s/i,
+        /^just\s/i,
+        /^quick\s/i,
+        /^can you\s+(grep|find|cat|ls|echo)/i,
+        /^(grep|find|cat|ls)\s+[\w.-]+/i,
+        /^what('s| is) the\s+\w+\s+\?$/i,
+        /^how do i\s+\w+\s*\?$/i,
+    ];
+    if (simplePatterns.some((p) => p.test(userMessage.trim()))) {
+        return {
+            shouldCreate: false,
+            reason: "Simple request (lookup/one-liner)",
+            confidence: "high",
+            skipReason: "Task is too simple to warrant tracking",
+        };
+    }
+    // Check for trivial single actions with no complexity (lower threshold)
+    // Allow more tasks to be tracked - being conservative about NOT tracking
+    const isTrivial = signals.stepCount === 1 &&
+        signals.fileCount <= 1 &&
+        !signals.needsResearch &&
+        !signals.createsFiles &&
+        !signals.explicitlyComplex &&
+        pendingCount === 0 &&
+        !signals.likelySubtasks;
+    if (isTrivial) {
+        return {
+            shouldCreate: false,
+            reason: "Trivial request (single action)",
+            confidence: "high",
+            skipReason: "Task is trivial",
+        };
+    }
+    // ── Force Modes ──────────────────────────────────────────────────────
+    if (options.forceMode) {
+        return {
+            shouldCreate: true,
+            reason: "Force mode enabled",
+            confidence: "high",
+        };
+    }
+    if (options.skipMode) {
+        return {
+            shouldCreate: false,
+            reason: "Skip mode enabled",
+            confidence: "high",
+            skipReason: "User requested skip",
+        };
+    }
+    // ── Auto-Create Conditions ──────────────────────────────────────────
+    // Be MORE aggressive about tracking tasks - default to tracking
+    const reasons = [];
+    // HIGH CONFIDENCE: Task explicitly complex
+    if (signals.explicitlyComplex) {
+        reasons.push("explicitly complex");
+    }
+    // HIGH CONFIDENCE: Multiple steps (lower from 3 to 2)
+    if (signals.stepCount >= 2) {
+        reasons.push(`${signals.stepCount} steps implied`);
+    }
+    // HIGH CONFIDENCE: Multiple files (lower from 3 to 2)
+    if (signals.fileCount >= 2) {
+        reasons.push(`${signals.fileCount} files involved`);
+    }
+    // MEDIUM CONFIDENCE: Research needed
+    if (signals.needsResearch) {
+        reasons.push("needs research");
+    }
+    // MEDIUM CONFIDENCE: Creates files
+    if (signals.createsFiles) {
+        reasons.push("creates files");
+    }
+    // MEDIUM CONFIDENCE: Likely subtasks
+    if (signals.likelySubtasks) {
+        reasons.push("likely has subtasks");
+    }
+    // MEDIUM CONFIDENCE: Has pending tasks already (session busy)
+    if (pendingCount >= 1) {
+        reasons.push(`${pendingCount} pending tasks`);
+    }
+    // Default to creating todo if any signal present
+    // Be conservative only for truly trivial requests (already filtered above)
+    if (reasons.length === 0) {
+        // No strong signals but not trivial either - track it anyway
+        reasons.push("multi-step task detected");
+    }
+    // Create todo if ANY reason OR any pending tasks
+    const shouldCreate = reasons.length >= 1 || pendingCount >= 1;
+    return {
+        shouldCreate,
+        reason: reasons.join(", "),
+        confidence: reasons.length >= 2 ? "high" : "medium",
+    };
+}
+// ─── Quick Score ─────────────────────────────────────────────────────────────
+/**
+ * Quick numeric score (0-100) for task complexity
+ * Higher = more likely to need a todo
+ */
+export function getTaskComplexityScore(userMessage) {
+    const signals = analyzeTaskSignals(userMessage);
+    const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
+    let score = 0;
+    // Step count (0-25)
+    score += Math.min(25, signals.stepCount * 8);
+    // File count (0-20)
+    score += Math.min(20, signals.fileCount * 5);
+    // Research needed (0-15)
+    if (signals.needsResearch)
+        score += 15;
+    // Creates files (0-10)
+    if (signals.createsFiles)
+        score += 10;
+    // Explicitly complex (0-20)
+    if (signals.explicitlyComplex)
+        score += 20;
+    // Likely subtasks (0-10)
+    if (signals.likelySubtasks)
+        score += 10;
+    // Pending task overload (0-25)
+    const pendingCount = pendingTasks.length;
+    if (pendingCount >= 3)
+        score += 25;
+    else if (pendingCount >= 2)
+        score += 15;
+    else if (pendingCount >= 1)
+        score += 5;
+    return Math.min(100, score);
+}

package/packages/todo-bd-sync/src/types.js

@@ -0,0 +1,66 @@
+/**
+ * Types for todo-bd-sync
+ * Two-way sync between rpiv-todo overlay and bd issue tracker
+ */
+// Registry of ID mappings
+export class IdMappingRegistry {
+    mappings = new Map(); // todoId -> mapping
+    bdMappings = new Map(); // bdId -> todoId
+    set(todoId, bdId) {
+        const now = Date.now();
+        const mapping = {
+            todoId,
+            bdId,
+            createdAt: now,
+            lastSync: now,
+        };
+        this.mappings.set(todoId, mapping);
+        this.bdMappings.set(bdId, todoId);
+    }
+    getByTodoId(todoId) {
+        return this.mappings.get(todoId);
+    }
+    getByBdId(bdId) {
+        const todoId = this.bdMappings.get(bdId);
+        return todoId !== undefined ? this.mappings.get(todoId) : undefined;
+    }
+    hasTodoId(todoId) {
+        return this.mappings.has(todoId);
+    }
+    hasBdId(bdId) {
+        return this.bdMappings.has(bdId);
+    }
+    updateLastSync(todoId) {
+        const mapping = this.mappings.get(todoId);
+        if (mapping) {
+            mapping.lastSync = Date.now();
+        }
+    }
+    delete(todoId) {
+        const mapping = this.mappings.get(todoId);
+        if (mapping) {
+            this.bdMappings.delete(mapping.bdId);
+            this.mappings.delete(todoId);
+        }
+    }
+    getAll() {
+        return Array.from(this.mappings.values());
+    }
+    clear() {
+        this.mappings.clear();
+        this.bdMappings.clear();
+    }
+}
+// Status mapping between todo and bd
+export const STATUS_MAP = {
+    pending: "open",
+    in_progress: "in_progress",
+    completed: "closed",
+    deleted: "closed",
+};
+export const BD_STATUS_MAP = {
+    open: "pending",
+    in_progress: "in_progress",
+    closed: "completed",
+    blocked: "pending",
+};

package/packages/token-estimation/src/index.js

@@ -0,0 +1,114 @@
+/**
+ * Token Estimation
+ *
+ * Rough token counting for messages and text.
+ * Used for context window management before API calls.
+ */
+/**
+ * Rough token count estimation — conservative (overestimates slightly).
+ * Based on average ~3.8 chars/token for English text.
+ */
+export function roughTokenCount(text) {
+    if (!text || text.length === 0)
+        return 0;
+    // Count words as proxy for tokens (more accurate for mixed content)
+    const words = text.trim().split(/\s+/).length;
+    // Average English token ~1.3 words, overhead for JSON structure
+    return Math.ceil(text.length / 3.5) + Math.ceil(words * 0.3);
+}
+/**
+ * Rough token count for a structured message.
+ * Handles role, content, tool_calls, tool_results, thinking blocks.
+ */
+export function roughMessageTokens(msg) {
+    if (!msg)
+        return 0;
+    let tokens = 0;
+    // Role overhead: ~4 tokens per message
+    tokens += 4;
+    // Content
+    if (typeof msg.content === "string") {
+        tokens += roughTokenCount(msg.content);
+    }
+    else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+                tokens += roughTokenCount(block.text);
+            }
+            else if (block.type === "tool_use" && block.name) {
+                // Tool name + JSON input
+                tokens += roughTokenCount(block.name);
+                if (block.input) {
+                    tokens += roughTokenCount(JSON.stringify(block.input));
+                }
+            }
+            else if (block.type === "tool_result") {
+                // Tool result: estimate 50 tokens overhead + content
+                tokens += 50;
+            }
+            else if (block.type === "image") {
+                // Image blocks: ~2000 tokens (Anthropic convention)
+                tokens += 2000;
+            }
+            else if (block.type === "thinking" && block.thinking) {
+                tokens += roughTokenCount(block.thinking);
+            }
+        }
+    }
+    // Tool calls (separate from content blocks)
+    if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+            tokens += roughTokenCount(tc.name);
+            if (tc.input) {
+                tokens += roughTokenCount(JSON.stringify(tc.input));
+            }
+        }
+    }
+    // Thinking blocks
+    if (msg.thinking) {
+        tokens += roughTokenCount(msg.thinking);
+    }
+    return tokens;
+}
+/**
+ * Rough token count for a full message array (API request format).
+ */
+export function roughMessagesTokens(messages) {
+    return messages.reduce((sum, msg) => sum + roughMessageTokens(msg), 0);
+}
+/**
+ * Estimate tokens for a system prompt string.
+ * System prompts typically have overhead from role markers.
+ */
+export function roughSystemPromptTokens(systemPrompt) {
+    // System message overhead (~15 tokens for role markers) + content
+    return 15 + roughTokenCount(systemPrompt);
+}
+/**
+ * Estimate tokens for tool definitions (schema).
+ */
+export function roughToolDefinitionTokens(tool) {
+    let tokens = roughTokenCount(tool.name);
+    if (tool.description) {
+        tokens += roughTokenCount(tool.description);
+    }
+    if (tool.input_schema) {
+        tokens += roughTokenCount(JSON.stringify(tool.input_schema));
+    }
+    return tokens;
+}
+export function estimateRequestTokens(systemPrompt, messages, tools, maxOutputTokens) {
+    const systemPromptTokens = roughSystemPromptTokens(systemPrompt);
+    const messagesTokens = roughMessagesTokens(messages);
+    const toolsTokens = tools.reduce((sum, tool) => sum + roughToolDefinitionTokens(tool), 0);
+    const total = systemPromptTokens + messagesTokens + toolsTokens;
+    const availableForContext = maxOutputTokens > 0 ? maxOutputTokens - total : 0;
+    return {
+        systemPrompt: systemPromptTokens,
+        messages: messagesTokens,
+        tools: toolsTokens,
+        total,
+        maxOutputTokens,
+        availableForContext,
+    };
+}