@pellux/goodvibes-agent 0.1.0

package/src/input/commands/shell-core.ts

@@ -0,0 +1,307 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import type { SelectionItem } from '../selection-modal.ts';
+import { EFFORT_DESCRIPTIONS } from '@pellux/goodvibes-sdk/platform/providers';
+import { REASONING_BUDGET_MAP } from '@pellux/goodvibes-sdk/platform/providers';
+import { executeWriteQuit } from './quit-shared.ts';
+import { compactConversation, requireKeybindingsManager, requireProviderApi } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+
+export function registerShellCoreCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'model',
+    aliases: ['m'],
+    description: 'Select or display the current LLM model',
+    usage: '[model-id]',
+    argsHint: '[name]',
+    async handler(args, ctx) {
+      const providerApi = requireProviderApi(ctx);
+      if (args.length === 0) {
+        if (ctx.openModelPicker) {
+          ctx.openModelPicker();
+        } else {
+          const models = await providerApi.listModels({ selectableOnly: true });
+          const lines = ['Available models:', ...models.map((model) =>
+            `  ${model.current ? '▶' : ' '} ${model.registryKey.padEnd(36)} ${model.displayName} (${model.providerId})`,
+          )];
+          ctx.print(lines.join('\n'));
+        }
+      } else {
+        const modelId = args[0];
+        try {
+          const selected = await providerApi.selectModel(modelId);
+          ctx.session.runtime.model = selected.registryKey;
+          ctx.session.runtime.provider = selected.providerId;
+          ctx.platform.configManager.set('provider.model', selected.registryKey);
+          ctx.print(`Switched to model: ${selected.displayName} (${selected.providerId})`);
+          void providerApi.recordModelUsage(selected.registryKey).catch((err) => { logger.debug('model usage record failed', { err }); });
+        } catch (e) {
+          ctx.print(`Error: ${summarizeError(e)}`);
+        }
+      }
+    },
+  });
+
+  registry.register({
+    name: 'commands',
+    aliases: ['cmds'],
+    description: 'Browse all commands in a scrollable list',
+    handler(_args, ctx) {
+      if (ctx.openHelpOverlay) {
+        ctx.openHelpOverlay();
+        return;
+      }
+      ctx.print('Use /help for interactive command list');
+    },
+  });
+
+  registry.register({
+    name: 'shortcuts',
+    aliases: ['keys', 'keybinds'],
+    description: 'Show keyboard shortcuts reference',
+    handler(_args, ctx) {
+      if (ctx.openShortcutsOverlay) {
+        ctx.openShortcutsOverlay();
+        return;
+      }
+      ctx.print('Use ? key or /help for shortcuts');
+    },
+  });
+
+  registry.register({
+    name: 'keybindings',
+    aliases: ['kb'],
+    description: 'List current keyboard bindings and their config file path',
+    handler(_args, ctx) {
+      const km = requireKeybindingsManager(ctx);
+      const all = km.getAll();
+      const lines: string[] = [
+        `Keybindings config: ${km.getConfigPath()}`,
+        '',
+        `  ${'Action'.padEnd(28)}  ${'Binding'.padEnd(20)}  Description`,
+        `  ${'─'.repeat(28)}  ${'─'.repeat(20)}  ${'─'.repeat(34)}`,
+      ];
+      for (const { action, combos, description } of all) {
+        const label = combos.map((combo) => km.formatCombo(combo)).join(', ');
+        lines.push(`  ${action.padEnd(28)}  ${label.padEnd(20)}  ${description}`);
+      }
+      lines.push('');
+      lines.push('To customize: create the config file with { "action": { "key": "x", "ctrl": true } }');
+      ctx.print(lines.join('\n'));
+    },
+  });
+
+  registry.register({
+    name: 'paste',
+    aliases: ['clip'],
+    description: 'Insert clipboard text or image into the prompt',
+    handler(_args, ctx) {
+      if (!ctx.pasteFromClipboard) {
+        ctx.print('Paste is not available in this context.');
+        return;
+      }
+      const result = ctx.pasteFromClipboard();
+      if (!result.pasted) {
+        ctx.print('Clipboard does not contain supported text or image data.');
+      }
+    },
+  });
+
+  registry.register({
+    name: 'help',
+    aliases: ['h', '?'],
+    description: 'Show available commands and keyboard shortcuts',
+    argsHint: '[command]',
+    handler(_args, ctx) {
+      if (ctx.openSelection) {
+        const items: SelectionItem[] = [
+          { id: '/agent', label: '/agent', detail: 'Open the Agent operator workspace', category: 'Agent Operator' },
+          { id: '/home', label: '/home', detail: 'Alias for the Agent operator workspace', category: 'Agent Operator' },
+          { id: '/model', label: '/model [id]', detail: 'Select LLM model', category: 'Model & Provider' },
+          { id: '/provider', label: '/provider [name]', detail: 'Switch provider', category: 'Model & Provider' },
+          { id: '/effort', label: '/effort [level]', detail: 'Reasoning effort (instant/low/medium/high)', category: 'Model & Provider' },
+          { id: '/config', label: '/config [category|key]', detail: 'Open fullscreen configuration workspace', category: 'Config & Display' },
+          { id: '/debug', label: '/debug', detail: 'Toggle debug mode', category: 'Config & Display' },
+          { id: '/expand', label: '/expand [type]', detail: 'Expand blocks (all|thinking|tool|code)', category: 'Config & Display' },
+          { id: '/collapse', label: '/collapse [type]', detail: 'Collapse blocks', category: 'Config & Display' },
+          { id: '/bookmarks', label: '/bookmarks', detail: 'List bookmarked blocks', category: 'Config & Display' },
+          { id: '/clear', label: '/clear', detail: 'Clear display (keep context)', category: 'Conversation' },
+          { id: '/reset', label: '/reset', detail: 'Clear display + context', category: 'Conversation' },
+          { id: '/compact', label: '/compact', detail: 'Summarize to free context', category: 'Conversation' },
+          { id: '/export', label: '/export [file]', detail: 'Export as markdown', category: 'Conversation' },
+          { id: '/title', label: '/title [text]', detail: 'Show or set title', category: 'Conversation' },
+          { id: '/save', label: '/save [name]', detail: 'Save session', category: 'Conversation' },
+          { id: '/load', label: '/load <name>', detail: 'Load session', category: 'Conversation' },
+          { id: '/sessions', label: '/sessions', detail: 'List saved sessions', category: 'Conversation' },
+          { id: '/session', label: '/session', detail: 'Current session info', category: 'Conversation' },
+          { id: '/session list', label: '/session list', detail: 'List all sessions', category: 'Conversation' },
+          { id: '/session rename', label: '/session rename <name>', detail: 'Rename current session', category: 'Conversation' },
+          { id: '/session resume', label: '/session resume <id>', detail: 'Load and resume a session', category: 'Conversation' },
+          { id: '/session fork', label: '/session fork [name]', detail: 'Fork current session to new ID', category: 'Conversation' },
+          { id: '/session save', label: '/session save [name]', detail: 'Force-save current session', category: 'Conversation' },
+          { id: '/session info', label: '/session info [id]', detail: 'Show session details', category: 'Conversation' },
+          { id: '/session export', label: '/session export <id> [format]', detail: 'Export session as markdown/text', category: 'Conversation' },
+          { id: '/session search', label: '/session search <query>', detail: 'Search across all sessions', category: 'Conversation' },
+          { id: '/session delete', label: '/session delete <id>', detail: 'Delete a session', category: 'Conversation' },
+          { id: '/undo', label: '/undo', detail: 'Remove last turn', category: 'Conversation' },
+          { id: '/redo', label: '/redo', detail: 'Restore undone turn', category: 'Conversation' },
+          { id: '/retry', label: '/retry [text]', detail: 'Re-send last message', category: 'Conversation' },
+          { id: '/fork', label: '/fork [name]', detail: 'Snapshot conversation as a named branch', category: 'Conversation' },
+          { id: '/branch', label: '/branch [name]', detail: 'List branches or switch to one', category: 'Conversation' },
+          { id: '/merge', label: '/merge <name>', detail: 'Append messages from a branch', category: 'Conversation' },
+          { id: '/template', label: '/template', detail: 'Browse templates', category: 'Templates' },
+          { id: '/template save', label: '/template save <name>', detail: 'Save prompt as template', category: 'Templates' },
+          { id: '/template use', label: '/template use <name>', detail: 'Execute template', category: 'Templates' },
+          { id: '/tools', label: '/tools', detail: 'List available tools', category: 'Tools & System' },
+          { id: '/paste', label: '/paste', detail: 'Insert clipboard text or image into the prompt', category: 'Tools & System' },
+          { id: '/shortcuts', label: '/shortcuts', detail: 'View keyboard shortcuts reference', category: 'Tools & System' },
+          { id: '/commands', label: '/commands', detail: 'Browse all commands in a scrollable list', category: 'Tools & System' },
+          { id: '/secrets', label: '/secrets set|link|get|test|list|delete', detail: 'Manage encrypted and provider-backed secrets', category: 'Tools & System' },
+          { id: '/help', label: '/help', detail: 'This help', category: 'Tools & System' },
+          { id: '/quit', label: '/quit', detail: 'Exit', category: 'Tools & System' },
+          { id: '/wq', label: '/wq', detail: 'Commit all git changes and then exit', category: 'Tools & System' },
+        ];
+        ctx.openSelection('Help  —  Commands', items, { allowSearch: true }, (result) => {
+          if (!result) return;
+          const command = result.item.id;
+          if (command.startsWith('/')) {
+            const parts = command.slice(1).trim().split(/\s+/);
+            const name = parts[0];
+            const cmdArgs = parts.slice(1);
+            void (ctx.executeCommand?.(name, cmdArgs) ?? registry.execute(name, cmdArgs, ctx));
+          }
+        });
+        return;
+      }
+      ctx.print('Use /help to open the help modal. Commands: /agent, /model, /provider, /config, /template, /tools, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit, /wq');
+    },
+  });
+
+  registry.register({
+    name: 'clear',
+    aliases: ['cls'],
+    description: 'Clear the conversation display (keeps LLM context)',
+    handler(_args, ctx) {
+      ctx.session.conversationManager.clearDisplay();
+      ctx.renderRequest();
+    },
+  });
+
+  registry.register({
+    name: 'reset',
+    aliases: [],
+    description: 'Full reset: clear display and conversation context',
+    handler(_args, ctx) {
+      ctx.session.conversationManager.resetAll();
+      if (ctx.reloadSystemPrompt) {
+        ctx.session.runtime.systemPrompt = ctx.reloadSystemPrompt();
+      }
+      ctx.session.conversationManager.rebuildHistory();
+      ctx.renderRequest();
+    },
+  });
+
+  registry.register({
+    name: 'compact',
+    aliases: [],
+    description: 'Summarize conversation to free context window',
+    async handler(_args, ctx) {
+      ctx.print('Compacting conversation...');
+      await compactConversation(ctx);
+      ctx.print('Conversation compacted.');
+      ctx.renderRequest();
+    },
+  });
+
+  registry.register({
+    name: 'quit',
+    aliases: [':q'],
+    description: 'Exit the application',
+    handler(_args, ctx) {
+      ctx.exit();
+    },
+  });
+
+  registry.register({
+    name: 'wq',
+    aliases: [':wq'],
+    description: 'Commit all git changes and then exit',
+    async handler(_args, ctx) {
+      await executeWriteQuit(ctx);
+    },
+  });
+
+  registry.register({
+    name: 'debug',
+    aliases: [],
+    description: 'Toggle debug mode',
+    handler(_args, ctx) {
+      ctx.session.runtime.debugMode = !ctx.session.runtime.debugMode;
+      ctx.print(`Debug mode: ${ctx.session.runtime.debugMode ? 'ON' : 'OFF'}`);
+    },
+  });
+
+  registry.register({
+    name: 'effort',
+    aliases: ['e'],
+    description: 'Show or set reasoning effort level',
+    usage: '[level]',
+    argsHint: '<instant|low|medium|high>',
+    async handler(args, ctx) {
+      const currentModel = await requireProviderApi(ctx).getCurrentModel();
+      const validLevels = currentModel.reasoningEffort ?? [];
+
+      if (validLevels.length === 0) {
+        ctx.print(`Current model (${currentModel.displayName}) does not support configurable reasoning effort.`);
+        return;
+      }
+
+      if (args.length === 0) {
+        const current = (ctx.session.runtime.reasoningEffort || ctx.platform.configManager.get('provider.reasoningEffort') || 'medium') as string;
+        if (ctx.openSelection) {
+          const descriptions: Record<string, string> = {
+            ...EFFORT_DESCRIPTIONS,
+            medium: 'Balanced speed and quality (default)',
+          };
+          const items: SelectionItem[] = validLevels.map((level) => ({
+            id: level,
+            label: level,
+            detail: level === current ? `◉ ${descriptions[level] ?? level}` : (descriptions[level] ?? level),
+          }));
+          ctx.openSelection('Reasoning Effort', items, { preSelectId: current, allowSearch: false }, (result) => {
+            if (!result) return;
+            const level = result.item.id as 'instant' | 'low' | 'medium' | 'high';
+            ctx.session.runtime.reasoningEffort = level;
+            ctx.platform.configManager.set('provider.reasoningEffort', level);
+            ctx.print(`Reasoning effort set to: ${level}`);
+            ctx.renderRequest();
+          });
+          return;
+        }
+        const budget = REASONING_BUDGET_MAP[current];
+        const lines = [
+          `Reasoning effort: ${current}`,
+          `  Mercury-2:  reasoning_effort = '${current}'`,
+          `  Claude:     thinking.budget_tokens = ${budget}`,
+          `  Gemini:     thinking_config.thinking_budget = ${budget}`,
+          `  GPT-5:      (no-op)`,
+          '',
+          `Levels: ${validLevels.join(', ')}`,
+        ];
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      const level = args[0] as 'instant' | 'low' | 'medium' | 'high';
+      if (!validLevels.includes(level)) {
+        ctx.print(`Invalid effort level: ${level}\nValid levels: ${validLevels.join(', ')}`);
+        return;
+      }
+
+      ctx.session.runtime.reasoningEffort = level;
+      ctx.platform.configManager.set('provider.reasoningEffort', level);
+      ctx.print(`Reasoning effort set to: ${level}`);
+    },
+  });
+
+}

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

@@ -0,0 +1,221 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { discoverSkills } from '../../panels/skills-panel.ts';
+import {
+  installEcosystemCatalogEntry,
+  listInstalledEcosystemEntries,
+  loadEcosystemCatalog,
+  removeEcosystemCatalogEntry,
+  reviewEcosystemCatalogEntry,
+  searchEcosystemCatalog,
+  uninstallEcosystemCatalogEntry,
+  updateInstalledEcosystemEntry,
+  upsertEcosystemCatalogEntry,
+} from '@/runtime/index.ts';
+import { requireEcosystemCatalogPaths, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+
+export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'skills',
+    aliases: ['skill'],
+    description: 'Inspect installed skill packs',
+    usage: '[open|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]',
+    async handler(args, ctx) {
+      const sub = args[0] ?? 'open';
+      if (sub === 'open' || sub === 'panel') {
+        if (ctx.showPanel) ctx.showPanel('skills');
+        else {
+          const panelManager = requirePanelManager(ctx);
+          panelManager.open('skills');
+          panelManager.show();
+          ctx.renderRequest();
+        }
+        return;
+      }
+      const skills = await discoverSkills(requireShellPaths(ctx));
+      const ecosystemPaths = requireEcosystemCatalogPaths(ctx);
+      if (sub === 'list') {
+        if (skills.length === 0) {
+          ctx.print('No skills discovered.');
+          return;
+        }
+        ctx.print([
+          `Skills (${skills.length})`,
+          ...skills.map((skill) => `  ${skill.name}  [${skill.origin}]  ${skill.description || 'No description provided.'}`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'origins') {
+        const counts = new Map<string, number>();
+        for (const skill of skills) counts.set(skill.origin, (counts.get(skill.origin) ?? 0) + 1);
+        ctx.print([
+          'Skill Origins',
+          ...[...counts.entries()].map(([origin, count]) => `  ${origin}: ${count}`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'show') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /skills show <name>');
+          return;
+        }
+        const skill = skills.find((entry) => entry.name === name);
+        if (!skill) {
+          ctx.print(`Unknown skill: ${name}`);
+          return;
+        }
+        ctx.print([
+          `Skill ${skill.name}`,
+          `  origin: ${skill.origin}`,
+          `  path: ${skill.path}`,
+          `  description: ${skill.description || 'No description provided.'}`,
+          `  dependencies: ${skill.dependencies.join(', ') || '(none)'}`,
+          `  includes: ${skill.includes.join(', ') || '(none)'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'browse' || sub === 'catalog') {
+        const query = args.slice(1).join(' ');
+        const entries = query ? searchEcosystemCatalog('skill', query, ecosystemPaths) : loadEcosystemCatalog('skill', ecosystemPaths);
+        if (entries.length === 0) {
+          ctx.print(query
+            ? `No curated skill catalog entries matched "${query}".`
+            : 'No curated skill catalog entries found. Add .goodvibes/agent/ecosystem/skills.json to publish a local-first skill catalog.');
+          return;
+        }
+        ctx.print([
+          `Curated Skill Catalog (${entries.length})`,
+          ...entries.map((entry) => `  ${entry.id}  ${entry.name}  [${entry.tags.join(', ') || 'untagged'}]  ${entry.summary}`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'installed') {
+        const receipts = listInstalledEcosystemEntries('skill', ecosystemPaths);
+        if (receipts.length === 0) {
+          ctx.print('No curated skills installed from local catalogs yet.');
+          return;
+        }
+        ctx.print([
+          `Installed Curated Skills (${receipts.length})`,
+          ...receipts.map((receipt) => `  ${receipt.entry.id}  ${receipt.scope}  ${receipt.targetPath}`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'catalog-review') {
+        const entryId = args[1];
+        if (!entryId) {
+          ctx.print('Usage: /skills catalog-review <catalog-id>');
+          return;
+        }
+        const entry = loadEcosystemCatalog('skill', ecosystemPaths).find((candidate) => candidate.id === entryId);
+        if (!entry) {
+          ctx.print(`Unknown curated skill entry: ${entryId}`);
+          return;
+        }
+        const review = reviewEcosystemCatalogEntry(entry, ecosystemPaths);
+        ctx.print([
+          `Skill Catalog Review: ${entry.name}`,
+          `  id: ${entry.id}`,
+          `  source: ${entry.source}`,
+          `  sourceKind: ${review.sourceKind}`,
+          `  sourceExists: ${review.sourceExists ? 'yes' : 'no'}`,
+          `  recommendedScope: ${review.recommendedScope}`,
+          `  risk: ${review.riskLevel}`,
+          `  trust notes: ${entry.trustNotes ?? '(none)'}`,
+          `  provenance: ${entry.provenance ?? '(none)'}`,
+          `  update hint: ${entry.updateHint ?? '(none)'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'publish-local') {
+        const entryId = args[1];
+        const sourcePath = args[2];
+        const summary = args.slice(3).join(' ').trim();
+        if (!entryId || !sourcePath || !summary) {
+          ctx.print('Usage: /skills publish-local <catalog-id> <path> <summary...>');
+          return;
+        }
+        const result = upsertEcosystemCatalogEntry({
+          id: entryId,
+          kind: 'skill',
+          name: entryId.replace(/[-_]/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase()),
+          summary,
+          source: sourcePath,
+          tags: ['local-first', 'published'],
+          provenance: 'operator-published',
+          updateHint: 'Use /skills publish-local again to refresh catalog metadata after edits.',
+        }, ecosystemPaths);
+        ctx.print(result.ok ? `Published curated skill ${entryId} into ${result.path}` : `Error: ${result.error}`);
+        return;
+      }
+      if (sub === 'unpublish') {
+        const entryId = args[1];
+        if (!entryId) {
+          ctx.print('Usage: /skills unpublish <catalog-id>');
+          return;
+        }
+        const result = removeEcosystemCatalogEntry('skill', entryId, ecosystemPaths);
+        ctx.print(result.ok ? `Removed curated skill ${entryId} from ${result.path}` : `Error: ${result.error}`);
+        return;
+      }
+      if (sub === 'install-hint') {
+        const entryId = args[1];
+        if (!entryId) {
+          ctx.print('Usage: /skills install-hint <catalog-id>');
+          return;
+        }
+        const entry = loadEcosystemCatalog('skill', ecosystemPaths).find((candidate) => candidate.id === entryId);
+        if (!entry) {
+          ctx.print(`Unknown curated skill entry: ${entryId}`);
+          return;
+        }
+        ctx.print([
+          `Skill Install Guidance: ${entry.name}`,
+          `  id: ${entry.id}`,
+          `  source: ${entry.source}`,
+          `  tags: ${entry.tags.join(', ') || '(none)'}`,
+          `  trust notes: ${entry.trustNotes ?? '(none)'}`,
+          `  install hint: ${entry.installHint ?? 'Place the skill pack under a configured skill directory and refresh the skills panel.'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'install') {
+        const entryId = args[1];
+        const scopeArg = args[2];
+        if (!entryId) {
+          ctx.print('Usage: /skills install <catalog-id> [project|user]');
+          return;
+        }
+        const scope = scopeArg === 'project' ? 'project' : 'user';
+        const result = installEcosystemCatalogEntry('skill', entryId, { ...ecosystemPaths, scope });
+        ctx.print(result.ok ? `Installed curated skill ${entryId} into ${result.receipt.targetPath}` : `Error: ${result.error}`);
+        return;
+      }
+      if (sub === 'update') {
+        const entryId = args[1];
+        const scopeArg = args[2];
+        if (!entryId) {
+          ctx.print('Usage: /skills update <catalog-id> [project|user]');
+          return;
+        }
+        const scope = scopeArg === 'project' ? 'project' : 'user';
+        const result = updateInstalledEcosystemEntry('skill', entryId, { ...ecosystemPaths, scope });
+        ctx.print(result.ok ? `Updated curated skill ${entryId} in ${result.receipt.targetPath}` : `Error: ${result.error}`);
+        return;
+      }
+      if (sub === 'uninstall') {
+        const entryId = args[1];
+        const scopeArg = args[2];
+        if (!entryId) {
+          ctx.print('Usage: /skills uninstall <catalog-id> [project|user]');
+          return;
+        }
+        const scope = scopeArg === 'project' ? 'project' : 'user';
+        const result = uninstallEcosystemCatalogEntry('skill', entryId, { ...ecosystemPaths, scope });
+        ctx.print(result.ok ? `Uninstalled curated skill ${entryId} from ${result.removedPath}` : `Error: ${result.error}`);
+        return;
+      }
+      ctx.print('Usage: /skills [open|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]');
+    },
+  });
+}