@pellux/goodvibes-agent 0.1.116 → 0.1.117

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

@@ -0,0 +1,232 @@
+import type { AgentWorkspaceAction, AgentWorkspaceActionResult, 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';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+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 requireConfirmation(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  label: string,
+): AgentWorkspaceMemoryCommandEditorSubmission | null {
+  return isAffirmative(readField('confirm')) ? null : unconfirmed(editor, label);
+}
+
+export function isAgentWorkspaceMemoryCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMemoryCommandEditorKind {
+  return isAgentWorkspaceMemoryCommandEditorKind(kind);
+}
+
+export function buildAgentWorkspaceMemoryCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceMemoryCommandEditorSubmission {
+  if (editor.kind === 'memory-search') {
+    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'));
+    if (isAffirmative(readField('semantic'))) parts.push('--semantic');
+    const command = parts.join(' ');
+    return dispatch(
+      command,
+      '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') {
+    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,
+      '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') {
+    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,
+      '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') {
+    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,
+      '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') {
+    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'));
+    parts.push('--yes');
+    return dispatch(
+      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') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory bundle import');
+    if (confirmation) return confirmation;
+    const command = `/memory import ${quoteSlashCommandArg(readField('path'))} --yes`;
+    return dispatch(
+      command,
+      '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') {
+    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'));
+    parts.push('--yes');
+    return dispatch(
+      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') {
+    const confirmation = requireConfirmation(editor, readField, 'Memory handoff import');
+    if (confirmation) return confirmation;
+    const command = `/memory handoff-import ${quoteSlashCommandArg(readField('path'))} --yes`;
+    return dispatch(
+      command,
+      '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',
+    );
+  }
+
+  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',
+  );
+}

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

@@ -0,0 +1,180 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceMemoryCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'memory-search'
+  | 'memory-get'
+  | 'memory-explain'
+  | 'memory-promote'
+  | 'memory-link'
+  | 'memory-export'
+  | 'memory-import'
+  | 'memory-handoff-export'
+  | 'memory-handoff-inspect'
+  | 'memory-handoff-import'
+  | 'memory-vector-rebuild'
+>;
+
+export function isAgentWorkspaceMemoryCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMemoryCommandEditorKind {
+  return kind === 'memory-search'
+    || kind === 'memory-get'
+    || kind === 'memory-explain'
+    || kind === 'memory-promote'
+    || kind === 'memory-link'
+    || kind === 'memory-export'
+    || kind === 'memory-import'
+    || kind === 'memory-handoff-export'
+    || kind === 'memory-handoff-inspect'
+    || kind === 'memory-handoff-import'
+    || kind === 'memory-vector-rebuild';
+}
+
+export function createAgentWorkspaceMemoryCommandEditor(kind: AgentWorkspaceMemoryCommandEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'memory-search') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Search Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Search Agent-local memory only. This does not query default Knowledge/Wiki or other product routes.',
+      fields: [
+        { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional text query. Blank searches by filters.' },
+        { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional session, project, or team.' },
+        { id: 'class', label: 'Class', value: '', required: false, multiline: false, hint: 'Optional fact, constraint, pattern, runbook, risk, etc.' },
+        { id: 'limit', label: 'Limit', value: '', required: false, multiline: false, hint: 'Optional result limit.' },
+        { id: 'semantic', label: 'Semantic', value: 'no', required: false, multiline: false, hint: 'yes/no. Uses the local vector index when available.' },
+      ],
+    };
+  }
+  if (kind === 'memory-get') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Show one Agent-local memory record with provenance and links.',
+      fields: [
+        { id: 'id', label: 'Memory id', value: '', required: true, multiline: false, hint: 'Existing Agent memory id.' },
+      ],
+    };
+  }
+  if (kind === 'memory-explain') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Explain Memory Selection',
+      selectedFieldIndex: 0,
+      message: 'Preview which reviewed Agent-local memory records would be selected for a task.',
+      fields: [
+        { id: 'task', label: 'Task', value: '', required: true, multiline: true, hint: 'Task description. Ctrl-J inserts a new line.' },
+        { id: 'scopes', label: 'Scopes', value: '', required: false, multiline: false, hint: 'Optional comma-separated write scopes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-promote') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Promote Agent Memory',
+      selectedFieldIndex: 0,
+      message: 'Promote one Agent-local memory record to another scope. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'id', label: 'Memory id', value: '', required: true, multiline: false, hint: 'Existing Agent memory id.' },
+        { id: 'scope', label: 'Scope', value: '', required: true, multiline: false, hint: 'session, project, or team.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory promote with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-link') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Link Agent Memories',
+      selectedFieldIndex: 0,
+      message: 'Create one directed relation between two Agent-local memory records. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'fromId', label: 'From memory id', value: '', required: true, multiline: false, hint: 'Source memory id.' },
+        { id: 'toId', label: 'To memory id', value: '', required: true, multiline: false, hint: 'Target memory id.' },
+        { id: 'relation', label: 'Relation', value: '', required: true, multiline: false, hint: 'Short relation label, such as supports, supersedes, or contradicts.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory link with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-export') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Export Agent Memory Bundle',
+      selectedFieldIndex: 0,
+      message: 'Export Agent-local memory records and links to a reviewable JSON bundle. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Output path', value: 'agent-memory-bundle.json', required: true, multiline: false, hint: 'Workspace-relative JSON path to write.' },
+        { id: 'scope', label: 'Scope', value: '', required: false, multiline: false, hint: 'Optional session, project, or team.' },
+        { id: 'class', label: 'Class', value: '', required: false, multiline: false, hint: 'Optional fact, constraint, pattern, runbook, risk, etc.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory export with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-import') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Import Agent Memory Bundle',
+      selectedFieldIndex: 0,
+      message: 'Import a reviewed Agent memory bundle into the Agent-local memory registry. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-bundle.json', required: true, multiline: false, hint: 'Workspace-relative JSON bundle path.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory import with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-export') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Export Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Export a scoped Agent memory handoff bundle for review. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Output path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON path to write.' },
+        { id: 'scope', label: 'Scope', value: 'team', required: false, multiline: false, hint: 'session, project, or team. Blank defaults to team.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory handoff-export with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-inspect') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Inspect Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Inspect a memory handoff bundle before importing it.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON handoff bundle path.' },
+      ],
+    };
+  }
+  if (kind === 'memory-handoff-import') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Import Memory Handoff',
+      selectedFieldIndex: 0,
+      message: 'Import a reviewed memory handoff bundle into Agent-local memory. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Bundle path', value: 'agent-memory-handoff.json', required: true, multiline: false, hint: 'Workspace-relative JSON handoff bundle path.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory handoff-import with --yes.' },
+      ],
+    };
+  }
+  return {
+    kind,
+    mode: 'update',
+    title: 'Rebuild Memory Vector Index',
+    selectedFieldIndex: 0,
+    message: 'Rebuild the Agent-local memory vector index. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /memory vector rebuild.' },
+    ],
+  };
+}

package/src/input/agent-workspace-navigation.ts

@@ -0,0 +1,45 @@
+import type { AgentWorkspaceAction, AgentWorkspaceCategory, AgentWorkspaceFocusPane } from './agent-workspace-types.ts';
+
+interface AgentWorkspaceNavigationHost {
+  readonly categories: readonly AgentWorkspaceCategory[];
+  readonly actions: readonly AgentWorkspaceAction[];
+  focusPane: AgentWorkspaceFocusPane;
+  selectedCategoryIndex: number;
+  selectedActionIndex: number;
+  clampSelection(): void;
+}
+
+export function moveAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost, delta: -1 | 1): void {
+  if (host.focusPane === 'categories') {
+    host.selectedCategoryIndex = Math.max(0, Math.min(host.categories.length - 1, host.selectedCategoryIndex + delta));
+    host.selectedActionIndex = 0;
+  } else {
+    host.selectedActionIndex = Math.max(0, Math.min(host.actions.length - 1, host.selectedActionIndex + delta));
+  }
+  host.clampSelection();
+}
+
+export function jumpAgentWorkspaceSelection(host: AgentWorkspaceNavigationHost, target: 'home' | 'end'): void {
+  if (host.focusPane === 'categories') {
+    host.selectedCategoryIndex = target === 'home' ? 0 : host.categories.length - 1;
+  } else {
+    host.selectedActionIndex = target === 'home' ? 0 : host.actions.length - 1;
+  }
+  host.clampSelection();
+}
+
+export function selectAgentWorkspaceCategory(host: AgentWorkspaceNavigationHost, categoryIdOrLabel: string): boolean {
+  const normalized = categoryIdOrLabel.trim().toLowerCase();
+  if (!normalized) return false;
+  const categoryIndex = host.categories.findIndex((category) =>
+    category.id.toLowerCase() === normalized
+    || category.label.toLowerCase() === normalized
+    || category.label.toLowerCase().replace(/[^a-z0-9]+/g, '-') === normalized
+  );
+  if (categoryIndex < 0) return false;
+  host.selectedCategoryIndex = categoryIndex;
+  host.selectedActionIndex = 0;
+  host.focusPane = 'actions';
+  host.clampSelection();
+  return true;
+}

package/src/input/agent-workspace-notify-editor-submission.ts

@@ -0,0 +1,107 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceNotifyEditorKind = 'notify-webhook' | 'notify-webhook-remove' | 'notify-webhook-clear' | 'notify-webhook-test';
+
+export type AgentWorkspaceNotifyEditorSubmission =
+  | {
+    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 function isAgentWorkspaceNotifyEditorKind(kind: string): kind is AgentWorkspaceNotifyEditorKind {
+  return kind === 'notify-webhook'
+    || kind === 'notify-webhook-remove'
+    || kind === 'notify-webhook-clear'
+    || kind === 'notify-webhook-test';
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string, status: string): AgentWorkspaceNotifyEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status,
+  };
+}
+
+function dispatch(command: string, title: string, status: string, detail: string): AgentWorkspaceNotifyEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail,
+      command,
+      safety: 'safe',
+    },
+  };
+}
+
+export function buildAgentWorkspaceNotifyEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceNotifyEditorSubmission {
+  if (editor.kind === 'notify-webhook') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook add not confirmed. Type yes, then press Enter.', 'Notification webhook add not confirmed.');
+    }
+    const command = `/notify add ${quoteSlashCommandArg(readField('url'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification webhook add',
+      'Opening notification webhook add.',
+      'The workspace handed a confirmed notification target command to the shell-owned command router.',
+    );
+  }
+
+  if (editor.kind === 'notify-webhook-remove') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook remove not confirmed. Type yes, then press Enter.', 'Notification webhook remove not confirmed.');
+    }
+    const command = `/notify remove ${quoteSlashCommandArg(readField('url'))} --yes`;
+    return dispatch(
+      command,
+      'Opening notification webhook remove',
+      'Opening notification webhook remove.',
+      'The workspace handed a confirmed notification target remove command to the shell-owned command router.',
+    );
+  }
+
+  if (editor.kind === 'notify-webhook-clear') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Notification webhook clear not confirmed. Type yes, then press Enter.', 'Notification webhook clear not confirmed.');
+    }
+    return dispatch(
+      '/notify clear --yes',
+      'Opening notification webhook clear',
+      'Opening notification webhook clear.',
+      'The workspace handed a confirmed notification target cleanup command to the shell-owned command router.',
+    );
+  }
+
+  if (!isAffirmative(readField('confirm'))) {
+    return unconfirmed(editor, 'Notification webhook test not confirmed. Type yes, then press Enter.', 'Notification webhook test not confirmed.');
+  }
+  return dispatch(
+    '/notify test --yes',
+    'Opening notification webhook test',
+    'Opening notification webhook test.',
+    'The workspace handed a confirmed notification test command to the shell-owned command router.',
+  );
+}