@adhdev/daemon-core 0.6.56 → 0.6.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.56",
+  "version": "0.6.58",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/providers/_builtin/cli/aider-cli/scripts/1.0/parse_output.js

@@ -35,13 +35,61 @@ function splitTurns(buffer) {
     return messages.length > 50 ? messages.slice(-50) : messages;
 }
 
+function mergeMessages(priorMessages, parsedMessages, status) {
+    const base = Array.isArray(priorMessages)
+        ? priorMessages
+            .filter(message => message && (message.role === 'user' || message.role === 'assistant'))
+            .map(message => ({
+                role: message.role,
+                content: typeof message.content === 'string' ? message.content : String(message.content || ''),
+                timestamp: message.timestamp,
+            }))
+        : [];
+    if (!parsedMessages.length) return base.map((message, index) => ({
+        id: `msg_${index}`,
+        role: message.role,
+        content: message.content,
+        index,
+        kind: 'standard',
+    }));
+
+    const latestAssistant = [...parsedMessages].reverse().find(message => message.role === 'assistant' && message.content);
+    if (!latestAssistant) {
+        return base.map((message, index) => ({
+            id: `msg_${index}`,
+            role: message.role,
+            content: message.content,
+            index,
+            kind: 'standard',
+        }));
+    }
+
+    const last = base[base.length - 1];
+    if (last && last.role === 'assistant') {
+        last.content = latestAssistant.content;
+    } else {
+        base.push({ role: 'assistant', content: latestAssistant.content });
+    }
+
+    return base.slice(-50).map((message, index, slice) => ({
+        id: `msg_${index}`,
+        role: message.role,
+        content: typeof message.content === 'string' ? message.content.slice(0, 6000) : '',
+        index,
+        kind: 'standard',
+        ...(status === 'generating' && index === slice.length - 1 && message.role === 'assistant'
+            ? { meta: { streaming: true } }
+            : {}),
+    }));
+}
+
 module.exports = function parseOutput(input) {
-    const { buffer, recentBuffer, partialResponse, screenText } = input;
-    const transcript = screenText || buffer;
+    const { buffer, recentBuffer, partialResponse, screenText, messages: priorMessages } = input;
+    const transcript = buffer || screenText;
     const tail = recentBuffer || (transcript || '').slice(-500);
     const status = detectStatus({ tail });
     const activeModal = status === 'waiting_approval' ? parseApproval({ buffer: transcript, tail }) : null;
-    const messages = splitTurns(transcript);
+    const messages = mergeMessages(priorMessages, splitTurns(transcript), status);
     if (status === 'generating' && partialResponse && partialResponse.trim().length > 2) {
         messages.push({ id: 'msg_partial', role: 'assistant', content: partialResponse.trim().slice(0, 6000), index: messages.length, kind: 'standard', meta: { streaming: true } });
     }

package/providers/_builtin/cli/claude-cli/provider.json

@@ -58,9 +58,14 @@
     }
   },
   "binary": "claude",
+  "sendDelayMs": 700,
+  "submitStrategy": "immediate",
   "spawn": {
     "command": "claude",
-    "args": [],
+    "args": [
+      "--permission-mode",
+      "acceptEdits"
+    ],
     "shell": true,
     "env": {}
   },
@@ -69,14 +74,21 @@
       { "source": "Type your message", "flags": "i" },
       { "source": "for\\s*shortcuts", "flags": "i" },
       { "source": "\\?\\s*for\\s*help", "flags": "i" },
-      { "source": "Press enter", "flags": "i" }
+      { "source": "Press enter", "flags": "i" },
+      { "source": "[›❯]\\s*$", "flags": "m" },
+      { "source": "medium\\s+·\\s+/effort", "flags": "i" }
     ],
     "generating": [
       { "source": "[\\u2800-\\u28ff]", "flags": "" },
       { "source": "esc to (cancel|interrupt|stop)", "flags": "i" },
       { "source": "generating\\.\\.\\.", "flags": "i" },
       { "source": "Claude is (?:thinking|processing|working)", "flags": "i" },
-      { "source": "Flummoxing", "flags": "i" }
+      { "source": "Flummoxing", "flags": "i" },
+      { "source": "Finagling", "flags": "i" },
+      { "source": "Scurrying", "flags": "i" },
+      { "source": "Bloviating", "flags": "i" },
+      { "source": "Whatchamacallit(?:ing)?", "flags": "i" },
+      { "source": "(Thinking|Processing|Working|Analyzing|Planning|Drafting|Synthesizing|Inspecting|Reading|Searching)…?", "flags": "i" }
     ],
     "approval": [
       { "source": "Allow\\s*once", "flags": "i" },
@@ -95,9 +107,9 @@
     ]
   },
   "approvalKeys": {
-    "0": "1",
-    "1": "2",
-    "2": "3"
+    "0": "\r",
+    "1": "\u001b[B\r",
+    "2": "\u001b[B\u001b[B\r"
   },
   "compatibility": [
     {

package/providers/_builtin/cli/claude-cli/scripts/1.0/detect_status.js

@@ -1,31 +1,83 @@
 /**
  * Claude Code — detect_status
  *
- * Lightweight status detection for high-frequency polling.
- * Input:  { tail: string }  — last ~500 chars of ANSI-stripped PTY output
- * Output: 'idle' | 'generating' | 'waiting_approval'
+ * Uses the current visible PTY screen when available.
+ * `tail` is still used as a fallback for older runtimes.
  */
 
 'use strict';
 
+function splitLines(text) {
+    return String(text || '')
+        .replace(/\u0007/g, '')
+        .split(/\r\n|\n|\r/g)
+        .map(line => line.replace(/\s+$/, ''));
+}
+
+function normalize(line) {
+    return String(line || '')
+        .replace(/\u0007/g, '')
+        .replace(/^\d+;/, '')
+        .trim();
+}
+
+function isVisiblePrompt(line) {
+    return /^❯\s*$/.test(normalize(line));
+}
+
+function isVisibleApproval(line) {
+    const trimmed = normalize(line);
+    return /Allow\s*once/i.test(trimmed)
+        || /Always\s*allow/i.test(trimmed)
+        || /This command requires approval/i.test(trimmed)
+        || /Do you want to (?:proceed|allow|run)/i.test(trimmed)
+        || /Deny|Reject|Cancel/i.test(trimmed)
+        || /\(y\/n\)/i.test(trimmed)
+        || /\[Y\/n\]/i.test(trimmed)
+        || /^([❯›>]\s*)?\d+[.)]\s+/.test(trimmed);
+}
+
+function isVisibleSpinner(line) {
+    const trimmed = normalize(line);
+    if (!trimmed) return false;
+    if (/^[✻✶✳✢✽⠂⠐⠒⠓⠦⠴⠶⠷⠿]+$/.test(trimmed)) return true;
+    if (/esc to (cancel|interrupt|stop)/i.test(trimmed)) return true;
+    if (/Running(?:\u2026|\.{3})?$/i.test(trimmed)) return true;
+    if (/(?:Finagling|Scurrying|Bloviating|Whatchamacallit(?:ing)?|Hatching|Thinking|Processing|Working|Analyzing|Planning|Drafting|Synthesizing|Inspecting|Reading|Searching|Tinkering|Canoodling|Whirring|Infusing|Accomplishing|Deliberating)\u2026?$/i.test(trimmed)) return true;
+    if (/^[A-Z][a-z]+ing\u2026?$/.test(trimmed)) return true;
+    return false;
+}
+
 module.exports = function detectStatus(input) {
-    const { tail } = input;
-    if (!tail) return 'idle';
+    const tail = String(input?.tail || '');
+    const screenText = String(input?.screenText || '');
+    const visibleLines = splitLines(screenText);
+    const visibleText = visibleLines.map(normalize).filter(Boolean).join('\n');
+    if (visibleText) {
+        if (visibleLines.some(isVisibleApproval)) return 'waiting_approval';
+    } else if (tail) {
+        const hasApproval = /Allow\s*once/i.test(tail)
+            || /Always\s*allow/i.test(tail)
+            || /This command requires approval/i.test(tail)
+            || /Do you want to (?:proceed|allow|run)/i.test(tail)
+            || /\(y\/n\)|\[Y\/n\]/i.test(tail)
+            || /^([❯›>]\s*)?\d+[.)]\s+/m.test(tail);
+        if (hasApproval) return 'waiting_approval';
+    }
+
+    if (visibleLines.length > 0) {
+        const hasSpinner = visibleLines.some(isVisibleSpinner);
+        if (hasSpinner) return 'generating';
 
-    // ─── waiting_approval (highest priority) ───
-    // Claude Code approval menu items
-    if (/Allow\s*once/i.test(tail) || /Always\s*allow/i.test(tail)) return 'waiting_approval';
-    if (/\(y\/n\)/i.test(tail) || /\[Y\/n\]/i.test(tail)) return 'waiting_approval';
+        const hasPrompt = visibleLines.some(isVisiblePrompt);
+        if (hasPrompt) return 'idle';
+    }
 
-    // ─── generating ───
-    // Braille spinner characters (universal TUI spinner)
     if (/[\u2800-\u28ff]/.test(tail)) return 'generating';
-    // Status line indicators
     if (/esc to (cancel|interrupt|stop)/i.test(tail)) return 'generating';
-    if (/generating\.\.\./i.test(tail)) return 'generating';
-    if (/Claude is (?:thinking|processing|working)/i.test(tail)) return 'generating';
-    if (/Flummoxing/i.test(tail)) return 'generating';
+    if (/Running(?:\u2026|\.{3})?$/im.test(tail)) return 'generating';
+    if (/(?:Finagling|Scurrying|Bloviating|Whatchamacallit(?:ing)?|Hatching|Thinking|Processing|Working|Analyzing|Planning|Drafting|Synthesizing|Inspecting|Reading|Searching|Tinkering|Canoodling|Whirring|Infusing|Accomplishing|Deliberating)\u2026?$/i.test(tail)) return 'generating';
+    if (/^[A-Z][a-z]+ing\u2026?$/m.test(tail)) return 'generating';
 
-    // ─── idle ───
     return 'idle';
 };

package/providers/_builtin/cli/claude-cli/scripts/1.0/parse_approval.js

@@ -1,38 +1,97 @@
 /**
  * Claude Code — parse_approval
- *
- * Extract approval modal info from PTY output.
- * Input:  { buffer: string, tail: string }
- * Output: { message: string, buttons: string[] } | null
  */
 
 'use strict';
 
+function splitLines(text) {
+    return String(text || '')
+        .replace(/\u0007/g, '')
+        .split(/\r\n|\n|\r/g)
+        .map(line => line.replace(/\s+$/, ''));
+}
+
+function normalize(line) {
+    return String(line || '')
+        .replace(/\u0007/g, '')
+        .replace(/^\d+;/, '')
+        .trim();
+}
+
+function isNoise(line) {
+    const trimmed = normalize(line);
+    if (!trimmed) return true;
+    if (/^[─═╭╮╰╯│┌┐└┘├┤┬┴┼]+$/.test(trimmed)) return true;
+    if (/^❯\s*$/.test(trimmed)) return true;
+    if (/^➜\s+\S+/.test(trimmed)) return true;
+    if (/^Update available!/i.test(trimmed)) return true;
+    if (/^Claude Code v\d/i.test(trimmed)) return true;
+    if (/^(Sonnet|Opus|Haiku)\b/i.test(trimmed)) return true;
+    return false;
+}
+
+function normalizeButtonLabel(line) {
+    return normalize(line)
+        .replace(/^[❯›>]\s*/, '')
+        .replace(/^[([{]?\d+[)\].:\]-]?\s*/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function isButtonLine(line) {
+    const raw = normalize(line);
+    const trimmed = normalizeButtonLabel(line);
+    if (/^Esc to cancel/i.test(raw)) return false;
+    return /^([❯›>]\s*)?\d+[.)]\s+/.test(raw)
+        || /^(Allow\s*once|Always\s*allow.*|Deny|Reject|Yes|No)$/i.test(trimmed);
+}
+
+function stripContextPrefix(line) {
+    return normalize(line)
+        .replace(/^[⏺•]\s+/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function findLastIndex(lines, predicate) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (predicate(lines[i])) return i;
+    }
+    return -1;
+}
+
 module.exports = function parseApproval(input) {
-    const { buffer, tail } = input;
-    const check = tail || (buffer || '').slice(-800);
-    if (!check) return null;
+    const primary = String(input?.buffer || '');
+    const fallback = String(input?.tail || '');
+    const lines = splitLines(primary || fallback);
+    if (lines.length === 0) return null;
 
-    // Claude Code approval patterns
-    const hasApproval =
-        /Allow\s*once/i.test(check) ||
-        /Always\s*allow/i.test(check) ||
-        /\(y\/n\)/i.test(check) ||
-        /\[Y\/n\]/i.test(check);
+    const buttons = [];
+    for (const line of lines.slice(-40)) {
+        if (!isButtonLine(line)) continue;
+        const label = normalizeButtonLabel(line);
+        if (label && !buttons.includes(label)) buttons.push(label);
+    }
 
+    const hasApproval = buttons.length > 0
+        || /Allow\s*once|Always\s*allow|\(y\/n\)|\[Y\/n\]/i.test(primary || fallback);
     if (!hasApproval) return null;
 
-    // Extract context message (last few meaningful lines before the approval)
-    const lines = check.split('\n')
-        .map(l => l.trim())
-        .filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
+    const questionIndex = findLastIndex(lines, line => /Do you want to (?:proceed|make this edit|run this command|allow)/i.test(normalize(line)));
+    const actionIndex = findLastIndex(lines, line => /^(?:[⏺•]\s+)?(?:Bash|Write|Edit|MultiEdit|Read|Task|Glob|Grep|LS|NotebookEdit)\(/.test(stripContextPrefix(line)));
+    const startIndex = Math.max(0, (actionIndex >= 0 ? actionIndex : questionIndex >= 0 ? questionIndex - 4 : lines.length - 8));
+    const endIndex = questionIndex >= 0 ? questionIndex + 1 : lines.length;
 
-    const message = lines.slice(-5).join(' ').slice(0, 200) || 'Approval required';
+    const context = [];
+    for (const line of lines.slice(startIndex, endIndex)) {
+        if (isNoise(line) || isButtonLine(line)) continue;
+        const trimmed = stripContextPrefix(line);
+        if (!trimmed) continue;
+        if (context[context.length - 1] !== trimmed) context.push(trimmed);
+    }
 
-    // Claude Code-specific button labels
-    // These map to approvalKeys in provider.json: { "0": "1", "1": "2", "2": "3" }
     return {
-        message,
-        buttons: ['Yes (y)', 'Always allow (a)', 'Deny (Esc)'],
+        message: context.slice(-3).join(' ').slice(0, 240) || 'Claude Code approval required',
+        buttons: buttons.length > 0 ? buttons : ['Allow once', 'Always allow', 'Deny'],
     };
 };