@pellux/goodvibes-tui 0.18.4

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

@@ -0,0 +1,279 @@
+import type {
+  CommandContext,
+  CommandExtensionServices,
+  CommandOpsServices,
+  CommandPlatformServices,
+  CommandProviderServices,
+  CommandSessionServices,
+  CommandWorkspaceServices,
+} from '../command-registry.ts';
+import type { UiReadModels } from '../../runtime/ui-read-models.ts';
+import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+import type { EcosystemCatalogPathOptions } from '../../runtime/ecosystem/catalog.ts';
+import type { PluginPathOptions } from '../../plugins/loader.ts';
+import type { DirectTransport } from '../../runtime/transports/direct.ts';
+import type { KnowledgeApi } from '../../knowledge/knowledge-api.ts';
+import type { HookApi } from '../../hooks/hook-api.ts';
+import type { McpApi } from '../../mcp/mcp-api.ts';
+import type { OperatorClient } from '../../runtime/operator-client.ts';
+import type { OpsApi } from '../../runtime/ops-api.ts';
+import type { PeerClient } from '../../runtime/peer-client.ts';
+import type { ProviderApi } from '../../providers/provider-api.ts';
+import type {
+  ShellAgentManagerService,
+  ShellAcpManagerService,
+  ShellAutomationManagerService,
+  ShellAutomationManagerRuntimeService,
+  ShellModeManagerService,
+  ShellPlanManagerService,
+  ShellSessionOrchestrationService,
+} from '../../runtime/shell-command-ops.ts';
+
+function requireContextValue<T>(value: T | null | undefined, name: string): T {
+  if (value == null) {
+    throw new Error(`commandContext.${name} is required but was not wired at bootstrap`);
+  }
+  return value;
+}
+
+export function requireSession(context: CommandContext): CommandSessionServices {
+  return context.session;
+}
+
+export function requireProvider(context: CommandContext): CommandProviderServices {
+  return context.provider;
+}
+
+export function requireWorkspace(context: CommandContext): CommandWorkspaceServices {
+  return context.workspace;
+}
+
+export function requirePlatform(context: CommandContext): CommandPlatformServices {
+  return context.platform;
+}
+
+export function requireOps(context: CommandContext): CommandOpsServices {
+  return context.ops;
+}
+
+export function requireExtensions(context: CommandContext): CommandExtensionServices {
+  return context.extensions;
+}
+
+export function requireReadModels(context: CommandContext): UiReadModels {
+  return requireContextValue(context.platform.readModels, 'platform.readModels');
+}
+
+export function requireShellPaths(context: Pick<CommandContext, 'workspace'>): ShellPathService {
+  return requireContextValue(context.workspace.shellPaths, 'workspace.shellPaths');
+}
+
+export function requireEcosystemCatalogPaths(
+  context: CommandContext,
+): EcosystemCatalogPathOptions {
+  const shellPaths = requireShellPaths(context);
+  return {
+    cwd: shellPaths.workingDirectory,
+    homeDir: shellPaths.homeDirectory,
+  };
+}
+
+export function requirePluginPathOptions(
+  context: CommandContext,
+): PluginPathOptions {
+  const shellPaths = requireShellPaths(context);
+  return {
+    cwd: shellPaths.workingDirectory,
+    homeDir: shellPaths.homeDirectory,
+  };
+}
+
+export function openCommandPanel(
+  context: Pick<CommandContext, 'showPanel'>,
+  panelId: string,
+  pane?: 'top' | 'bottom',
+): void {
+  const showPanel = requireContextValue(context.showPanel, 'showPanel');
+  showPanel(panelId, pane);
+}
+
+export function requireKeybindingsManager(context: CommandContext) {
+  return requireContextValue(context.workspace.keybindingsManager, 'workspace.keybindingsManager');
+}
+
+export function requireProfileManager(context: CommandContext) {
+  return requireContextValue(context.workspace.profileManager, 'workspace.profileManager');
+}
+
+export function requirePanelManager(context: CommandContext) {
+  return requireContextValue(context.workspace.panelManager, 'workspace.panelManager');
+}
+
+export function requireBookmarkManager(context: CommandContext) {
+  return requireContextValue(context.workspace.bookmarkManager, 'workspace.bookmarkManager');
+}
+
+export function requireSessionManager(context: CommandContext) {
+  return requireContextValue(context.session.sessionManager, 'session.sessionManager');
+}
+
+export function requireSecretsManager(context: CommandContext) {
+  return requireContextValue(context.platform.secretsManager, 'platform.secretsManager');
+}
+
+export function requireSubscriptionManager(context: CommandContext) {
+  return requireContextValue(context.platform.subscriptionManager, 'platform.subscriptionManager');
+}
+
+export function requireServiceRegistry(context: CommandContext) {
+  return requireContextValue(context.platform.serviceRegistry, 'platform.serviceRegistry');
+}
+
+export function requireLocalUserAuthManager(context: CommandContext) {
+  return requireContextValue(context.platform.localUserAuthManager, 'platform.localUserAuthManager');
+}
+
+export function requireTokenAuditor(context: CommandContext) {
+  return requireContextValue(context.platform.tokenAuditor, 'platform.tokenAuditor');
+}
+
+export function requireReplayEngine(context: CommandContext) {
+  return requireContextValue(context.platform.replayEngine, 'platform.replayEngine');
+}
+
+export function requireWebhookNotifier(context: CommandContext) {
+  return requireContextValue(context.platform.webhookNotifier, 'platform.webhookNotifier');
+}
+
+export function requireSessionMemoryStore(context: CommandContext) {
+  return requireContextValue(context.session.sessionMemoryStore, 'session.sessionMemoryStore');
+}
+
+export function requireSessionLineageTracker(context: CommandContext) {
+  return requireContextValue(context.session.sessionLineageTracker, 'session.sessionLineageTracker');
+}
+
+export function requireSessionChangeTracker(context: CommandContext) {
+  return requireContextValue(context.session.changeTracker, 'session.changeTracker');
+}
+
+export function requirePlanManager(context: CommandContext): ShellPlanManagerService {
+  return requireContextValue(context.ops.planManager, 'ops.planManager') as ShellPlanManagerService;
+}
+
+export function requireAdaptivePlanner(context: CommandContext): unknown {
+  return requireContextValue(context.ops.adaptivePlanner, 'ops.adaptivePlanner');
+}
+
+export function requireSessionOrchestration(context: CommandContext): ShellSessionOrchestrationService {
+  return requireContextValue(context.ops.sessionOrchestration, 'ops.sessionOrchestration') as ShellSessionOrchestrationService;
+}
+
+export function requireForensicsRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.forensicsRegistry, 'extensions.forensicsRegistry');
+}
+
+export function requirePluginManager(context: CommandContext) {
+  return requireContextValue(context.extensions.pluginManager, 'extensions.pluginManager');
+}
+
+export function requirePolicyRuntimeState(context: CommandContext) {
+  return requireContextValue(context.extensions.policyRuntimeState, 'extensions.policyRuntimeState');
+}
+
+export function requireMcpRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.mcpRegistry, 'extensions.mcpRegistry');
+}
+
+export function requireToolRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.toolRegistry, 'extensions.toolRegistry');
+}
+
+export function requireHookWorkbench(context: CommandContext) {
+  return requireContextValue(context.extensions.hookWorkbench, 'extensions.hookWorkbench');
+}
+
+export function requireIntegrationHelpers(context: CommandContext) {
+  return requireContextValue(context.extensions.integrationHelpers, 'extensions.integrationHelpers');
+}
+
+export function requireProviderOptimizer(context: CommandContext) {
+  return requireContextValue(context.provider.providerOptimizer, 'provider.providerOptimizer');
+}
+
+export function requireFavoritesStore(context: CommandContext) {
+  return requireContextValue(context.provider.favoritesStore, 'provider.favoritesStore');
+}
+
+export function requireBenchmarkStore(context: CommandContext) {
+  return requireContextValue(context.provider.benchmarkStore, 'provider.benchmarkStore');
+}
+
+export function requireRemoteRuntime(context: CommandContext) {
+  return requireContextValue(context.ops.remoteRuntime, 'ops.remoteRuntime');
+}
+
+export function requireOperatorClient(context: CommandContext): OperatorClient {
+  return requireContextValue(context.clients?.operator, 'clients.operator');
+}
+
+export function requirePeerClient(context: CommandContext): PeerClient {
+  return requireContextValue(context.clients?.peer, 'clients.peer');
+}
+
+export function requireProviderApi(context: CommandContext): ProviderApi {
+  return requireContextValue(context.clients?.providerApi, 'clients.providerApi');
+}
+
+export async function compactConversation(context: CommandContext): Promise<void> {
+  await context.session.conversationManager.compact(
+    context.provider.providerRegistry,
+    context.session.runtime.model,
+    'manual',
+    context.session.runtime.provider,
+  );
+}
+
+export function requireKnowledgeApi(context: CommandContext): KnowledgeApi {
+  return requireContextValue(context.clients?.knowledgeApi, 'clients.knowledgeApi');
+}
+
+export function requireHookApi(context: CommandContext): HookApi {
+  return requireContextValue(context.clients?.hookApi, 'clients.hookApi');
+}
+
+export function requireMcpApi(context: CommandContext): McpApi {
+  return requireContextValue(context.clients?.mcpApi, 'clients.mcpApi');
+}
+
+export function requireOpsApi(context: CommandContext): OpsApi {
+  return requireContextValue(context.clients?.opsApi, 'clients.opsApi');
+}
+
+export function requireDirectTransport(context: CommandContext): DirectTransport {
+  return requireContextValue(context.clients?.transport, 'clients.transport');
+}
+
+export function requireAgentManager(context: CommandContext): ShellAgentManagerService {
+  return requireContextValue(context.ops.agentManager, 'ops.agentManager') as ShellAgentManagerService;
+}
+
+export function requireAcpManager(context: CommandContext): ShellAcpManagerService {
+  return requireContextValue(context.ops.acpManager, 'ops.acpManager') as ShellAcpManagerService;
+}
+
+export function requireModeManager(context: CommandContext): ShellModeManagerService {
+  return requireContextValue(context.ops.modeManager, 'ops.modeManager') as ShellModeManagerService;
+}
+
+export function requireAutomationManager(context: CommandContext): ShellAutomationManagerRuntimeService {
+  return requireContextValue(context.ops.automationManager, 'ops.automationManager') as ShellAutomationManagerRuntimeService;
+}
+
+export function requireSandboxSessionRegistry(context: CommandContext) {
+  return requireContextValue(context.workspace.sandboxSessionRegistry, 'workspace.sandboxSessionRegistry');
+}
+
+export function requireWorktreeRegistry(context: CommandContext) {
+  return requireContextValue(context.workspace.worktreeRegistry, 'workspace.worktreeRegistry');
+}

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

@@ -0,0 +1,332 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import {
+  formatEveryInterval,
+  normalizeCronStaggerMs,
+  normalizeAtSchedule,
+  normalizeCronSchedule,
+  normalizeEverySchedule,
+} from '../../automation/index.ts';
+import type { AutomationManager } from '../../automation/index.ts';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import type {
+  AutomationExecutionPolicy,
+  AutomationExternalContentSource,
+  AutomationSessionTarget,
+  AutomationWakeMode,
+} from '@pellux/goodvibes-sdk/platform/automation/session-targets';
+
+function formatSchedule(schedule: AutomationScheduleDefinition): string {
+  switch (schedule.kind) {
+    case 'cron':
+      return [
+        schedule.expression,
+        schedule.timezone ? `[${schedule.timezone}]` : '',
+        schedule.staggerMs !== undefined ? `[stagger ${schedule.staggerMs}ms]` : '',
+      ].filter(Boolean).join(' ');
+    case 'every':
+      return formatEveryInterval(schedule.intervalMs);
+    case 'at':
+      return new Date(schedule.at).toLocaleString();
+  }
+}
+
+function parseAutomationTarget(raw: string | undefined): AutomationSessionTarget | undefined {
+  if (!raw) return undefined;
+  const value = raw.trim();
+  if (!value) return undefined;
+  if (value.startsWith('session:')) {
+    return { kind: 'session', sessionId: value.slice('session:'.length), createIfMissing: true };
+  }
+  if (value.startsWith('route:')) {
+    return { kind: 'route', routeId: value.slice('route:'.length), preserveThread: true };
+  }
+  if (value === 'main' || value === 'current' || value === 'isolated' || value === 'pinned' || value === 'background') {
+    return { kind: value, createIfMissing: true };
+  }
+  return { kind: 'session', sessionId: value, createIfMissing: true };
+}
+
+function parseReasoningEffort(raw: string | undefined): AutomationExecutionPolicy['reasoningEffort'] | undefined {
+  if (!raw) return undefined;
+  if (raw === 'instant' || raw === 'low' || raw === 'medium' || raw === 'high') return raw;
+  throw new Error(`Invalid reasoning effort: "${raw}". Use instant, low, medium, or high.`);
+}
+
+function parseWakeMode(raw: string | undefined): AutomationWakeMode | undefined {
+  if (!raw) return undefined;
+  if (raw === 'now' || raw === 'next-heartbeat') return raw;
+  throw new Error(`Invalid wake mode: "${raw}". Use now or next-heartbeat.`);
+}
+
+function parseFallbackModels(raw: string | undefined): string[] | undefined {
+  if (!raw) return undefined;
+  return raw.split(',').map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+
+function formatNextRun(nextRunAt?: number): string {
+  return nextRunAt ? new Date(nextRunAt).toLocaleString() : 'n/a';
+}
+
+function formatPrompt(job: AutomationJob): string {
+  const prompt = (job.execution.prompt ?? job.description ?? '').trim();
+  return prompt.length > 60 ? `${prompt.slice(0, 60)}...` : prompt;
+}
+
+function resolveJob(manager: AutomationManager, id: string): AutomationJob | undefined {
+  return manager.listJobs().find((job) => job.id === id || job.id.startsWith(id));
+}
+
+function parseAtValue(raw: string): number {
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid date/time: "${raw}". Use an ISO timestamp or a format Date.parse understands.`);
+  }
+  return parsed;
+}
+
+export function registerScheduleRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    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',
+    async handler(args, ctx) {
+      const manager = ctx.ops.automationManager;
+      if (!manager) {
+        ctx.print('Automation manager is not available in this runtime.');
+        return;
+      }
+      await manager.start();
+      const sub = args[0];
+
+      if (!sub || sub === 'list') {
+        const jobs = manager.listJobs();
+        if (jobs.length === 0) {
+          ctx.print(
+            'No automation jobs.\n'
+            + 'Use:\n'
+            + '  /schedule add cron "*/30 * * * *" "check build status"\n'
+            + '  /schedule add every 15m "summarize open PRs"\n'
+            + '  /schedule add at 2026-04-10T09:00:00 "send release reminder"'
+          );
+          return;
+        }
+        const lines = ['Automation jobs:', ''];
+        for (const job of jobs) {
+          const status = job.enabled ? '● enabled ' : '○ paused  ';
+          const next = formatNextRun(job.nextRunAt);
+          const last = job.lastRunAt ? new Date(job.lastRunAt).toLocaleString() : 'never';
+          lines.push(`  ${job.id.slice(0, 12)}  ${status} runs:${job.runCount}  next:${next}  last:${last}`);
+          lines.push(`    name: ${job.name}  schedule: ${formatSchedule(job.schedule)}`);
+          lines.push(`    prompt: ${formatPrompt(job)}`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'add') {
+        const scheduleKind = args[1];
+        if (!scheduleKind) {
+          ctx.print(
+            '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>]'
+          );
+          return;
+        }
+
+        const legacyCronMode = scheduleKind !== 'cron' && scheduleKind !== 'every' && scheduleKind !== 'at';
+        const scheduleArg = legacyCronMode ? args[1] : args[2];
+        const valueStartIndex = legacyCronMode ? 2 : 3;
+        if (!scheduleArg) {
+          ctx.print('Missing schedule value.');
+          return;
+        }
+
+        let name: string | undefined;
+        let model: string | undefined;
+        let provider: string | undefined;
+        let template: string | undefined;
+        let timezone: string | undefined;
+        let staggerMs: number | undefined;
+        let target: AutomationSessionTarget | undefined;
+        let reasoningEffort: AutomationExecutionPolicy['reasoningEffort'] | undefined;
+        let thinking: string | undefined;
+        let wakeMode: AutomationWakeMode | undefined;
+        let fallbackModels: string[] | undefined;
+        let externalContentSource: AutomationExternalContentSource | undefined;
+        let allowUnsafeExternalContent: boolean | undefined;
+        let lightContext: boolean | undefined;
+        const toolAllowlist: string[] = [];
+        const promptWords: string[] = [];
+        try {
+          for (let i = valueStartIndex; i < args.length; i++) {
+            const token = args[i]!;
+            if (token === '--name' && i + 1 < args.length) {
+              name = args[++i];
+            } else if (token === '--model' && i + 1 < args.length) {
+              model = args[++i];
+            } else if (token === '--provider' && i + 1 < args.length) {
+              provider = args[++i];
+            } else if (token === '--template' && i + 1 < args.length) {
+              template = args[++i];
+            } else if ((token === '--tz' || token === '--timezone') && i + 1 < args.length) {
+              timezone = args[++i];
+            } else if (token === '--stagger' && i + 1 < args.length) {
+              const parsed = normalizeCronStaggerMs(args[++i]);
+              if (parsed === undefined) throw new Error(`Invalid stagger window: "${args[i]}"`);
+              staggerMs = parsed;
+            } else if (token === '--target' && i + 1 < args.length) {
+              target = parseAutomationTarget(args[++i]);
+            } else if (token === '--reasoning' && i + 1 < args.length) {
+              reasoningEffort = parseReasoningEffort(args[++i]);
+            } else if (token === '--thinking' && i + 1 < args.length) {
+              thinking = args[++i];
+            } else if (token === '--wake' && i + 1 < args.length) {
+              wakeMode = parseWakeMode(args[++i]);
+            } else if ((token === '--fallback' || token === '--fallbacks') && i + 1 < args.length) {
+              fallbackModels = parseFallbackModels(args[++i]);
+            } else if (token === '--tool' && i + 1 < args.length) {
+              const tool = args[++i]?.trim();
+              if (tool) toolAllowlist.push(tool);
+            } else if (token === '--external-source' && i + 1 < args.length) {
+              externalContentSource = args[++i] as AutomationExternalContentSource;
+            } else if (token === '--allow-unsafe-external-content') {
+              allowUnsafeExternalContent = true;
+            } else if (token === '--light-context') {
+              lightContext = true;
+            } else {
+              promptWords.push(token);
+            }
+          }
+        } catch (error) {
+          ctx.print(`Error: ${summarizeError(error)}`);
+          return;
+        }
+
+        const prompt = promptWords.join(' ').trim();
+        if (!prompt) {
+          ctx.print('Missing prompt text for automation job.');
+          return;
+        }
+
+        try {
+          const schedule = legacyCronMode
+            ? normalizeCronSchedule(scheduleArg, timezone, staggerMs)
+            : 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,
+            schedule,
+            description: prompt,
+            model,
+            provider,
+            fallbackModels,
+            template,
+            target,
+            reasoningEffort,
+            thinking,
+            wakeMode,
+            toolAllowlist: toolAllowlist.length > 0 ? toolAllowlist : undefined,
+            allowUnsafeExternalContent,
+            externalContentSource,
+            lightContext,
+            enabled: true,
+          });
+          ctx.print(
+            `Automation job created: ${job.id}\n`
+            + `  name: ${job.name}\n`
+            + `  schedule: ${formatSchedule(job.schedule)}\n`
+            + `  next run: ${formatNextRun(job.nextRunAt)}`
+          );
+        } catch (error) {
+          ctx.print(`Error: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
+      if (sub === 'remove') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /schedule remove <id>');
+          return;
+        }
+        const job = resolveJob(manager, id);
+        if (!job) {
+          ctx.print(`Automation job not found: ${id}`);
+          return;
+        }
+        await manager.removeJob(job.id);
+        ctx.print(`Removed automation job: ${job.id} (${job.name})`);
+        return;
+      }
+
+      if (sub === 'enable' || sub === 'disable') {
+        const id = args[1];
+        if (!id) {
+          ctx.print(`Usage: /schedule ${sub} <id>`);
+          return;
+        }
+        const job = resolveJob(manager, id);
+        if (!job) {
+          ctx.print(`Automation job not found: ${id}`);
+          return;
+        }
+        const updated = await manager.setEnabled(job.id, sub === 'enable');
+        if (!updated) {
+          ctx.print(`Automation job not found: ${id}`);
+          return;
+        }
+        ctx.print(
+          `${sub === 'enable' ? 'Enabled' : 'Disabled'} automation job: ${updated.id}\n`
+          + `  next run: ${formatNextRun(updated.nextRunAt)}`
+        );
+        return;
+      }
+
+      if (sub === 'run') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /schedule run <id>');
+          return;
+        }
+        const job = resolveJob(manager, id);
+        if (!job) {
+          ctx.print(`Automation job not found: ${id}`);
+          return;
+        }
+        try {
+          const run = await manager.runNow(job.id);
+          ctx.print(
+            `Running automation job ${job.id} immediately\n`
+            + `  run: ${run.id}\n`
+            + `  agent: ${run.agentId ?? 'unavailable'}`
+          );
+        } catch (error) {
+          ctx.print(`Error running automation job: ${summarizeError(error)}`);
+        }
+        return;
+      }
+
+      ctx.print(
+        'Usage:\n'
+        + '  /schedule add cron "<expr>" <prompt...> [--target main|current|isolated|pinned|session:<id>] [--stagger <ms>]\n'
+        + '  /schedule add every <interval> <prompt...> [--target <target>]\n'
+        + '  /schedule add at <timestamp> <prompt...> [--target <target>]\n'
+        + '  /schedule list\n'
+        + '  /schedule remove <id>\n'
+        + '  /schedule enable <id>\n'
+        + '  /schedule disable <id>\n'
+        + '  /schedule run <id>'
+      );
+    },
+  });
+}