@adhdev/daemon-core 0.9.82-rc.34 → 0.9.82-rc.340

package/src/providers/sdk/v1/builders/cli/detect-status.ts

@@ -0,0 +1,262 @@
+/**
+ * buildDetectStatusFromTui
+ *
+ * Turns a manifest's declarative TUI block into a runtime
+ * `(input: CliStatusInput) => CliStatus | null` function.
+ *
+ * Inputs handled (all optional except spinner):
+ *   - tui/spinner@1          → contributes `generating`
+ *   - tui/settled-prompt@1   → contributes `idle`
+ *   - tui/modal@1            → contributes `waiting_approval`
+ *
+ * Dispatch order (sprint-2026-06 contract):
+ *   1. Active generation cues win over idle prompt — checked first.
+ *      Reason: codex/claude keep model footer visible during `Working` and
+ *      `hasReadyPrompt` falsely fired idle. Audit §4.2 introduces
+ *      `tui/cue-ordering` as the named primitive for this rule.
+ *   2. Modal cue (if present) is checked next — `waiting_approval`.
+ *   3. Settled-prompt cue — `idle`.
+ *   4. Default: `null` (no change).
+ */
+
+import type {
+  CliStatusInput,
+  CliStatus,
+  CliDetectStatusFn,
+} from '../../types/cli/index.js';
+import {
+  applyVisibleRegion,
+  type VisibleRegionSpec,
+} from './visible-region.js';
+
+// ─── Primitive spec shapes (mirror the JSON schemas) ───────────────────
+
+interface RegexLikeSpec {
+  regex: string;
+  flags?: string;
+}
+
+interface SpinnerPatternSpec extends RegexLikeSpec {
+  description?: string;
+}
+
+interface SpinnerSpec {
+  $schema: 'adhdev:tui/spinner@1';
+  patterns: SpinnerPatternSpec[];
+  scope?: 'live-frame-tail' | 'whole-screen' | 'recent-buffer';
+  scopeWindowLines?: number;
+}
+
+interface SettledPromptFooterSpec {
+  pattern: string;
+  kind?: 'substring' | 'regex';
+  flags?: string;
+}
+
+interface SettledPromptSpec {
+  $schema: 'adhdev:tui/settled-prompt@1';
+  regex: string;
+  flags?: string;
+  withFooter?: SettledPromptFooterSpec[];
+  scope?: 'last-n-lines' | 'whole-screen';
+  scopeWindowLines?: number;
+}
+
+interface ModalSpec {
+  $schema: 'adhdev:tui/modal@1';
+  questionPattern: string;
+  questionFlags?: string;
+  questionVariants?: Array<{ regex: string; flags?: string; label?: string }>;
+  buttonPattern: string;
+  buttonFlags?: string;
+}
+
+export type DispatchGroup =
+  | 'spinner'
+  | 'modal'
+  | 'settled-prompt'
+  | 'cue-ordering'
+  | 'error-detection'
+  | 'approval-stitching';
+
+export interface DispatchOrderSpec {
+  $schema: 'adhdev:tui/dispatch-order@1';
+  order: DispatchGroup[];
+  onNoMatch?: 'idle' | 'unknown' | 'preserve-last';
+}
+
+export interface DetectStatusTuiSpec {
+  spinner?: SpinnerSpec;
+  settledPrompt?: SettledPromptSpec;
+  modal?: ModalSpec;
+  dispatchOrder?: DispatchOrderSpec;
+  visibleRegion?: VisibleRegionSpec;
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+function compile(re: string, flags?: string): RegExp {
+  try {
+    return new RegExp(re, flags ?? '');
+  } catch (e) {
+    throw new Error(`Invalid regex /${re}/${flags ?? ''}: ${(e as Error).message}`);
+  }
+}
+
+function takeTail(text: string, lines: number): string {
+  if (!text) return '';
+  const split = text.split('\n');
+  if (split.length <= lines) return text;
+  return split.slice(-lines).join('\n');
+}
+
+function scopeText(
+  input: CliStatusInput,
+  scope: SpinnerSpec['scope'] | SettledPromptSpec['scope'],
+  windowLines: number | undefined,
+): string {
+  const lines = windowLines && windowLines > 0 ? windowLines : 8;
+  switch (scope) {
+    case 'whole-screen':
+      return input.screenText ?? '';
+    case 'recent-buffer':
+      return input.tail ?? '';
+    case 'last-n-lines':
+    case 'live-frame-tail':
+    case undefined:
+    default:
+      return takeTail(input.screenText ?? '', lines);
+  }
+}
+
+function compileSpinnerMatchers(spec: SpinnerSpec): RegExp[] {
+  return spec.patterns.map((p) => compile(p.regex, p.flags ?? 'i'));
+}
+
+function spinnerMatches(spec: SpinnerSpec, input: CliStatusInput): boolean {
+  const matchers = compileSpinnerMatchers(spec);
+  const text = scopeText(input, spec.scope, spec.scopeWindowLines);
+  return matchers.some((re) => re.test(text));
+}
+
+function compileSettledPromptMatchers(spec: SettledPromptSpec): {
+  prompt: RegExp;
+  footers: Array<{ test: (s: string) => boolean }>;
+} {
+  const prompt = compile(spec.regex, spec.flags ?? 'm');
+  const footers = (spec.withFooter ?? []).map((f) => {
+    if (f.kind === 'regex') {
+      const re = compile(f.pattern, f.flags ?? 'i');
+      return { test: (s: string) => re.test(s) };
+    }
+    const needle = f.pattern.toLowerCase();
+    return { test: (s: string) => s.toLowerCase().includes(needle) };
+  });
+  return { prompt, footers };
+}
+
+function settledPromptMatches(spec: SettledPromptSpec, input: CliStatusInput): boolean {
+  const { prompt, footers } = compileSettledPromptMatchers(spec);
+  const text = scopeText(input, spec.scope, spec.scopeWindowLines);
+  if (!prompt.test(text)) return false;
+  if (footers.length === 0) return true;
+  return footers.every((f) => f.test(text));
+}
+
+function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean {
+  // Status-level modal detection is cue-only — does the question appear at all?
+  // Button extraction lives in buildParseApprovalFromTui.
+  const text = input.screenText ?? '';
+  const question = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  if (question.test(text)) return true;
+  for (const variant of spec.questionVariants ?? []) {
+    const re = compile(variant.regex, variant.flags ?? 'i');
+    if (re.test(text)) return true;
+  }
+  return false;
+}
+
+// ─── Public builder ────────────────────────────────────────────────────
+
+const DEFAULT_ORDER: DispatchGroup[] = ['spinner', 'modal', 'settled-prompt'];
+
+function evaluateGroup(
+  group: DispatchGroup,
+  spec: DetectStatusTuiSpec,
+  input: CliStatusInput,
+  compiled: {
+    spinner: RegExp[] | null;
+    settled: ReturnType<typeof compileSettledPromptMatchers> | null;
+  },
+): CliStatus | null {
+  switch (group) {
+    case 'spinner': {
+      if (!spec.spinner || !compiled.spinner) return null;
+      const text = scopeText(input, spec.spinner.scope, spec.spinner.scopeWindowLines);
+      return compiled.spinner.some((re) => re.test(text)) ? 'generating' : null;
+    }
+    case 'modal': {
+      if (!spec.modal) return null;
+      return modalMatches(spec.modal, input) ? 'waiting_approval' : null;
+    }
+    case 'settled-prompt': {
+      if (!spec.settledPrompt || !compiled.settled) return null;
+      const text = scopeText(input, spec.settledPrompt.scope, spec.settledPrompt.scopeWindowLines);
+      if (!compiled.settled.prompt.test(text)) return null;
+      if (compiled.settled.footers.length === 0) return 'idle';
+      return compiled.settled.footers.every((f) => f.test(text)) ? 'idle' : null;
+    }
+    // Groups declared in the catalog but not yet implemented as builder steps
+    // return null so they are no-ops in dispatch — declaring them in `order`
+    // is forward-compatible. Phase 2 Week 8+ will wire them.
+    case 'cue-ordering':
+    case 'error-detection':
+    case 'approval-stitching':
+      return null;
+    default:
+      return null;
+  }
+}
+
+export function buildDetectStatusFromTui(spec: DetectStatusTuiSpec): CliDetectStatusFn {
+  const compiledSpinner = spec.spinner ? compileSpinnerMatchers(spec.spinner) : null;
+  const compiledSettled = spec.settledPrompt
+    ? compileSettledPromptMatchers(spec.settledPrompt)
+    : null;
+  const compiled = { spinner: compiledSpinner, settled: compiledSettled };
+  const order = spec.dispatchOrder?.order && spec.dispatchOrder.order.length > 0
+    ? spec.dispatchOrder.order
+    : DEFAULT_ORDER;
+
+  return function detectStatus(input: CliStatusInput): CliStatus | null {
+    // Apply visible-region scoping before running any matchers.
+    const effectiveInput: CliStatusInput = spec.visibleRegion
+      ? {
+          ...input,
+          screenText: applyVisibleRegion(spec.visibleRegion, input.screenText ?? ''),
+          tail: applyVisibleRegion(spec.visibleRegion, input.tail),
+        }
+      : input;
+
+    for (const group of order) {
+      const verdict = evaluateGroup(group, spec, effectiveInput, compiled);
+      if (verdict !== null) return verdict;
+    }
+    // onNoMatch policy: the builder always returns null when nothing matched.
+    // The daemon's outer state machine maps null per the policy below:
+    //   'idle'          → caller treats null as idle (default)
+    //   'unknown'       → caller keeps status unknown / shows last
+    //   'preserve-last' → caller preserves the last reported verdict
+    // Encoding this here would require call-site state; instead the daemon
+    // reads `dispatchOrder.onNoMatch` from the manifest directly.
+    return null;
+  };
+}
+
+// Internal exports for builder reuse + tests.
+export const __internal = {
+  scopeText,
+  spinnerMatches,
+  settledPromptMatches,
+  modalMatches,
+};

package/src/providers/sdk/v1/builders/cli/parse-approval-squash.ts

@@ -0,0 +1,158 @@
+/**
+ * buildParseApprovalFromSquash
+ *
+ * Companion to buildParseApprovalFromTui. Handles the squashed-modal case:
+ * the terminal has re-flowed the approval frame so the rendered text is a
+ * single run of lowercase-alnum bytes (e.g. `doyoutrustthecontentsofthisdirectory…1yescontinue2noquit`).
+ *
+ * Author declares:
+ *   - `cues`        — compact substrings/regexes that identify the modal
+ *   - `footers`     — optional compact substrings that must also be present
+ *   - `buttonRules` — compact→labels mappings used to recover button labels
+ *
+ * Returns the same shape as buildParseApprovalFromTui — a CliApprovalModal
+ * (message + buttons) or null when no rule matches. Caller composes the two
+ * builders: try the regular modal first, then fall back to squash. Codex
+ * needs both because at narrow widths the terminal renders the squash form,
+ * and at wider widths it renders the regular framed form.
+ */
+
+import type {
+  CliApprovalInput,
+  CliApprovalModal,
+  CliParseApprovalFn,
+} from '../../types/cli/index.js';
+
+// ─── Spec mirrors the JSON schema ─────────────────────────────────────
+
+interface SquashCueSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+  label?: string;
+  messageWhenMatched?: string;
+}
+
+interface SquashFooterSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+}
+
+interface SquashButtonRuleSpec {
+  compact: string;
+  kind?: 'substring' | 'regex';
+  labels: string[];
+}
+
+export interface ApprovalSquashSpec {
+  $schema: 'adhdev:tui/approval-squash@1';
+  cues: SquashCueSpec[];
+  footers?: SquashFooterSpec[];
+  buttonRules: SquashButtonRuleSpec[];
+  scope?: 'tail-window' | 'whole-screen';
+  tailWindowLines?: number;
+}
+
+// ─── Internals ────────────────────────────────────────────────────────
+
+const COMPACT_RE = /[^a-z0-9]+/g;
+
+/**
+ * The canonical normalisation. Identical to codex-cli's `compactText`:
+ * lowercase, then strip everything that is not a-z or 0-9.
+ *
+ * Exported for tests and for the (rare) provider that wants to compose this
+ * with extra normalisation steps.
+ */
+export function compactText(value: string): string {
+  return String(value || '').toLowerCase().replace(COMPACT_RE, '');
+}
+
+function compileRegex(source: string, flags = 'i'): RegExp {
+  try { return new RegExp(source, flags); }
+  catch (e) { throw new Error(`Invalid regex /${source}/${flags}: ${(e as Error).message}`); }
+}
+
+function matchSubstringOrRegex(
+  needle: string,
+  kind: 'substring' | 'regex' | undefined,
+  haystack: string,
+): boolean {
+  if (kind === 'regex') return compileRegex(needle).test(haystack);
+  return haystack.includes(needle);
+}
+
+function scopeText(spec: ApprovalSquashSpec, input: CliApprovalInput): string {
+  const scope = spec.scope ?? 'tail-window';
+  const candidates = [
+    String(input.screenText || ''),
+    String(input.rawBuffer || ''),
+    String(input.buffer || ''),
+    String(input.tail || ''),
+  ].filter(Boolean);
+  const joined = candidates.join('\n');
+  if (scope === 'whole-screen') return joined;
+  const tailLines = spec.tailWindowLines ?? 24;
+  return joined.split('\n').slice(-tailLines).join('\n');
+}
+
+// ─── Public builder ───────────────────────────────────────────────────
+
+export function buildParseApprovalFromSquash(spec: ApprovalSquashSpec): CliParseApprovalFn {
+  if (!Array.isArray(spec.cues) || spec.cues.length === 0) {
+    throw new Error('approval-squash spec must declare at least one cue.');
+  }
+  if (!Array.isArray(spec.buttonRules) || spec.buttonRules.length === 0) {
+    throw new Error('approval-squash spec must declare at least one button rule.');
+  }
+
+  return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
+    const text = scopeText(spec, input);
+    if (!text) return null;
+    const compact = compactText(text);
+    if (!compact) return null;
+
+    // 1) Find the first matching cue. Its messageWhenMatched (if present) is
+    //    the human-readable modal message; otherwise we fall back to a label
+    //    or empty string.
+    let matchedCue: SquashCueSpec | null = null;
+    for (const cue of spec.cues) {
+      if (matchSubstringOrRegex(cue.compact, cue.kind, compact)) {
+        matchedCue = cue;
+        break;
+      }
+    }
+    if (!matchedCue) return null;
+
+    // 2) If footers are declared, at least one must also match.
+    if (spec.footers && spec.footers.length > 0) {
+      const anyFooter = spec.footers.some((f) =>
+        matchSubstringOrRegex(f.compact, f.kind, compact),
+      );
+      if (!anyFooter) return null;
+    }
+
+    // 3) Find a button rule whose compact pattern is present in the compacted
+    //    text. First match wins.
+    let labels: string[] | null = null;
+    for (const rule of spec.buttonRules) {
+      if (matchSubstringOrRegex(rule.compact, rule.kind, compact)) {
+        labels = rule.labels;
+        break;
+      }
+    }
+    if (!labels || labels.length === 0) return null;
+
+    const message = matchedCue.messageWhenMatched
+      || matchedCue.label
+      || '';
+
+    return { message, buttons: [...labels] };
+  };
+}
+
+// Internal exports for tests.
+export const __internal = {
+  compactText,
+  matchSubstringOrRegex,
+  scopeText,
+};

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -0,0 +1,250 @@
+/**
+ * buildParseApprovalFromTui
+ *
+ * Turns a `tui/modal@1` block into a runtime
+ * `(input: CliApprovalInput) => CliApprovalModal | null` function.
+ *
+ * Contract rules enforced (sprint-2026-06):
+ *   - Returns null when the question pattern is not visible.
+ *   - Returns null when the button list is empty or shorter than minButtons.
+ *   - Button labels are raw text; never rewritten (e.g. "Yes, and don't ask
+ *     again for X" stays verbatim).
+ *   - Modal scope respects between-last-two-separators / window-around-question
+ *     / whole-screen to avoid false-positives from numbered lists in
+ *     assistant prose.
+ */
+
+import type {
+  CliApprovalInput,
+  CliApprovalModal,
+  CliParseApprovalFn,
+} from '../../types/cli/index.js';
+import {
+  applyVisibleRegion,
+  type VisibleRegionSpec,
+} from './visible-region.js';
+
+// ─── Spec shapes ───────────────────────────────────────────────────────
+
+interface ModalQuestionVariant {
+  regex: string;
+  flags?: string;
+  label?: string;
+}
+
+interface ModalContextHeader {
+  regex: string;
+  flags?: string;
+}
+
+export interface ModalTuiSpec {
+  $schema: 'adhdev:tui/modal@1';
+  questionPattern: string;
+  questionFlags?: string;
+  questionVariants?: ModalQuestionVariant[];
+  buttonPattern: string;
+  buttonFlags?: string;
+  buttonLabelGroup?: number;
+  /**
+   * Optional fallback for terminals that render all options on a single line
+   * (e.g. Antigravity feedback survey: `[0] skip [1] yes [2] no [3] still using`).
+   * When per-line button extraction collects fewer than `minButtons`, the
+   * builder makes a second pass with this regex (global match, capture group 1
+   * is the label).
+   */
+  inlineButtonPattern?: string;
+  inlineButtonFlags?: string;
+  scope?: 'between-last-two-separators' | 'window-around-question' | 'whole-screen';
+  scopeWindowLines?: number;
+  contextHeader?: ModalContextHeader;
+  continuationLines?: boolean;
+  minButtons?: number;
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+const SEPARATOR_RE = /^(?:─|━|═|━){10,}\s*$/;
+
+function compile(re: string, flags?: string): RegExp {
+  try {
+    return new RegExp(re, flags);
+  } catch (e) {
+    throw new Error(`Invalid regex /${re}/${flags ?? ''}: ${(e as Error).message}`);
+  }
+}
+
+function findQuestionLineIndex(
+  spec: ModalTuiSpec,
+  lines: string[],
+): { index: number; matchedSource: 'primary' | string } | null {
+  const primary = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  // Search bottom-up to prefer the most recent modal.
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (primary.test(lines[i])) return { index: i, matchedSource: 'primary' };
+  }
+  for (const variant of spec.questionVariants ?? []) {
+    const re = compile(variant.regex, variant.flags ?? 'i');
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (re.test(lines[i])) return { index: i, matchedSource: variant.label ?? 'variant' };
+    }
+  }
+  return null;
+}
+
+function scopeLines(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+): { start: number; end: number } {
+  const scope = spec.scope ?? 'between-last-two-separators';
+  if (scope === 'whole-screen') {
+    return { start: 0, end: lines.length };
+  }
+  if (scope === 'window-around-question') {
+    const window = spec.scopeWindowLines ?? 16;
+    return {
+      start: Math.max(0, questionIndex - 2),
+      end: Math.min(lines.length, questionIndex + window),
+    };
+  }
+  // between-last-two-separators
+  let lastSep = -1;
+  let prevSep = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (SEPARATOR_RE.test(lines[i].trim())) {
+      if (lastSep < 0) lastSep = i;
+      else if (prevSep < 0) {
+        prevSep = i;
+        break;
+      }
+    }
+  }
+  if (lastSep >= 0 && prevSep >= 0) {
+    return { start: prevSep, end: lastSep + 1 };
+  }
+  // Fallback: window around question line.
+  return {
+    start: Math.max(0, questionIndex - 4),
+    end: Math.min(lines.length, questionIndex + 16),
+  };
+}
+
+function extractButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  const buttonRe = compile(spec.buttonPattern, spec.buttonFlags ?? 'm');
+  const out: string[] = [];
+  const labelGroup = Number.isInteger(spec.buttonLabelGroup) && (spec.buttonLabelGroup ?? 0) > 0
+    ? spec.buttonLabelGroup!
+    : 1;
+  let i = windowStart;
+  while (i < windowEnd) {
+    const line = lines[i];
+    const m = buttonRe.exec(line);
+    const captured = m?.[labelGroup] ?? (labelGroup === 1 && m && m.length > 2 ? m[m.length - 1] : undefined);
+    if (m && captured) {
+      let label = captured.trim();
+      // Continuation lines: when enabled, append indented lines below until
+      // the next button or blank.
+      if (spec.continuationLines) {
+        let j = i + 1;
+        while (j < windowEnd) {
+          const next = lines[j];
+          if (!next.trim()) break;
+          if (buttonRe.test(next)) break;
+          // continuation must be indented (not at column 0 like a new section).
+          if (!/^\s+/.test(next)) break;
+          label += ' ' + next.trim();
+          j += 1;
+        }
+        i = j;
+      } else {
+        i += 1;
+      }
+      out.push(label);
+    } else {
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function buildMessage(
+  spec: ModalTuiSpec,
+  lines: string[],
+  questionIndex: number,
+  windowStart: number,
+  windowEnd: number,
+): string {
+  const messageParts: string[] = [];
+  if (spec.contextHeader) {
+    const ctxRe = compile(spec.contextHeader.regex, (spec.contextHeader.flags ?? 'i') + 'm');
+    const haystack = lines.slice(windowStart, windowEnd).join('\n');
+    const m = ctxRe.exec(haystack);
+    if (m) messageParts.push(m[1] ? m[1].trim() : m[0].trim());
+  }
+  messageParts.push(lines[questionIndex].trim());
+  return messageParts.filter(Boolean).join(' — ');
+}
+
+// ─── Public builder ────────────────────────────────────────────────────
+
+function extractInlineButtons(
+  spec: ModalTuiSpec,
+  lines: string[],
+  windowStart: number,
+  windowEnd: number,
+): string[] {
+  if (!spec.inlineButtonPattern) return [];
+  // Always force the `g` flag so we can iterate all matches in the line.
+  const declaredFlags = spec.inlineButtonFlags ?? 'gi';
+  const flags = declaredFlags.includes('g') ? declaredFlags : declaredFlags + 'g';
+  const re = compile(spec.inlineButtonPattern, flags);
+  const out: string[] = [];
+  for (let i = windowStart; i < windowEnd; i += 1) {
+    let m: RegExpExecArray | null;
+    re.lastIndex = 0;
+    while ((m = re.exec(lines[i])) !== null) {
+      const label = (m[1] ?? m[0]).trim();
+      if (label && !out.includes(label)) out.push(label);
+      if (m.index === re.lastIndex) re.lastIndex += 1; // safety against zero-width matches
+    }
+  }
+  return out;
+}
+
+export function buildParseApprovalFromTui(
+  spec: ModalTuiSpec,
+  visibleRegion?: VisibleRegionSpec,
+): CliParseApprovalFn {
+  const minButtons = spec.minButtons ?? 2;
+
+  return function parseApproval(input: CliApprovalInput): CliApprovalModal | null {
+    const rawText = input.screenText ?? input.buffer ?? '';
+    if (!rawText) return null;
+    const text = visibleRegion ? applyVisibleRegion(visibleRegion, rawText) : rawText;
+    const lines = text.split('\n');
+    const question = findQuestionLineIndex(spec, lines);
+    if (!question) return null;
+    const { start, end } = scopeLines(spec, lines, question.index);
+    if (question.index < start || question.index >= end) return null;
+    let buttons = extractButtons(spec, lines, question.index + 1, end);
+    // Inline fallback: when per-line extraction came up short, the terminal
+    // may have rendered every option on the same line ("[0] skip [1] yes …").
+    if (buttons.length < minButtons && spec.inlineButtonPattern) {
+      buttons = extractInlineButtons(spec, lines, question.index, end);
+    }
+    if (buttons.length < minButtons) return null;
+    const message = buildMessage(spec, lines, question.index, start, end);
+    return { message, buttons };
+  };
+}
+
+export const __internal = {
+  findQuestionLineIndex,
+  scopeLines,
+  extractButtons,
+};