@pellux/goodvibes-tui 1.13.1 → 1.15.0

package/src/input/commands/rewind-runtime.ts

@@ -0,0 +1,362 @@
+// ---------------------------------------------------------------------------
+// rewind-runtime.ts — /rewind (message-anchored, unified files + conversation),
+// plus the /undo rewind and /redo rewind reversals over the last receipt.
+//
+// The rewind engine is the SDK's UnifiedRewindService (platform/rewind:
+// plan() previews + issues a single-use confirm token; apply() is token-gated
+// and returns a receipt carrying an undo block). It JOINS the platform's three
+// existing history stores — it never adds a fourth. This module wires that
+// service to the TUI's in-process stores through the two ports the service
+// defines:
+//   • RewindWorkspacePort  ← the in-process WorkspaceCheckpointManager (the
+//     same store /checkpoints and the daemon's own files-rewind use). The port
+//     resolves an anchor's checkpoint by turnId across the session's turn
+//     checkpoints; the TUI does not stamp checkpoints with a sessionId, so the
+//     adapter returns the full checkpoint list and lets the shared turnId do the
+//     join (see rewind-turn-anchors.ts).
+//   • RewindConversationPort ← the in-process ConversationManager. preview()
+//     reports how many messages truncate to the recorded turn boundary;
+//     rewind() truncates and captures the pre- and post-truncation snapshots so
+//     /undo rewind and /redo rewind can reverse and re-apply it.
+// The undo/redo stacks stay TUI-side: the service reports how to reverse a
+// rewind (its receipt's undo block), and this module performs the reversal.
+//
+// The confirm step reuses the DiffPanel confirm idiom (PanelConfirmOverlay),
+// exactly like the former checkpoint-id /rewind this replaces (see the
+// architecture note in checkpoint-runtime.ts): the handler resolves the
+// anchor, previews the change, and arms the panel's confirm overlay; the actual
+// y/n handling lives in DiffPanel.handleInput().
+// ---------------------------------------------------------------------------
+
+import {
+  UnifiedRewindService,
+  type RewindAnchor,
+  type RewindCheckpointDiff,
+  type RewindCheckpointView,
+  type RewindReceipt,
+  type RewindRestoreResult,
+  type RewindScope as SdkRewindScope,
+  type RewindWorkspacePort,
+} from '@pellux/goodvibes-sdk/platform/rewind';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { buildRewindReceiptBlock } from '../../core/rewind-receipt.ts';
+import { getTurnAnchors, type TurnAnchor } from '../../core/rewind-turn-anchors.ts';
+import { createConversationRewindPort, type ConversationRewindPort } from '../../runtime/conversation-rewind-port.ts';
+import { requirePanelManager } from './runtime-services.ts';
+
+export type RewindScope = SdkRewindScope;
+const REWIND_SCOPES: readonly RewindScope[] = ['files', 'conversation', 'both'];
+
+// ---------------------------------------------------------------------------
+// Ports — bridge the SDK rewind service onto the TUI's in-process stores.
+// ---------------------------------------------------------------------------
+
+/**
+ * Workspace port over the in-process WorkspaceCheckpointManager. The manager's
+ * own list()/diff()/restore() satisfy the port shape; list() drops the
+ * service's sessionId filter because TUI turn checkpoints are joined by the
+ * shared turnId, not a stamped sessionId.
+ */
+function makeWorkspacePort(mgr: WorkspaceCheckpointManager): RewindWorkspacePort {
+  return {
+    async list(): Promise<readonly RewindCheckpointView[]> {
+      return mgr.list();
+    },
+    async diff(id: string): Promise<RewindCheckpointDiff> {
+      return mgr.diff(id);
+    },
+    async restore(id: string, opts?: { readonly safetyCheckpoint?: boolean | undefined }): Promise<RewindRestoreResult> {
+      return mgr.restore(id, opts);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Per-session rewind state — the SDK service (with its wired ports) plus the
+// TUI-owned undo/redo stacks of applied receipts.
+// ---------------------------------------------------------------------------
+
+interface RewindSessionState {
+  readonly service: UnifiedRewindService;
+  readonly convPort: ConversationRewindPort;
+  readonly undo: RewindReceipt[];
+  readonly redo: RewindReceipt[];
+}
+
+const sessions = new Map<string, RewindSessionState>();
+
+/** Get or build the per-session service, capturing the session's live stores. */
+function stateFor(ctx: CommandContext): RewindSessionState {
+  const sessionId = ctx.session.runtime.sessionId;
+  let state = sessions.get(sessionId);
+  if (!state) {
+    const mgr = ctx.workspace.workspaceCheckpointManager;
+    const conv = ctx.session.conversationManager;
+    const convPort = createConversationRewindPort(() => conv);
+    const service = new UnifiedRewindService({
+      workspace: mgr ? makeWorkspacePort(mgr) : null,
+      conversation: convPort,
+    });
+    state = { service, convPort, undo: [], redo: [] };
+    sessions.set(sessionId, state);
+  }
+  return state;
+}
+
+/** Reset a session's rewind state. Exposed for tests and session reset. */
+export function resetRewindState(sessionId: string): void {
+  sessions.delete(sessionId);
+}
+
+function wants(scope: RewindScope, part: 'files' | 'conversation'): boolean {
+  return scope === 'both' || scope === part;
+}
+
+function undoAvailable(receipt: RewindReceipt): boolean {
+  return receipt.undo.files !== null || receipt.undo.conversation !== null;
+}
+
+// ---------------------------------------------------------------------------
+// /undo rewind & /redo rewind — reversal over the last receipt's undo points.
+// Called from session-content.ts so the /undo and /redo commands stay single.
+// ---------------------------------------------------------------------------
+
+export interface RewindReversalResult {
+  readonly handled: boolean;
+  readonly message: string;
+}
+
+export async function undoLastRewind(ctx: CommandContext): Promise<RewindReversalResult> {
+  const state = stateFor(ctx);
+  const receipt = state.undo.pop();
+  if (!receipt) return { handled: false, message: 'No applied rewind to undo. (Bare /undo removes the last conversation turn.)' };
+
+  const mgr = ctx.workspace.workspaceCheckpointManager;
+  const parts: string[] = [];
+  try {
+    if (receipt.undo.files && mgr) {
+      await mgr.restore(receipt.undo.files.restoreCheckpointId, { safetyCheckpoint: false });
+      parts.push('files restored to pre-rewind state');
+    }
+    if (receipt.undo.conversation && state.convPort.restoreBefore(receipt.undo.conversation.undoSnapshotId)) {
+      parts.push('conversation restored to pre-rewind state');
+    }
+  } catch (err) {
+    state.undo.push(receipt);
+    return { handled: true, message: `Undo rewind failed: ${summarizeError(err)}` };
+  }
+  state.redo.push(receipt);
+  ctx.renderRequest();
+  return { handled: true, message: `Rewind undone: ${parts.join(', ') || 'nothing to reverse'}. Use /redo rewind to re-apply.` };
+}
+
+export async function redoLastRewind(ctx: CommandContext): Promise<RewindReversalResult> {
+  const state = stateFor(ctx);
+  const receipt = state.redo.pop();
+  if (!receipt) return { handled: false, message: 'No undone rewind to redo. (Bare /redo restores the last conversation turn.)' };
+
+  const mgr = ctx.workspace.workspaceCheckpointManager;
+  const parts: string[] = [];
+  try {
+    if (receipt.files?.checkpointId && mgr) {
+      await mgr.restore(receipt.files.checkpointId, { safetyCheckpoint: false });
+      parts.push('files re-applied');
+    }
+    if (receipt.undo.conversation && state.convPort.restoreAfter(receipt.undo.conversation.undoSnapshotId)) {
+      parts.push('conversation re-applied');
+    }
+  } catch (err) {
+    state.redo.push(receipt);
+    return { handled: true, message: `Redo rewind failed: ${summarizeError(err)}` };
+  }
+  state.undo.push(receipt);
+  ctx.renderRequest();
+  return { handled: true, message: `Rewind re-applied: ${parts.join(', ') || 'nothing to re-apply'}.` };
+}
+
+// ---------------------------------------------------------------------------
+// Recent-turns picker + anchor resolution
+// ---------------------------------------------------------------------------
+
+function formatAge(atMs: number, nowMs = Date.now()): string {
+  const s = Math.max(0, Math.floor((nowMs - atMs) / 1000));
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+/** Recent turns, NEWEST first, numbered 1..N for the picker. */
+function recentTurnsNewestFirst(sessionId: string): TurnAnchor[] {
+  return [...getTurnAnchors(sessionId)].reverse();
+}
+
+function renderTurnList(sessionId: string): string {
+  const turns = recentTurnsNewestFirst(sessionId);
+  if (turns.length === 0) {
+    return 'No completed turns recorded this run yet. /rewind targets turns completed in the current session run.';
+  }
+  const lines = ['Recent turns (newest first) — /rewind <n> [files|conversation|both]:'];
+  turns.slice(0, 20).forEach((t, i) => {
+    lines.push(`  ${String(i + 1).padStart(2)}. ${t.label}  (${formatAge(t.at)}, ${t.messageCount} msgs)`);
+  });
+  lines.push('Default scope is "both" (files + conversation). Files resolve only for turns that changed files.');
+  return lines.join('\n');
+}
+
+/** Resolve a user ref ('1'..'N' newest-first, or a turnId / turnId prefix) to an anchor turn. */
+function resolveRef(sessionId: string, ref: string): TurnAnchor | { error: string } {
+  const turns = recentTurnsNewestFirst(sessionId);
+  if (turns.length === 0) return { error: 'No completed turns recorded this run yet.' };
+  if (/^\d+$/.test(ref)) {
+    const idx = Number(ref) - 1;
+    const turn = turns[idx];
+    return turn ? turn : { error: `No turn #${ref}. Run /rewind to list recent turns (1–${turns.length}).` };
+  }
+  const exact = turns.find((t) => t.turnId === ref);
+  if (exact) return exact;
+  const prefix = turns.filter((t) => t.turnId.startsWith(ref));
+  if (prefix.length === 1) return prefix[0]!;
+  if (prefix.length > 1) return { error: `Turn ref "${ref}" is ambiguous (${prefix.length} matches). Use the list number instead.` };
+  return { error: `Unknown turn ref "${ref}". Run /rewind to list recent turns.` };
+}
+
+function parseScope(token: string | undefined): RewindScope | null {
+  if (token === undefined) return 'both';
+  const lower = token.toLowerCase();
+  return (REWIND_SCOPES as readonly string[]).includes(lower) ? (lower as RewindScope) : null;
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerRewindRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'rewind',
+    description: 'Rewind files, conversation, or both to a completed turn (preview + confirm)',
+    usage: '[<n|turnId> [files|conversation|both]]',
+    argsHint: '[<n> [files|conversation|both]]',
+    handler: async (args, ctx: CommandContext) => {
+      const sessionId = ctx.session.runtime.sessionId;
+
+      if (args.length === 0) {
+        ctx.print(renderTurnList(sessionId));
+        return;
+      }
+
+      const scope = parseScope(args[1]);
+      if (scope === null) {
+        ctx.print(`Unknown scope "${args[1]}". Use one of: files | conversation | both.`);
+        return;
+      }
+      const resolved = resolveRef(sessionId, args[0]!);
+      if ('error' in resolved) {
+        ctx.print(resolved.error);
+        return;
+      }
+      const anchor: RewindAnchor = { sessionId, turnId: resolved.turnId };
+
+      if (wants(scope, 'files') && !ctx.workspace.workspaceCheckpointManager) {
+        ctx.print('Checkpoints are not available in this session — files rewind cannot run. Try /rewind <n> conversation.');
+        return;
+      }
+
+      const state = stateFor(ctx);
+      const plan = await state.service.plan(anchor, scope).catch((err) => {
+        ctx.print(`Could not plan rewind: ${summarizeError(err)}`);
+        return null;
+      });
+      if (!plan) return;
+
+      const filesAvailable = plan.files?.available ?? false;
+      const conversationAvailable = plan.conversation?.available ?? false;
+      if (!filesAvailable && !conversationAvailable) {
+        ctx.print(`Nothing to rewind for turn "${resolved.label}" at scope ${scope}.`);
+        for (const w of plan.warnings) ctx.print(`  note: ${w}`);
+        return;
+      }
+
+      // Preview in the DiffPanel + arm its confirm overlay (same idiom the
+      // former checkpoint-id /rewind used — see checkpoint-runtime.ts).
+      const { DiffPanel } = await import('../../panels/diff-panel.ts');
+      const pm = requirePanelManager(ctx);
+      let panel = pm.getAllOpen().find((p) => p.id === 'diff');
+      if (!panel) {
+        try { panel = pm.open('diff'); } catch { ctx.print('Could not open diff panel.'); return; }
+      }
+      pm.activateById('diff');
+      if (!pm.isVisible()) pm.show();
+      ctx.focusPanels?.();
+      const diffPanel = panel as InstanceType<typeof DiffPanel>;
+
+      const checkpointId = plan.files?.checkpointId ?? null;
+      if (filesAvailable && checkpointId && ctx.workspace.workspaceCheckpointManager) {
+        try {
+          const diff = await ctx.workspace.workspaceCheckpointManager.diff(checkpointId);
+          if (diff.unifiedDiff.trim()) diffPanel.loadRawDiff(diff.unifiedDiff);
+          else diffPanel.showDiff('(no file changes)', '@@ -0,0 +0,0 @@\n Working tree already matches this checkpoint.');
+        } catch {
+          diffPanel.showDiff('(preview unavailable)', '@@ -0,0 +0,0 @@\n Could not load the checkpoint diff.');
+        }
+      } else {
+        const drop = plan.conversation?.messagesToDrop ?? 0;
+        const remaining = plan.conversation?.messagesRemaining ?? 0;
+        diffPanel.showDiff(
+          `Conversation rewind — drop ${drop} message(s)`,
+          `@@ rewind @@\n Keep ${remaining} message(s), drop ${drop} after this turn. No files change.`,
+        );
+      }
+
+      const summaryParts: string[] = [];
+      if (wants(scope, 'files')) summaryParts.push(filesAvailable ? `${plan.files?.affectedFileCount ?? 0} file(s)` : 'files: none');
+      if (wants(scope, 'conversation')) summaryParts.push(conversationAvailable ? `${plan.conversation?.messagesToDrop ?? 0} message(s)` : 'conversation: unavailable');
+
+      diffPanel.confirmOverlay.arm({
+        id: anchor.turnId ?? sessionId,
+        label: `${resolved.label} — rewind ${scope} (${summaryParts.join(', ')})`,
+        verb: 'Rewind',
+        onConfirm: async () => {
+          try {
+            const result = await state.service.apply(anchor, scope, { confirmToken: plan.token });
+            const receipt = result.receipt;
+            if (!receipt) {
+              ctx.print(`Rewind not applied: ${result.refusal?.reason ?? 'confirmation was refused.'}`);
+              return;
+            }
+            if (undoAvailable(receipt)) {
+              state.undo.push(receipt);
+              state.redo.length = 0; // a fresh apply invalidates the redo stack
+            }
+            // addTypedSystemMessage persists the receipt into real session
+            // history (indexed by getTranscriptEventIndex + save/load), and the
+            // [Rewind] prefix is force-surfaced inline (system-message-router.ts).
+            ctx.session.conversationManager.addTypedSystemMessage(
+              buildRewindReceiptBlock({ ...receipt, undoAvailable: undoAvailable(receipt) }),
+              'operational',
+            );
+            pm.close('diff');
+            ctx.focusPrompt?.();
+            ctx.renderRequest();
+          } catch (err) {
+            ctx.print(`Rewind failed: ${summarizeError(err)}`);
+          }
+        },
+        onCancel: () => {
+          ctx.print('Rewind cancelled — nothing changed.');
+          pm.close('diff');
+          ctx.focusPrompt?.();
+          ctx.renderRequest();
+        },
+      });
+
+      ctx.print(`Previewing rewind of turn "${resolved.label}" (${scope}: ${summaryParts.join(', ')}). Confirm in the diff panel: Enter/y to rewind, n/Esc to cancel.`);
+      for (const w of plan.warnings) ctx.print(`  note: ${w}`);
+      ctx.renderRequest();
+    },
+  });
+}

package/src/input/commands/schedule-nl.ts

@@ -0,0 +1,147 @@
+/**
+ * Local natural-language schedule parsing for `/schedule add when "<phrase>"`.
+ *
+ * Parses common English scheduling phrases entirely offline into one of the
+ * three concrete schedule shapes the automation manager already understands —
+ * `cron`, `every` (fixed interval), or `at` (one-shot timestamp) — and returns
+ * a plain-English description of exactly what it decided, so the caller can
+ * ALWAYS echo the concrete interpretation back to the user before anything is
+ * saved.
+ *
+ * This is intentionally a bounded, predictable grammar rather than a fuzzy
+ * date library: it recognizes a fixed set of shapes and reports an honest error
+ * for anything it does not understand, so the user is never silently given a
+ * schedule that does not match what they typed.
+ */
+
+export type ParsedSchedule =
+  | { readonly kind: 'cron'; readonly expression: string; readonly description: string }
+  | { readonly kind: 'every'; readonly interval: string; readonly description: string }
+  | { readonly kind: 'at'; readonly at: number; readonly description: string }
+  | { readonly kind: 'error'; readonly error: string };
+
+const DOW: Record<string, number> = {
+  sunday: 0, sun: 0,
+  monday: 1, mon: 1,
+  tuesday: 2, tue: 2, tues: 2,
+  wednesday: 3, wed: 3,
+  thursday: 4, thu: 4, thurs: 4,
+  friday: 5, fri: 5,
+  saturday: 6, sat: 6,
+};
+
+const DOW_NAME = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+/** Parse "9am", "9:30pm", "14:00", "9" → {hour, minute} in 24h, or null. */
+function parseTimeOfDay(raw: string): { hour: number; minute: number } | null {
+  const m = raw.trim().toLowerCase().match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (!m) return null;
+  let hour = Number(m[1]);
+  const minute = m[2] ? Number(m[2]) : 0;
+  const meridiem = m[3];
+  if (minute > 59) return null;
+  if (meridiem === 'am') {
+    if (hour < 1 || hour > 12) return null;
+    if (hour === 12) hour = 0;
+  } else if (meridiem === 'pm') {
+    if (hour < 1 || hour > 12) return null;
+    if (hour !== 12) hour += 12;
+  } else if (hour > 23) {
+    return null;
+  }
+  return { hour, minute };
+}
+
+function fmtTime(hour: number, minute: number): string {
+  return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
+const UNIT_MS: Record<string, number> = {
+  second: 1000, seconds: 1000, sec: 1000, secs: 1000,
+  minute: 60_000, minutes: 60_000, min: 60_000, mins: 60_000,
+  hour: 3_600_000, hours: 3_600_000, hr: 3_600_000, hrs: 3_600_000,
+  day: 86_400_000, days: 86_400_000,
+};
+
+/** Parse a natural-language scheduling phrase into a concrete schedule. */
+export function parseNaturalLanguageSchedule(phrase: string, now: number = Date.now()): ParsedSchedule {
+  const text = phrase.trim().toLowerCase().replace(/\s+/g, ' ');
+  if (!text) return { kind: 'error', error: 'Empty schedule phrase.' };
+
+  // "at HH..." with an optional day anchor → one-shot `at`.
+  const relIn = text.match(/^in (\d+) (second|seconds|sec|secs|minute|minutes|min|mins|hour|hours|hr|hrs|day|days)$/);
+  if (relIn) {
+    const unitMs = UNIT_MS[relIn[2]!]!;
+    const at = now + Number(relIn[1]) * unitMs;
+    return { kind: 'at', at, description: `once at ${new Date(at).toLocaleString()}` };
+  }
+
+  // Shorthand words.
+  if (text === 'hourly') return { kind: 'cron', expression: '0 * * * *', description: 'every hour, on the hour' };
+  if (text === 'daily') return { kind: 'cron', expression: '0 0 * * *', description: 'every day at 00:00' };
+  if (text === 'weekly') return { kind: 'cron', expression: '0 0 * * 0', description: 'every week on Sunday at 00:00' };
+
+  // "every <n> <unit>" → fixed interval.
+  const everyN = text.match(/^every (\d+) (second|seconds|sec|secs|minute|minutes|min|mins|hour|hours|hr|hrs|day|days)$/);
+  if (everyN) {
+    const n = everyN[1]!;
+    const unit = everyN[2]!;
+    const short = unit.startsWith('sec') ? 's' : unit.startsWith('min') ? 'm' : unit.startsWith('h') ? 'h' : 'd';
+    return { kind: 'every', interval: `${n}${short}`, description: `every ${n} ${unit}` };
+  }
+
+  // "every <unit>" (singular) → interval of 1 unit.
+  const everyUnit = text.match(/^every (second|minute|hour|day)$/);
+  if (everyUnit) {
+    const unit = everyUnit[1]!;
+    const short = unit === 'second' ? 's' : unit === 'minute' ? 'm' : unit === 'hour' ? 'h' : 'd';
+    return { kind: 'every', interval: `1${short}`, description: `every ${unit}` };
+  }
+
+  // Time-of-day driven cron forms. Extract a trailing "at <time>", default midnight.
+  const atMatch = text.match(/(?:^|\s)at (\d{1,2}(?::\d{2})?\s*(?:am|pm)?)$/);
+  const timeStr = atMatch ? atMatch[1]! : null;
+  const time = timeStr ? parseTimeOfDay(timeStr) : { hour: 0, minute: 0 };
+  if (timeStr && !time) return { kind: 'error', error: `Could not understand the time "${timeStr}".` };
+  const head = atMatch ? text.slice(0, text.length - atMatch[0].length).trim() : text;
+  const { hour, minute } = time!;
+
+  // "every day" / "everyday" / "daily at <time>".
+  if (head === 'every day' || head === 'everyday' || head === 'daily') {
+    return { kind: 'cron', expression: `${minute} ${hour} * * *`, description: `every day at ${fmtTime(hour, minute)}` };
+  }
+
+  // "every weekday" / "weekdays".
+  if (head === 'every weekday' || head === 'weekdays' || head === 'every weekdays') {
+    return { kind: 'cron', expression: `${minute} ${hour} * * 1-5`, description: `every weekday (Mon-Fri) at ${fmtTime(hour, minute)}` };
+  }
+
+  // "every weekend" / "weekends".
+  if (head === 'every weekend' || head === 'weekends' || head === 'every weekends') {
+    return { kind: 'cron', expression: `${minute} ${hour} * * 0,6`, description: `every weekend (Sat-Sun) at ${fmtTime(hour, minute)}` };
+  }
+
+  // "every <weekday>" / "every monday" etc.
+  const everyDow = head.match(/^every (\w+)$/) ?? head.match(/^(\w+)s$/);
+  if (everyDow) {
+    const day = everyDow[1]!;
+    const dow = DOW[day] ?? DOW[day.replace(/s$/, '')];
+    if (dow !== undefined) {
+      return { kind: 'cron', expression: `${minute} ${hour} * * ${dow}`, description: `every ${DOW_NAME[dow]} at ${fmtTime(hour, minute)}` };
+    }
+  }
+
+  // Bare "at <time>" → one-shot at the next occurrence of that time today/tomorrow.
+  if (timeStr && head === '') {
+    const next = new Date(now);
+    next.setSeconds(0, 0);
+    next.setHours(hour, minute, 0, 0);
+    if (next.getTime() <= now) next.setDate(next.getDate() + 1);
+    return { kind: 'at', at: next.getTime(), description: `once at ${next.toLocaleString()}` };
+  }
+
+  return {
+    kind: 'error',
+    error: `Could not parse "${phrase}". Try phrases like "every weekday at 9am", "every 30 minutes", "daily at 6pm", "every monday at 08:00", or "in 2 hours".`,
+  };
+}

package/src/input/commands/schedule-runtime.ts

@@ -10,6 +10,7 @@ import type { AutomationManager } from '@pellux/goodvibes-sdk/platform/automatio
 import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
 import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { parseNaturalLanguageSchedule } from './schedule-nl.ts';
 import type {
   AutomationExecutionPolicy,
   AutomationExternalContentSource,
@@ -91,8 +92,8 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
     name: 'schedule',
     aliases: ['sched'],
     description: 'Manage automation jobs and scheduled runs',
-    usage: 'add <cron|every|at> <value> <prompt...> | list | remove <id> | enable <id> | disable <id> | run <id>',
-    argsHint: 'add cron <expr> | add every <interval> | add at <timestamp> | list | remove | enable | disable | run',
+    usage: 'add <cron|every|at|when> <value> <prompt...> | list | remove <id> | enable <id> | disable <id> | run <id>',
+    argsHint: 'add cron <expr> | add every <interval> | add at <timestamp> | add when "<natural language>" | list | remove | enable | disable | run',
     async handler(args, ctx) {
       const manager = ctx.ops.automationManager;
       if (!manager) {
@@ -134,12 +135,13 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
             'Usage:\n'
             + '  /schedule add cron "<expr>" <prompt...> [--name <name>] [--model <model>] [--provider <provider>] [--template <tmpl>] [--tz <timezone>] [--stagger <ms>]\n'
             + '  /schedule add every <interval> <prompt...> [--name <name>] [--model <model>] [--provider <provider>] [--template <tmpl>]\n'
-            + '  /schedule add at <timestamp> <prompt...> [--name <name>] [--model <model>] [--provider <provider>] [--template <tmpl>]'
+            + '  /schedule add at <timestamp> <prompt...> [--name <name>] [--model <model>] [--provider <provider>] [--template <tmpl>]\n'
+            + '  /schedule add when "<natural language, e.g. every weekday at 9am>" <prompt...>'
           );
           return;
         }
 
-        const legacyCronMode = scheduleKind !== 'cron' && scheduleKind !== 'every' && scheduleKind !== 'at';
+        const legacyCronMode = scheduleKind !== 'cron' && scheduleKind !== 'every' && scheduleKind !== 'at' && scheduleKind !== 'when';
         const scheduleArg = legacyCronMode ? args[1] : args[2];
         const valueStartIndex = legacyCronMode ? 2 : 3;
         if (!scheduleArg) {
@@ -215,13 +217,30 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         }
 
         try {
-          const schedule = legacyCronMode
-            ? normalizeCronSchedule(scheduleArg, timezone, staggerMs)
-            : scheduleKind === 'cron'
+          let schedule: AutomationScheduleDefinition;
+          if (scheduleKind === 'when') {
+            // Natural-language phrase: parse locally, ALWAYS echo the concrete
+            // interpretation before saving so nothing is scheduled silently.
+            const parsed = parseNaturalLanguageSchedule(scheduleArg);
+            if (parsed.kind === 'error') {
+              ctx.print(`Error: ${parsed.error}`);
+              return;
+            }
+            schedule = parsed.kind === 'cron'
+              ? normalizeCronSchedule(parsed.expression, timezone, staggerMs)
+              : parsed.kind === 'every'
+                ? normalizeEverySchedule(parsed.interval)
+                : normalizeAtSchedule(parsed.at);
+            ctx.print(`Interpreted "${scheduleArg}" as: ${parsed.description}\n  → ${formatSchedule(schedule)}`);
+          } else {
+            schedule = legacyCronMode
               ? normalizeCronSchedule(scheduleArg, timezone, staggerMs)
-              : scheduleKind === 'every'
-                ? normalizeEverySchedule(scheduleArg)
-                : normalizeAtSchedule(parseAtValue(scheduleArg));
+              : scheduleKind === 'cron'
+                ? normalizeCronSchedule(scheduleArg, timezone, staggerMs)
+                : scheduleKind === 'every'
+                  ? normalizeEverySchedule(scheduleArg)
+                  : normalizeAtSchedule(parseAtValue(scheduleArg));
+          }
           const job = await manager.createJob({
             name: name ?? prompt.slice(0, 40),
             prompt,

package/src/input/commands/secret-runtime.ts

@@ -0,0 +1,55 @@
+/**
+ * /secret — capture a password-like value through the composer's concealed
+ * input mode, without the plaintext ever appearing in the transcript or input
+ * history.
+ *
+ * This is the user-facing demonstration of the generalized concealed-input
+ * affordance (see src/input/concealed-input.ts): the same masking that used to
+ * live only on the local-auth and onboarding surfaces, now reachable for any
+ * password-like prompt. The captured value is written to a process environment
+ * variable so a subsequent shell command / tool run can read it, while the
+ * transcript only ever shows a redacted confirmation.
+ */
+
+import type { CommandRegistry } from '../command-registry.ts';
+
+/** Normalize a requested name into a conventional env-var identifier. */
+function toEnvVarName(raw: string): string {
+  return raw.trim().replace(/[^A-Za-z0-9_]/g, '_').replace(/^_+|_+$/g, '').toUpperCase();
+}
+
+export function registerSecretRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'secret',
+    description: 'Enter a secret with concealed (masked) input and store it as an environment variable — plaintext never enters the transcript',
+    usage: '/secret <NAME>',
+    argsHint: '<NAME>',
+    handler(args, ctx) {
+      const name = toEnvVarName(args[0] ?? '');
+      if (!name) {
+        ctx.print('[Secret] Usage: /secret <NAME> — the value is typed on the next line with the keystrokes masked.');
+        return;
+      }
+      if (!ctx.beginConcealedInput) {
+        ctx.print('[Secret] Concealed input is not available on this surface.');
+        return;
+      }
+      ctx.print(`[Secret] Enter value for ${name} (input is masked; press Enter to store, Esc to cancel).`);
+      ctx.beginConcealedInput({
+        label: name,
+        onSubmit: (value) => {
+          if (value.length === 0) {
+            ctx.print(`[Secret] ${name} not set (empty value).`);
+            return;
+          }
+          process.env[name] = value;
+          // Never echo the value — only a redacted confirmation of length.
+          ctx.print(`[Secret] Stored ${name} (${value.length} character${value.length === 1 ? '' : 's'}, value hidden). Available to shell/tool runs as $${name}.`);
+        },
+        onCancel: () => {
+          ctx.print(`[Secret] ${name} cancelled.`);
+        },
+      });
+    },
+  });
+}