@pellux/goodvibes-tui 0.18.4

package/src/input/commands/memory.ts

@@ -0,0 +1,151 @@
+/**
+ * /recall command handler.
+ *
+ * Implements the Project Memory Substrate commands:
+ *
+ *   /recall add <class> <summary>           — Add a new memory record
+ *   /recall add <class> <summary> --detail <text> --tags <tag,tag>
+ *   /recall search [query]                  — Search memory records
+ *   /recall search --cls <class>            — Filter by class
+ *   /recall link <fromId> <toId> <relation> — Link two records
+ *   /recall get <id>                        — Show a single record with provenance
+ *   /recall list [class]                    — List all records (optionally by class)
+ *   /recall remove <id>                     — Delete a record
+ */
+
+import type { SlashCommand, CommandContext } from '../command-registry.ts';
+import { handleRecallAdd, handleRecallCapture } from './recall-capture.ts';
+import { handleRecallExport, handleRecallHandoffExport, handleRecallHandoffImport, handleRecallHandoffInspect, handleRecallImport } from './recall-bundle.ts';
+import { handleRecallGet, handleRecallLink, handleRecallList, handleRecallRemove, handleRecallSearch, handleRecallVector } from './recall-query.ts';
+import { handleRecallExplain, handleRecallPromote, handleRecallQueue, handleRecallReview } from './recall-review.ts';
+import { VALID_CLASSES, VALID_REVIEW_STATES, VALID_SCOPES } from './recall-shared.ts';
+
+// ── Top-level command ─────────────────────────────────────────────────────────
+
+export const recallCommand: SlashCommand = {
+  name: 'recall',
+  aliases: ['rc'],
+  description: 'Project memory: add decisions, constraints, incidents, and patterns with provenance.',
+  usage: '<subcommand> [args]',
+  argsHint: 'add|search|link|get|list|remove',
+  handler: async (args: string[], context: CommandContext): Promise<void> => {
+    const [sub, ...rest] = args;
+
+    switch (sub) {
+      case 'add':
+        await handleRecallAdd(rest, context);
+        break;
+
+      case 'search':
+      case 'find':
+        handleRecallSearch(rest, context);
+        break;
+
+      case 'vector':
+      case 'vectors':
+        handleRecallVector(rest, context);
+        break;
+
+      case 'capture':
+        await handleRecallCapture(rest, context);
+        break;
+
+      case 'get':
+      case 'show':
+        handleRecallGet(rest, context);
+        break;
+
+      case 'queue':
+        handleRecallQueue(rest, context);
+        break;
+
+      case 'review':
+        handleRecallReview(rest, context);
+        break;
+
+      case 'stale':
+        handleRecallReview([rest[0] ?? '', 'stale', '--reason', ...rest.slice(1)], context);
+        break;
+
+      case 'contradict':
+      case 'contradicted':
+        handleRecallReview([rest[0] ?? '', 'contradicted', '--reason', ...rest.slice(1)], context);
+        break;
+
+      case 'explain':
+        handleRecallExplain(rest, context);
+        break;
+
+      case 'promote':
+        handleRecallPromote(rest, context);
+        break;
+
+      case 'link':
+        await handleRecallLink(rest, context);
+        break;
+
+      case 'list':
+      case 'ls':
+        handleRecallList(rest, context);
+        break;
+
+      case 'remove':
+      case 'delete':
+      case 'rm':
+        handleRecallRemove(rest, context);
+        break;
+
+      case 'export':
+        handleRecallExport(rest, context);
+        break;
+
+      case 'import':
+        await handleRecallImport(rest, context);
+        break;
+
+      case 'handoff-export':
+      case 'share':
+        handleRecallHandoffExport(rest, context);
+        break;
+
+      case 'handoff-inspect':
+        handleRecallHandoffInspect(rest, context);
+        break;
+
+      case 'handoff-import':
+        await handleRecallHandoffImport(rest, context);
+        break;
+
+      default: {
+        const usage = [
+          'Usage: /recall <subcommand>',
+          '  add <class> <summary> [--scope <session|project|team>] [--detail <text>] [--tags <t,t>] [--session <id>] [--task <id>] [--file <path>]',
+          `       classes: ${VALID_CLASSES.join(', ')}`,
+          '  capture incident <id|latest>                    — Capture a forensics incident as durable memory',
+          '  capture policy                                  — Capture the latest policy preflight review as durable memory',
+          '  capture mcp <server>                            — Capture MCP trust/quarantine posture as durable memory',
+          '  capture plugin <name>                           — Capture plugin trust/quarantine posture as durable memory',
+          '  search [query] [--semantic] [--cls <class>] [--scope <scope>] [--limit <n>]  — Full-text or sqlite-vec semantic search',
+          '  vector [status|doctor|rebuild]                  — Inspect or rebuild the sqlite-vec memory index',
+          '  get <id>                                       — Show record with provenance + links',
+          '  link <fromId> <toId> <relation>               — Create a directed relation between records',
+          '  queue [limit]                                  — Show the operator review queue',
+          '  review <id> <state> [--confidence <n>] [--by <name>] [--reason <text>]',
+          '  stale <id> [reason...]                          — Mark a record stale with an operator reason',
+          '  contradict <id> [reason...]                     — Mark a record contradicted with an operator reason',
+          '  explain <task...> [--scope <path> ...]         — Show the knowledge records that would be injected for a task',
+          '  promote <id> <scope>                           — Promote a memory record into session|project|team scope',
+          '  export <path> [--scope <scope>] [--cls <class>] — Export a durable knowledge bundle',
+          '  import <path>                                  — Import a durable knowledge bundle',
+          '  handoff-export <path> [--scope <scope>]        — Export a reviewable handoff bundle for team/shared use',
+          '  handoff-inspect <path>                         — Inspect a handoff bundle before import',
+          '  handoff-import <path>                          — Import a handoff bundle into durable memory',
+          '  list [class] [--scope <scope>]                 — List all records grouped by class',
+          '  remove <id>                                    — Delete a record',
+        ].join('\n');
+        context.print(usage);
+        break;
+      }
+    }
+  },
+};

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

@@ -0,0 +1,83 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { requireWebhookNotifier } from './runtime-services.ts';
+
+export function registerNotifyRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'notify',
+    aliases: [],
+    description: 'Manage webhook notification URLs (ntfy.sh format)',
+    usage: 'add <url> | remove <url> | list | clear | test',
+    argsHint: 'add|remove|list|clear|test',
+    async handler(args, ctx) {
+      const notifications = ctx.platform.configManager.getCategory('notifications');
+      const urls: string[] = Array.isArray(notifications.webhookUrls) ? [...notifications.webhookUrls] : [];
+      const notifier = requireWebhookNotifier(ctx);
+      const sub = args[0];
+
+      if (!sub || sub === 'list') {
+        if (urls.length === 0) ctx.print('No webhook URLs configured.\nUse: /notify add <url>');
+        else ctx.print(`Webhook URLs (${urls.length}):\n${urls.map((u, i) => `  ${i + 1}. ${u}`).join('\n')}`);
+        return;
+      }
+
+      if (sub === 'add') {
+        const url = args[1];
+        if (!url) {
+          ctx.print('Usage: /notify add <url>\nExample: /notify add https://ntfy.sh/my-topic');
+          return;
+        }
+        try { new URL(url); } catch {
+          ctx.print(`Invalid URL: ${url}`);
+          return;
+        }
+        if (urls.includes(url)) {
+          ctx.print(`Already configured: ${url}`);
+          return;
+        }
+        urls.push(url);
+        ctx.platform.configManager.mergeCategory('notifications', { webhookUrls: urls });
+        notifier.setUrls(urls);
+        ctx.print(`Webhook added: ${url}`);
+        return;
+      }
+
+      if (sub === 'remove') {
+        const url = args[1];
+        if (!url) {
+          ctx.print('Usage: /notify remove <url>');
+          return;
+        }
+        const next = urls.filter((u) => u !== url);
+        if (next.length === urls.length) {
+          ctx.print(`Not found: ${url}`);
+          return;
+        }
+        ctx.platform.configManager.mergeCategory('notifications', { webhookUrls: next });
+        notifier.setUrls(next);
+        ctx.print(`Webhook removed: ${url}`);
+        return;
+      }
+
+      if (sub === 'clear') {
+        ctx.platform.configManager.mergeCategory('notifications', { webhookUrls: [] });
+        notifier.setUrls([]);
+        ctx.print('All webhook URLs cleared.');
+        return;
+      }
+
+      if (sub === 'test') {
+        if (urls.length === 0) {
+          ctx.print('No webhook URLs configured. Use: /notify add <url>');
+          return;
+        }
+        ctx.print(`Testing ${urls.length} webhook${urls.length !== 1 ? 's' : ''}...`);
+        notifier.setUrls(urls);
+        const results = await notifier.test();
+        ctx.print(results.map((r) => r.ok ? `  [ok] ${r.url}` : `  [fail] ${r.url} — ${r.error ?? 'unknown error'}`).join('\n'));
+        return;
+      }
+
+      ctx.print('Usage: /notify add <url> | remove <url> | list | clear | test');
+    },
+  });
+}

package/src/input/commands/operator-panel-runtime.ts

@@ -0,0 +1,141 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { requirePanelManager } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+export function registerOperatorPanelCommand(registry: CommandRegistry): void {
+  registry.register({
+    name: 'panel',
+    aliases: ['panels', 'p'],
+    description: 'Open, place, resize, or list panels. Usage: /panel [open <id> [top|bottom]|close <id>|list|toggle|move|focus|split|width|height]',
+    usage: '[open <id> [top|bottom]|close <id>|list|toggle|move <top|bottom|other> [id]|focus <top|bottom|toggle>|split [show|hide|toggle]|width <left|right|reset>|height <up|down|reset>]',
+    argsHint: '<open|close|list|toggle|move|focus|split|width|height> [id]',
+    handler(args, ctx) {
+      const pm = requirePanelManager(ctx);
+      const sub = args[0]?.toLowerCase() ?? '';
+      if (!sub || sub === 'toggle') {
+        try {
+          if (ctx.showPanel) ctx.showPanel('panel-list');
+          else {
+            pm.open('panel-list');
+            pm.show();
+            ctx.renderRequest();
+          }
+        } catch {
+          pm.toggle();
+          ctx.renderRequest();
+        }
+      } else if (sub === 'list') {
+        try {
+          if (ctx.showPanel) ctx.showPanel('panel-list');
+          else {
+            pm.open('panel-list');
+            pm.show();
+            ctx.renderRequest();
+          }
+        } catch {
+          pm.show();
+          ctx.renderRequest();
+        }
+      } else if (sub === 'open') {
+        const id = args[1];
+        const pane = args[2]?.toLowerCase();
+        if (!id) { ctx.print('Usage: /panel open <panel-id>'); return; }
+        if (pane && pane !== 'top' && pane !== 'bottom') {
+          ctx.print('Usage: /panel open <panel-id> [top|bottom]');
+          return;
+        }
+        try {
+          if (ctx.showPanel) ctx.showPanel(id, pane as 'top' | 'bottom' | undefined);
+          else {
+            pm.open(id, pane as 'top' | 'bottom' | undefined);
+            pm.show();
+            ctx.renderRequest();
+          }
+          ctx.print(`Panel opened: ${id}${pane ? ` (${pane} pane)` : ''}`);
+        } catch (e) {
+          ctx.print(`Error: ${summarizeError(e)}`);
+        }
+      } else if (sub === 'close') {
+        const id = args[1];
+        if (!id) { ctx.print('Usage: /panel close <panel-id>'); return; }
+        try {
+          pm.close(id);
+          ctx.renderRequest();
+          ctx.print(`Panel closed: ${id}`);
+        } catch (e) {
+          ctx.print(`Error: ${summarizeError(e)}`);
+        }
+      } else if (sub === 'move') {
+        const dest = args[1]?.toLowerCase();
+        if (dest !== 'top' && dest !== 'bottom' && dest !== 'other') {
+          ctx.print('Usage: /panel move <top|bottom|other> [panel-id]');
+          return;
+        }
+        const panelId = args[2];
+        try {
+          if (dest === 'other') pm.moveToOtherPane(panelId);
+          else pm.moveToPane(dest, panelId);
+          ctx.renderRequest();
+          ctx.print(`Panel moved to ${dest} pane`);
+        } catch (e) {
+          ctx.print(`Error: ${summarizeError(e)}`);
+        }
+      } else if (sub === 'focus') {
+        const pane = args[1]?.toLowerCase();
+        if (pane !== 'top' && pane !== 'bottom' && pane !== 'toggle') {
+          ctx.print('Usage: /panel focus <top|bottom|toggle>');
+          return;
+        }
+        if (pane === 'toggle') pm.togglePaneFocus();
+        else pm.focusPane(pane);
+        ctx.renderRequest();
+        ctx.print(`Focused ${pm.getFocusedPane()} pane`);
+      } else if (sub === 'split') {
+        const mode = args[1]?.toLowerCase() ?? 'toggle';
+        if (mode !== 'toggle' && mode !== 'show' && mode !== 'hide') {
+          ctx.print('Usage: /panel split [show|hide|toggle]');
+          return;
+        }
+        if (mode === 'show' && !pm.isBottomPaneVisible()) pm.toggleBottomPane();
+        if (mode === 'hide' && pm.isBottomPaneVisible()) pm.toggleBottomPane();
+        if (mode === 'toggle') pm.toggleBottomPane();
+        ctx.renderRequest();
+        ctx.print(pm.isBottomPaneVisible() ? 'Bottom pane visible' : 'Bottom pane hidden');
+      } else if (sub === 'width') {
+        const dir = args[1]?.toLowerCase();
+        if (dir !== 'left' && dir !== 'right' && dir !== 'reset') {
+          ctx.print('Usage: /panel width <left|right|reset>');
+          return;
+        }
+        if (dir === 'left') pm.widenLeft();
+        else if (dir === 'right') pm.widenRight();
+        else pm.setSplitRatio(0.6);
+        ctx.renderRequest();
+        ctx.print(`Panel width ratio: ${pm.getSplitRatio().toFixed(2)}`);
+      } else if (sub === 'height') {
+        const dir = args[1]?.toLowerCase();
+        if (dir !== 'up' && dir !== 'down' && dir !== 'reset') {
+          ctx.print('Usage: /panel height <up|down|reset>');
+          return;
+        }
+        if (dir === 'up') pm.setVerticalSplitRatio(pm.getVerticalSplitRatio() - 0.05);
+        else if (dir === 'down') pm.setVerticalSplitRatio(pm.getVerticalSplitRatio() + 0.05);
+        else pm.setVerticalSplitRatio(0.5);
+        ctx.renderRequest();
+        ctx.print(`Panel height ratio: ${pm.getVerticalSplitRatio().toFixed(2)}`);
+      } else {
+        const id = args[0]!;
+        try {
+          if (ctx.showPanel) ctx.showPanel(id);
+          else {
+            pm.open(id);
+            pm.show();
+            ctx.renderRequest();
+          }
+        } catch {
+          ctx.print(`Unknown panel "${id}". Use /panel list to see available panels.`);
+        }
+      }
+    },
+  });
+}