@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/src/panels/session-browser-panel.ts

@@ -4,6 +4,7 @@
 
 import type { Line } from '../types/grid.ts';
 import { BasePanel } from './base-panel.ts';
+import type { PanelIntegrationContext } from './types.ts';
 import type { SessionInfo } from '@pellux/goodvibes-sdk/platform/sessions';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { SessionBrowserQuery } from '../runtime/ui-service-queries.ts';
@@ -40,6 +41,15 @@ const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   countFg:  '#88bbcc',
 });
 
+// Splits a computed '/command arg1 arg2' string into the { name, args } shape
+// ctx.executeCommand expects — same leading-slash-stripping approach used by
+// remote-panel.ts for its own dispatched command.
+function parseCommand(command: string): { name: string; args: string[] } | null {
+  const parts = command.replace(/^\//, '').split(/\s+/).filter(Boolean);
+  const [name, ...args] = parts;
+  return name ? { name, args } : null;
+}
+
 function shortDate(ts: number): string {
   const d = new Date(ts);
   const Y = d.getFullYear();
@@ -87,6 +97,12 @@ export class SessionBrowserPanel extends BasePanel {
   private loadError = '';
   private hasLoaded = false;
   private refreshTimerId: ReturnType<typeof setInterval> | null = null;
+  // x = dispatch the computed next-step command ('/remote recover <runner>'
+  // or '/session resume <name>') via the same handleInput -> handlePanelIntegrationAction
+  // bridge remote-panel.ts uses — handleInput has no ctx.executeCommand.
+  private pendingCommand: { name: string; args: string[] } | null = null;
+  // On resume, restore any panels the session had open when it was saved.
+  private pendingOpenPanels: string[] | null = null;
 
   constructor(
     private readonly sessionManager: SessionBrowserQuery,
@@ -101,6 +117,21 @@ export class SessionBrowserPanel extends BasePanel {
     this.refreshTimerId = this.registerTimer(setInterval(() => { this._load(); }, 5000));
   }
 
+  /**
+   * Clears any active search/filter and moves the cursor to the session
+   * matching `sessionId` (SessionInfo.name) so a sibling panel (e.g.
+   * RoutesPanel's Enter-on-binding jump) can land directly on it. No-ops
+   * (beyond clearing the filter) if the session isn't found.
+   */
+  focusSession(sessionId: string): void {
+    this.searching = false;
+    this.searchQuery = '';
+    this._filter();
+    const index = this.filtered.findIndex((session) => session.name === sessionId);
+    if (index >= 0) this.cursorIndex = index;
+    this.markDirty();
+  }
+
   override onDeactivate(): void {
     if (this.refreshTimerId !== null) { this.clearTimer(this.refreshTimerId); this.refreshTimerId = null; }
     this.searching = false;
@@ -163,10 +194,34 @@ export class SessionBrowserPanel extends BasePanel {
       case 'return':   this._resume();      return true;
       case 'd':        this._promptDelete(); return true;
       case 'r':        this._load();        return true;
+      case 'x':        this._dispatchNextStep(); return true;
       default:         return false;
     }
   }
 
+  /**
+   * Drains `pendingCommand` (set by the 'x' key) and `pendingOpenPanels`
+   * (set by `_resume()`) via the ctx.executeCommand / PanelManager bridge.
+   * Called by the input router immediately after handleInput() consumes the
+   * same key (panel-integration-actions.ts's onPanelInputConsumed).
+   */
+  handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
+    let consumed = false;
+    if (this.pendingCommand) {
+      const { name, args } = this.pendingCommand;
+      this.pendingCommand = null;
+      void ctx.executeCommand?.(name, args);
+      consumed = true;
+    }
+    if (this.pendingOpenPanels) {
+      const openPanels = this.pendingOpenPanels;
+      this.pendingOpenPanels = null;
+      for (const panelId of openPanels) ctx.panelManager.open(panelId);
+      consumed = true;
+    }
+    return consumed;
+  }
+
   render(width: number, height: number): Line[] {
     if (height <= 0 || width <= 0) return [];
     const intro = 'Browse, search, resume, and prune saved conversations.';
@@ -196,7 +251,7 @@ export class SessionBrowserPanel extends BasePanel {
       hints.push({ keys: 'type', label: 'filter' }, { keys: 'Esc/Enter', label: 'apply' });
     } else {
       hints.push({ keys: '/', label: this.searchQuery ? 'edit search' : 'search' });
-      if (hasSelection) hints.push({ keys: 'Enter', label: 'resume' }, { keys: 'd', label: 'delete' });
+      if (hasSelection) hints.push({ keys: 'Enter', label: 'resume' }, { keys: 'x', label: 'run next step' }, { keys: 'd', label: 'delete' });
       hints.push({ keys: 'r', label: 'refresh' });
     }
     const footerLines = [
@@ -285,7 +340,7 @@ export class SessionBrowserPanel extends BasePanel {
             ...formatReturnContextLines(selected.returnContext).map((line) =>
               buildPanelLine(width, [[' ', DEFAULT_PANEL_PALETTE.dim], [truncateDisplay(line, Math.max(0, width - 2)), DEFAULT_PANEL_PALETTE.dim]])
             ),
-            buildPanelLine(width, [[' Next ', DEFAULT_PANEL_PALETTE.label], [selected.returnContext?.remoteRunners?.length ? `/remote recover ${selected.returnContext.remoteRunners[0]}` : '/session resume', DEFAULT_PANEL_PALETTE.dim]]),
+            buildPanelLine(width, [[' Next ', DEFAULT_PANEL_PALETTE.label], [this._computeNextStepCommand(selected), DEFAULT_PANEL_PALETTE.dim], ['   (x to run)', DEFAULT_PANEL_PALETTE.dim]]),
           ],
         }
       : { title: 'Selected', lines: [] };
@@ -389,9 +444,25 @@ export class SessionBrowserPanel extends BasePanel {
   private _resume(): void {
     const sess = this.filtered[this.cursorIndex];
     if (!sess) return;
+    if (sess.returnContext?.openPanels?.length) {
+      this.pendingOpenPanels = [...sess.returnContext.openPanels];
+    }
     this.resumeSession?.(sess.name);
   }
 
+  /** The next-step command shown in the 'Selected' section and dispatched by 'x'. */
+  private _computeNextStepCommand(sess: SessionInfo): string {
+    const runner = sess.returnContext?.remoteRunners?.[0];
+    return runner ? `/remote recover ${runner}` : `/session resume ${sess.name}`;
+  }
+
+  private _dispatchNextStep(): void {
+    const sess = this.filtered[this.cursorIndex];
+    if (!sess) return;
+    const parsed = parseCommand(this._computeNextStepCommand(sess));
+    if (parsed) this.pendingCommand = parsed;
+  }
+
   private _promptDelete(): void {
     const sess = this.filtered[this.cursorIndex];
     if (!sess) return;

package/src/panels/session-maintenance.ts

@@ -1,16 +1,13 @@
 /**
- * Session maintenance types and local evaluator.
+ * Session maintenance types.
  *
  * The canonical evaluator is the SDK version exported from @/runtime/index.ts
  * (via operations.evaluateSessionMaintenance), which reads from configManager.
- *
- * This module provides:
- *  - The shared type surface used across TUI panels.
- *  - A thin local evaluator kept in sync with the SDK signature so panel code
- *    that passes configManager has a coherent call site.
+ * Import the evaluator from there — this module provides only the shared
+ * Panel* type surface used across TUI panels and tests; it intentionally does
+ * not re-implement the evaluator.
  */
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import { computeContextUsage } from '../core/context-usage.ts';
 
 export type PanelGuidanceMode = 'off' | 'minimal' | 'guided';
 export type PanelSessionMaintenanceLevel = 'stable' | 'watch' | 'suggest-compact' | 'compacting' | 'needs-repair' | 'unknown';
@@ -59,118 +56,3 @@ export interface PanelSessionMaintenanceStatus {
   readonly lastCompactedAt?: number;
   readonly compactRecommended: boolean;
 }
-
-/**
- * Evaluate session maintenance from config-driven thresholds.
- *
- * behavior.autoCompactThreshold (percent integer, SDK schema range [10, 100], default 80):
- *  - [10, 100] → threshold at that percent; autoCompactEnabled = true.
- *  - 0 (defensive fallback for null/missing config only; not a valid schema value).
- *
- * NOTE: The SDK's evaluateSessionMaintenance (from @/runtime/index.ts) is the
- * canonical implementation used in production.  This local version exists so
- * panel tests can import types without crossing the SDK boundary.
- */
-export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput): PanelSessionMaintenanceStatus {
-  const guidanceMode: PanelGuidanceMode = (input.configManager.get('behavior.guidanceMode') as PanelGuidanceMode | undefined) ?? 'minimal';
-  const rawThreshold = Number(input.configManager.get('behavior.autoCompactThreshold') ?? 0);
-  const thresholdPct = Math.max(0, Number.isFinite(rawThreshold) ? rawThreshold : 0);
-  const autoCompactEnabled = thresholdPct > 0;
-
-  const { pct: usagePct, remaining: remainingTokens } = computeContextUsage(input.currentTokens, input.contextWindow);
-  const sessionMemoryCount = Math.max(0, input.sessionMemoryCount ?? 0);
-  const compactionCount = Math.max(0, input.session?.lineage?.filter((entry) => entry.branchReason === 'compaction').length ?? 0);
-  const lastCompactedAt = input.session?.lastCompactedAt;
-  const messageCount = Math.max(0, input.messageCount ?? 0);
-  const staleByMessageGrowth = (input.session?.compactionMessageCount ?? 0) > 0
-    ? messageCount - (input.session?.compactionMessageCount ?? 0) >= 12
-    : messageCount >= 24;
-
-  if (input.contextWindow <= 0) {
-    return {
-      level: 'unknown',
-      summary: 'Context window unavailable.',
-      reasons: ['Current model does not expose a known context limit yet.'],
-      nextSteps: ['/provider', '/context'],
-      guidanceMode,
-      usagePct,
-      remainingTokens,
-      thresholdPct,
-      autoCompactEnabled,
-      sessionMemoryCount,
-      compactionCount,
-      lastCompactedAt,
-      compactRecommended: false,
-    };
-  }
-
-  if (input.session?.compactionState === 'failed') {
-    return {
-      level: 'needs-repair',
-      summary: 'Compaction needs operator repair.',
-      reasons: ['Compaction failed and the session may need manual recovery.'],
-      nextSteps: ['/compact', '/health review'],
-      guidanceMode,
-      usagePct,
-      remainingTokens,
-      thresholdPct,
-      autoCompactEnabled,
-      sessionMemoryCount,
-      compactionCount,
-      lastCompactedAt,
-      compactRecommended: true,
-    };
-  }
-
-  const reasons: string[] = [];
-  const nextSteps: string[] = [];
-  let summary = 'Session maintenance is stable.';
-  let compactRecommended = false;
-  let level: PanelSessionMaintenanceLevel = 'stable';
-
-  const atThreshold = autoCompactEnabled ? usagePct >= thresholdPct : usagePct >= 80;
-  if (atThreshold || remainingTokens <= 15_000) {
-    level = 'suggest-compact';
-    summary = `Compact now to recover context headroom (${usagePct}% used).`;
-    reasons.push(`Context pressure is high at ${usagePct}% usage.`);
-    nextSteps.push('/compact', '/panel tokens');
-    compactRecommended = true;
-  } else if (usagePct >= Math.max(70, autoCompactEnabled ? thresholdPct - 10 : 70) || staleByMessageGrowth) {
-    level = 'watch';
-    summary = staleByMessageGrowth
-      ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
-      : `Watch context growth (${usagePct}% used, threshold ${thresholdPct}%).`;
-    reasons.push(staleByMessageGrowth
-      ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
-      : `Context usage is climbing toward the ${thresholdPct > 0 ? `${thresholdPct}% auto-compact threshold` : 'maintenance band'}.`);
-    nextSteps.push('/panel tokens');
-  } else {
-    reasons.push('Context pressure is currently within the stable operating band.');
-  }
-
-  if (sessionMemoryCount > 0) {
-    reasons.push(`${sessionMemoryCount} pinned session memor${sessionMemoryCount === 1 ? 'y is' : 'ies are'} preserved during compaction.`);
-  }
-  if (compactionCount > 0) {
-    reasons.push(`Last compaction ran ${lastCompactedAt ? new Date(lastCompactedAt).toISOString() : 'recently'}.`);
-  }
-  if (!autoCompactEnabled) {
-    reasons.push('Auto-compaction is disabled; maintenance stays fully manual.');
-  }
-
-  return {
-    level,
-    summary,
-    reasons,
-    nextSteps,
-    guidanceMode,
-    usagePct,
-    remainingTokens,
-    thresholdPct,
-    autoCompactEnabled,
-    sessionMemoryCount,
-    compactionCount,
-    lastCompactedAt,
-    compactRecommended,
-  };
-}