@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/input/agent-workspace-mcp-command-editors.ts

@@ -0,0 +1,52 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorSpecEntry } from './agent-workspace-command-editor-engine.ts';
+import { createAgentWorkspaceEditorFromTable } from './agent-workspace-command-editor-engine.ts';
+
+export type AgentWorkspaceMcpCommandEditorKind = Extract<AgentWorkspaceEditorKind, 'mcp-server' | 'mcp-tools-server' | 'mcp-repair'>;
+
+export function isAgentWorkspaceMcpCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMcpCommandEditorKind {
+  return kind === 'mcp-server' || kind === 'mcp-tools-server' || kind === 'mcp-repair';
+}
+
+const MCP_COMMAND_EDITOR_SPECS: Readonly<Record<AgentWorkspaceMcpCommandEditorKind, AgentWorkspaceEditorSpecEntry<AgentWorkspaceMcpCommandEditorKind>>> = {
+  'mcp-server': {
+    mode: 'create',
+    title: 'Add MCP Server',
+    selectedFieldIndex: 0,
+    message: 'Add or update one MCP server from the Agent workspace. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'name', label: 'Server name', value: '', required: true, multiline: false, hint: 'Letters, numbers, dot, underscore, and dash only.' },
+      { id: 'command', label: 'Command', value: '', required: true, multiline: false, hint: 'Executable command, such as bunx, npx, uvx, or a full local binary path.' },
+      { id: 'args', label: 'Arguments', value: '', required: false, multiline: false, hint: 'Optional command arguments. Quotes are supported.' },
+      { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional. Defaults to project. Use project or global.' },
+      { id: 'role', label: 'Role', value: '', required: false, multiline: false, hint: 'Optional. general, docs, filesystem, git, database, browser, automation, ops, or remote.' },
+      { id: 'trust', label: 'Trust mode', value: '', required: false, multiline: false, hint: 'Optional. Defaults to constrained. Use constrained, ask-on-risk, or blocked. Use settings for allow-all.' },
+      { id: 'env', label: 'Env refs', value: '', required: false, multiline: false, hint: 'Comma-separated KEY=VALUE entries. Prefer secret refs, not raw secrets.' },
+      { id: 'paths', label: 'Allowed paths', value: '', required: false, multiline: false, hint: 'Comma-separated path allowlist entries.' },
+      { id: 'hosts', label: 'Allowed hosts', value: '', required: false, multiline: false, hint: 'Comma-separated host allowlist entries.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to save the MCP server through the TUI command router.' },
+    ],
+  },
+  'mcp-tools-server': {
+    mode: 'create',
+    title: 'Show MCP Server Tools',
+    selectedFieldIndex: 0,
+    message: 'List tools exposed by one MCP server without changing server trust, role, or config.',
+    fields: [
+      { id: 'server', label: 'Server name', value: '', required: true, multiline: false, hint: 'MCP server name from MCP Review or the fullscreen MCP workspace.' },
+    ],
+  },
+  'mcp-repair': {
+    mode: 'create',
+    title: 'Show MCP Repair Guidance',
+    selectedFieldIndex: 0,
+    message: 'Show read-only repair guidance for one MCP server. This does not approve quarantine, change trust, or reload the runtime.',
+    fields: [
+      { id: 'server', label: 'Server name', value: '', required: true, multiline: false, hint: 'MCP server name from MCP Review or Auth review.' },
+    ],
+  },
+};
+
+export function createAgentWorkspaceMcpCommandEditor(kind: AgentWorkspaceMcpCommandEditorKind): AgentWorkspaceLocalEditor {
+  return createAgentWorkspaceEditorFromTable(kind, MCP_COMMAND_EDITOR_SPECS);
+}

package/src/input/agent-workspace-media-command-editor-submission.ts

@@ -1,42 +1,22 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import type { AgentWorkspaceMediaCommandEditorKind } from './agent-workspace-media-command-editors.ts';
 import { isAgentWorkspaceMediaCommandEditorKind } from './agent-workspace-media-command-editors.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceMediaCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
+export type AgentWorkspaceMediaCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceMediaCommandSubmissionKind(kind: string): kind is AgentWorkspaceMediaCommandEditorKind {
   return isAgentWorkspaceMediaCommandEditorKind(kind as AgentWorkspaceMediaCommandEditorKind);
 }
 
-function isAffirmative(value: string): boolean {
-  return /^(y|yes|true)$/i.test(value.trim());
-}
-
 export function buildAgentWorkspaceMediaCommandEditorSubmission(
   editor: AgentWorkspaceLocalEditor,
   readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceMediaCommandEditorSubmission {
+): AgentWorkspaceCommandEditorSubmission {
   if (!isAffirmative(readField('confirm'))) {
-    return {
-      kind: 'editor',
-      editor: { ...editor, message: 'Media generation not confirmed. Type yes, then press Enter.' },
-      status: 'Agent media generation not confirmed.',
-    };
+    return editorMessageSubmission(editor, 'Media generation not confirmed. Type yes, then press Enter.', 'Agent media generation not confirmed.');
   }
   const parts = ['/media', 'generate'];
   const provider = readField('provider');
@@ -46,17 +26,10 @@ export function buildAgentWorkspaceMediaCommandEditorSubmission(
   if (model) parts.push('--model', quoteSlashCommandArg(model));
   if (mime) parts.push('--mime', quoteSlashCommandArg(mime));
   parts.push(quoteSlashCommandArg(readField('prompt')), '--yes');
-  const command = parts.join(' ');
-  return {
-    kind: 'dispatch',
-    command,
-    status: 'Opening media generation.',
-    actionResult: {
-      kind: 'dispatched',
-      title: 'Opening media generation',
-      detail: 'The workspace handed confirmed media generation to the shell-owned command router.',
-      command,
-      safety: 'safe',
-    },
-  };
+  return dispatchCommandEditorSubmission(
+    parts.join(' '),
+    'Opening media generation',
+    'The workspace handed confirmed media generation to the shell-owned command router.',
+    'safe',
+  );
 }

package/src/input/agent-workspace-media-command-editors.ts

@@ -1,17 +1,15 @@
 import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorSpecEntry } from './agent-workspace-command-editor-engine.ts';
+import { createAgentWorkspaceEditorFromTable } from './agent-workspace-command-editor-engine.ts';
 
-export type AgentWorkspaceMediaCommandEditorKind = Extract<
-  AgentWorkspaceEditorKind,
-  'media-generate'
->;
+export type AgentWorkspaceMediaCommandEditorKind = Extract<AgentWorkspaceEditorKind, 'media-generate'>;
 
 export function isAgentWorkspaceMediaCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMediaCommandEditorKind {
   return kind === 'media-generate';
 }
 
-export function createAgentWorkspaceMediaCommandEditor(kind: AgentWorkspaceMediaCommandEditorKind): AgentWorkspaceLocalEditor {
-  return {
-    kind,
+const MEDIA_COMMAND_EDITOR_SPECS: Readonly<Record<AgentWorkspaceMediaCommandEditorKind, AgentWorkspaceEditorSpecEntry<AgentWorkspaceMediaCommandEditorKind>>> = {
+  'media-generate': {
     mode: 'create',
     title: 'Generate Media',
     selectedFieldIndex: 0,
@@ -23,5 +21,9 @@ export function createAgentWorkspaceMediaCommandEditor(kind: AgentWorkspaceMedia
       { id: 'mime', label: 'Output MIME', value: '', required: false, multiline: false, hint: 'Optional output type, such as image/png or video/mp4.' },
       { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /media generate with --yes.' },
     ],
-  };
+  },
+};
+
+export function createAgentWorkspaceMediaCommandEditor(kind: AgentWorkspaceMediaCommandEditorKind): AgentWorkspaceLocalEditor {
+  return createAgentWorkspaceEditorFromTable(kind, MEDIA_COMMAND_EDITOR_SPECS);
 }

package/src/input/agent-workspace-memory-command-editor-submission.ts

@@ -1,74 +1,21 @@
-import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
 import type { AgentWorkspaceMemoryCommandEditorKind } from './agent-workspace-memory-command-editors.ts';
 import { isAgentWorkspaceMemoryCommandEditorKind } from './agent-workspace-memory-command-editors.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceCommandSubmissionHandler, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { appendOptionalArg, buildCommandEditorSubmissionFromTable, dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative, splitCommaList } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
+export type AgentWorkspaceMemoryCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
-export type AgentWorkspaceMemoryCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
-
-type MemoryDispatchSafety = AgentWorkspaceAction['safety'];
-
-function isAffirmative(value: string): boolean {
-  return /^(y|yes|true)$/i.test(value.trim());
-}
-
-function splitCommaList(value: string): readonly string[] {
-  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
-}
-
-function unconfirmed(editor: AgentWorkspaceLocalEditor, label: string): AgentWorkspaceMemoryCommandEditorSubmission {
-  return {
-    kind: 'editor',
-    editor: { ...editor, message: `${label} not confirmed. Type yes, then press Enter.` },
-    status: `${label} not confirmed.`,
-  };
-}
-
-function dispatch(
-  command: string,
-  title: string,
-  status: string,
-  detail: string,
-  safety: MemoryDispatchSafety,
-): AgentWorkspaceMemoryCommandEditorSubmission {
-  return {
-    kind: 'dispatch',
-    command,
-    status,
-    actionResult: {
-      kind: 'dispatched',
-      title,
-      detail,
-      command,
-      safety,
-    },
-  };
-}
-
-function appendOptional(parts: string[], flag: string, value: string): void {
-  if (value.trim().length > 0) {
-    parts.push(flag, quoteSlashCommandArg(value));
-  }
+function unconfirmed(editor: AgentWorkspaceLocalEditor, label: string): AgentWorkspaceCommandEditorSubmission {
+  return editorMessageSubmission(editor, `${label} not confirmed. Type yes, then press Enter.`, `${label} not confirmed.`);
 }
 
 function requireConfirmation(
   editor: AgentWorkspaceLocalEditor,
   readField: AgentWorkspaceFieldReader,
   label: string,
-): AgentWorkspaceMemoryCommandEditorSubmission | null {
+): AgentWorkspaceCommandEditorSubmission | null {
   return isAffirmative(readField('confirm')) ? null : unconfirmed(editor, label);
 }
 
@@ -76,157 +23,135 @@ export function isAgentWorkspaceMemoryCommandSubmissionKind(kind: AgentWorkspace
   return isAgentWorkspaceMemoryCommandEditorKind(kind);
 }
 
-export function buildAgentWorkspaceMemoryCommandEditorSubmission(
-  editor: AgentWorkspaceLocalEditor,
-  readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceMemoryCommandEditorSubmission {
-  if (editor.kind === 'memory-search') {
+const MEMORY_COMMAND_SUBMISSION_HANDLERS: Readonly<Record<AgentWorkspaceMemoryCommandEditorKind, AgentWorkspaceCommandSubmissionHandler>> = {
+  'memory-search': (_editor, readField) => {
     const parts = ['/memory', 'search'];
     const query = readField('query');
     if (query.length > 0) parts.push(quoteSlashCommandArg(query));
-    appendOptional(parts, '--scope', readField('scope'));
-    appendOptional(parts, '--cls', readField('class'));
-    appendOptional(parts, '--limit', readField('limit'));
+    appendOptionalArg(parts, '--scope', readField('scope'));
+    appendOptionalArg(parts, '--cls', readField('class'));
+    appendOptionalArg(parts, '--limit', readField('limit'));
     if (isAffirmative(readField('semantic'))) parts.push('--semantic');
-    const command = parts.join(' ');
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      parts.join(' '),
       'Opening Agent memory search',
-      'Opening Agent memory search.',
       'The workspace handed an Agent-local memory search command to the shell-owned command router.',
       'read-only',
     );
-  }
-
-  if (editor.kind === 'memory-get') {
-    const command = `/memory get ${quoteSlashCommandArg(readField('id'))}`;
-    return dispatch(
-      command,
-      'Opening Agent memory record',
-      'Opening Agent memory record.',
-      'The workspace handed an Agent-local memory lookup command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-
-  if (editor.kind === 'memory-explain') {
+  },
+  'memory-get': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/memory get ${quoteSlashCommandArg(readField('id'))}`,
+    'Opening Agent memory record',
+    'The workspace handed an Agent-local memory lookup command to the shell-owned command router.',
+    'read-only',
+  ),
+  'memory-explain': (_editor, readField) => {
     const parts = ['/memory', 'explain', quoteSlashCommandArg(readField('task'))];
     const scopes = splitCommaList(readField('scopes'));
     if (scopes.length > 0) {
       parts.push('--scope');
       for (const scope of scopes) parts.push(quoteSlashCommandArg(scope));
     }
-    const command = parts.join(' ');
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      parts.join(' '),
       'Opening Agent memory explanation',
-      'Opening Agent memory explanation.',
       'The workspace handed an Agent-local memory explanation command to the shell-owned command router.',
       'read-only',
     );
-  }
-
-  if (editor.kind === 'memory-promote') {
+  },
+  'memory-promote': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory promotion');
     if (confirmation) return confirmation;
-    const command = `/memory promote ${quoteSlashCommandArg(readField('id'))} ${quoteSlashCommandArg(readField('scope'))} --yes`;
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      `/memory promote ${quoteSlashCommandArg(readField('id'))} ${quoteSlashCommandArg(readField('scope'))} --yes`,
       'Opening Agent memory promotion',
-      'Opening Agent memory promotion.',
       'The workspace handed a confirmed Agent-local memory promotion command to the shell-owned command router.',
       'safe',
     );
-  }
-
-  if (editor.kind === 'memory-link') {
+  },
+  'memory-link': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory link');
     if (confirmation) return confirmation;
-    const command = `/memory link ${quoteSlashCommandArg(readField('fromId'))} ${quoteSlashCommandArg(readField('toId'))} ${quoteSlashCommandArg(readField('relation'))} --yes`;
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      `/memory link ${quoteSlashCommandArg(readField('fromId'))} ${quoteSlashCommandArg(readField('toId'))} ${quoteSlashCommandArg(readField('relation'))} --yes`,
       'Opening Agent memory link',
-      'Opening Agent memory link.',
       'The workspace handed a confirmed Agent-local memory link command to the shell-owned command router.',
       'safe',
     );
-  }
-
-  if (editor.kind === 'memory-export') {
+  },
+  'memory-export': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory bundle export');
     if (confirmation) return confirmation;
     const parts = ['/memory', 'export', quoteSlashCommandArg(readField('path'))];
-    appendOptional(parts, '--scope', readField('scope'));
-    appendOptional(parts, '--cls', readField('class'));
+    appendOptionalArg(parts, '--scope', readField('scope'));
+    appendOptionalArg(parts, '--cls', readField('class'));
     parts.push('--yes');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       parts.join(' '),
       'Opening Agent memory bundle export',
-      'Opening Agent memory bundle export.',
       'The workspace handed a confirmed Agent-local memory export command to the shell-owned command router.',
       'safe',
     );
-  }
-
-  if (editor.kind === 'memory-import') {
+  },
+  'memory-import': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory bundle import');
     if (confirmation) return confirmation;
-    const command = `/memory import ${quoteSlashCommandArg(readField('path'))} --yes`;
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      `/memory import ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening Agent memory bundle import',
-      'Opening Agent memory bundle import.',
       'The workspace handed a confirmed Agent-local memory import command to the shell-owned command router.',
       'safe',
     );
-  }
-
-  if (editor.kind === 'memory-handoff-export') {
+  },
+  'memory-handoff-export': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory handoff export');
     if (confirmation) return confirmation;
     const parts = ['/memory', 'handoff-export', quoteSlashCommandArg(readField('path'))];
-    appendOptional(parts, '--scope', readField('scope'));
+    appendOptionalArg(parts, '--scope', readField('scope'));
     parts.push('--yes');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       parts.join(' '),
       'Opening Agent memory handoff export',
-      'Opening Agent memory handoff export.',
       'The workspace handed a confirmed Agent-local memory handoff export command to the shell-owned command router.',
       'safe',
     );
-  }
-
-  if (editor.kind === 'memory-handoff-inspect') {
-    const command = `/memory handoff-inspect ${quoteSlashCommandArg(readField('path'))}`;
-    return dispatch(
-      command,
-      'Opening Agent memory handoff inspection',
-      'Opening Agent memory handoff inspection.',
-      'The workspace handed an Agent-local memory handoff inspection command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-
-  if (editor.kind === 'memory-handoff-import') {
+  },
+  'memory-handoff-inspect': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/memory handoff-inspect ${quoteSlashCommandArg(readField('path'))}`,
+    'Opening Agent memory handoff inspection',
+    'The workspace handed an Agent-local memory handoff inspection command to the shell-owned command router.',
+    'read-only',
+  ),
+  'memory-handoff-import': (editor, readField) => {
     const confirmation = requireConfirmation(editor, readField, 'Memory handoff import');
     if (confirmation) return confirmation;
-    const command = `/memory handoff-import ${quoteSlashCommandArg(readField('path'))} --yes`;
-    return dispatch(
-      command,
+    return dispatchCommandEditorSubmission(
+      `/memory handoff-import ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening Agent memory handoff import',
-      'Opening Agent memory handoff import.',
       'The workspace handed a confirmed Agent-local memory handoff import command to the shell-owned command router.',
       'safe',
     );
-  }
+  },
+  'memory-vector-rebuild': (editor, readField) => {
+    const confirmation = requireConfirmation(editor, readField, 'Memory vector rebuild');
+    if (confirmation) return confirmation;
+    return dispatchCommandEditorSubmission(
+      '/memory vector rebuild',
+      'Opening Agent memory vector rebuild',
+      'The workspace handed a confirmed Agent-local memory vector rebuild command to the shell-owned command router.',
+      'safe',
+    );
+  },
+};
 
-  const confirmation = requireConfirmation(editor, readField, 'Memory vector rebuild');
-  if (confirmation) return confirmation;
-  return dispatch(
-    '/memory vector rebuild',
-    'Opening Agent memory vector rebuild',
-    'Opening Agent memory vector rebuild.',
-    'The workspace handed a confirmed Agent-local memory vector rebuild command to the shell-owned command router.',
-    'safe',
+export function buildAgentWorkspaceMemoryCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceCommandEditorSubmission {
+  return buildCommandEditorSubmissionFromTable(
+    editor.kind as AgentWorkspaceMemoryCommandEditorKind,
+    editor,
+    readField,
+    MEMORY_COMMAND_SUBMISSION_HANDLERS,
   );
 }