@pellux/goodvibes-agent 1.1.6 → 1.2.0

package/src/tools/agent-settings-tool.ts

@@ -0,0 +1,176 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
+import { createAgentHarnessTool } from './agent-harness-tool.ts';
+import { createAgentSettingsImportTool } from './agent-settings-import-tool.ts';
+
+type AgentSettingsAction =
+  | 'list'
+  | 'get'
+  | 'set'
+  | 'reset'
+  | 'import';
+
+interface AgentSettingsToolArgs {
+  readonly action?: unknown;
+  readonly mode?: unknown;
+  readonly key?: unknown;
+  readonly setting?: unknown;
+  readonly target?: unknown;
+  readonly query?: unknown;
+  readonly category?: unknown;
+  readonly prefix?: unknown;
+  readonly value?: unknown;
+  readonly includeHidden?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+interface AgentSettingsToolDeps {
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly toolRegistry: ToolRegistry;
+  readonly harnessTool?: Tool;
+  readonly settingsImportTool?: Tool;
+}
+
+function error(message: string): { readonly success: false; readonly error: string } {
+  return { success: false, error: message };
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true || (typeof value === 'string' && ['true', 'yes', 'apply', 'run'].includes(value.trim().toLowerCase()));
+}
+
+function normalizeSettingsAction(value: unknown): AgentSettingsAction | null {
+  const action = readString(value).toLowerCase().replace(/-/g, '_');
+  if (!action) return null;
+  if (action === 'list' || action === 'status' || action === 'settings' || action === 'catalog' || action === 'search' || action === 'find' || action === 'browse') return 'list';
+  if (action === 'get' || action === 'show' || action === 'inspect' || action === 'read' || action === 'setting' || action === 'get_setting') return 'get';
+  if (action === 'set' || action === 'update' || action === 'change' || action === 'configure' || action === 'set_setting') return 'set';
+  if (action === 'reset' || action === 'clear' || action === 'default' || action === 'restore' || action === 'reset_setting') return 'reset';
+  if (action === 'import' || action === 'import_settings' || action === 'settings_import' || action === 'import_goodvibes' || action === 'goodvibes_import' || action === 'preview_import' || action === 'apply_import') return 'import';
+  return null;
+}
+
+function readAction(args: AgentSettingsToolArgs): AgentSettingsAction {
+  const explicit = normalizeSettingsAction(args.action) ?? normalizeSettingsAction(args.mode);
+  if (explicit) return explicit;
+  if (readString(args.key) || readString(args.setting)) return 'get';
+  return 'list';
+}
+
+function compactArgs(entries: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function settingKey(args: AgentSettingsToolArgs): string {
+  return readString(args.key) || readString(args.setting);
+}
+
+function confirmedArgs(args: AgentSettingsToolArgs): Record<string, unknown> {
+  return compactArgs({
+    confirm: args.confirm,
+    explicitUserRequest: args.explicitUserRequest,
+  });
+}
+
+function settingsListArgs(args: AgentSettingsToolArgs): Record<string, unknown> {
+  return compactArgs({
+    mode: 'settings',
+    category: args.category,
+    prefix: args.prefix,
+    query: args.query ?? args.target,
+    includeHidden: args.includeHidden,
+    includeParameters: args.includeParameters,
+    limit: args.limit,
+  });
+}
+
+function settingsLookupArgs(mode: 'get_setting' | 'set_setting' | 'reset_setting', args: AgentSettingsToolArgs): Record<string, unknown> {
+  const key = settingKey(args);
+  return compactArgs({
+    mode,
+    key,
+    target: key ? undefined : args.target,
+    query: key ? undefined : args.query,
+    category: args.category,
+    prefix: args.prefix,
+    value: mode === 'set_setting' ? args.value : undefined,
+    includeHidden: args.includeHidden,
+    ...confirmedArgs(args),
+  });
+}
+
+export function createAgentSettingsTool(deps: AgentSettingsToolDeps): Tool {
+  const harnessTool = deps.harnessTool ?? createAgentHarnessTool({
+    commandRegistry: deps.commandRegistry,
+    commandContext: deps.commandContext,
+    toolRegistry: deps.toolRegistry,
+  });
+  const settingsImportTool = deps.settingsImportTool ?? createAgentSettingsImportTool(deps.commandContext);
+
+  return {
+    definition: {
+      name: 'settings',
+      description: 'List, inspect, change, reset, or import settings.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['list', 'get', 'set', 'reset', 'import'],
+            description: 'Read settings or confirm setting changes/imports.',
+          },
+          mode: { type: 'string', description: 'Alias for action.' },
+          key: { type: 'string', description: 'Exact setting key.' },
+          setting: { type: 'string', description: 'Alias for key.' },
+          target: { type: 'string', description: 'Setting lookup text.' },
+          query: { type: 'string', description: 'Setting search text.' },
+          category: { type: 'string', description: 'Top-level setting category.' },
+          prefix: { type: 'string', description: 'Setting key prefix.' },
+          value: { description: 'Value for action:set.' },
+          includeHidden: { type: 'boolean', description: 'Include scriptable or hidden settings.' },
+          includeParameters: { type: 'boolean', description: 'Include full setting metadata.' },
+          limit: { type: 'number', description: 'Maximum settings to return.' },
+          confirm: { type: 'boolean', description: 'Required true for set/reset/import apply.' },
+          explicitUserRequest: { type: 'string', description: 'User request authorizing confirmed setting effects.' },
+        },
+        additionalProperties: false,
+      },
+      sideEffects: ['state'],
+      concurrency: 'serial',
+    },
+    execute: async (rawArgs: unknown) => {
+      const args = (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs) ? rawArgs : {}) as AgentSettingsToolArgs;
+      const action = readAction(args);
+
+      if (action === 'list') return harnessTool.execute(settingsListArgs(args));
+      if (action === 'get') return harnessTool.execute(settingsLookupArgs('get_setting', args));
+      if (action === 'set') return harnessTool.execute(settingsLookupArgs('set_setting', args));
+      if (action === 'reset') return harnessTool.execute(settingsLookupArgs('reset_setting', args));
+      if (action === 'import') {
+        return settingsImportTool.execute({
+          action: readBoolean(args.confirm) ? 'apply' : 'preview',
+          ...confirmedArgs(args),
+        });
+      }
+
+      return error('Unknown settings action. Use action:"list" to inspect settings.');
+    },
+  };
+}
+
+export function registerAgentSettingsTool(
+  registry: ToolRegistry,
+  commandRegistry: CommandRegistry,
+  commandContext: CommandContext,
+): void {
+  if (!registry.has('settings')) registry.register(createAgentSettingsTool({ commandRegistry, commandContext, toolRegistry: registry }));
+}

package/src/tools/agent-setup-tool.ts

@@ -0,0 +1,226 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
+import { createAgentHarnessTool } from './agent-harness-tool.ts';
+import { createAgentSettingsImportTool } from './agent-settings-import-tool.ts';
+
+type AgentSetupAction =
+  | 'status'
+  | 'item'
+  | 'repair'
+  | 'checkpoint'
+  | 'save_checkpoint'
+  | 'clear_checkpoint'
+  | 'token'
+  | 'smoke'
+  | 'finish'
+  | 'import_settings';
+
+interface AgentSetupToolArgs {
+  readonly action?: unknown;
+  readonly mode?: unknown;
+  readonly setupItemId?: unknown;
+  readonly itemId?: unknown;
+  readonly target?: unknown;
+  readonly query?: unknown;
+  readonly fields?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+interface AgentSetupToolDeps {
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly toolRegistry: ToolRegistry;
+  readonly harnessTool?: Tool;
+  readonly settingsImportTool?: Tool;
+}
+
+function output(value: unknown): { readonly success: true; readonly output: string } {
+  return {
+    success: true,
+    output: typeof value === 'string' ? value : JSON.stringify(value, null, 2),
+  };
+}
+
+function error(message: string): { readonly success: false; readonly error: string } {
+  return { success: false, error: message };
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true || (typeof value === 'string' && ['true', 'yes', 'apply', 'run'].includes(value.trim().toLowerCase()));
+}
+
+function normalizeSetupAction(value: unknown): AgentSetupAction | null {
+  const action = readString(value).toLowerCase().replace(/-/g, '_');
+  if (!action) return null;
+  if (action === 'setup' || action === 'posture' || action === 'status' || action === 'summary' || action === 'list') return 'status';
+  if (action === 'item' || action === 'show' || action === 'inspect') return 'item';
+  if (action === 'repair' || action === 'fix' || action === 'diagnose_repair' || action === 'host_repair' || action === 'repair_host' || action === 'launch_host') return 'repair';
+  if (action === 'checkpoint' || action === 'resume' || action === 'checkpoint_status') return 'checkpoint';
+  if (action === 'save_checkpoint' || action === 'mark_checkpoint' || action === 'checkpoint_save' || action === 'save') return 'save_checkpoint';
+  if (action === 'clear_checkpoint' || action === 'reset_checkpoint' || action === 'checkpoint_clear' || action === 'clear') return 'clear_checkpoint';
+  if (action === 'token' || action === 'auth' || action === 'provision_token' || action === 'repair_token') return 'token';
+  if (action === 'smoke' || action === 'run_smoke' || action === 'install_smoke') return 'smoke';
+  if (action === 'finish' || action === 'closeout' || action === 'apply_close' || action === 'apply_and_close') return 'finish';
+  if (action === 'import' || action === 'import_settings' || action === 'settings_import') return 'import_settings';
+  return null;
+}
+
+function readAction(args: AgentSetupToolArgs): AgentSetupAction {
+  const explicit = normalizeSetupAction(args.action) ?? normalizeSetupAction(args.mode);
+  if (explicit) return explicit;
+  if (readString(args.setupItemId) || readString(args.itemId)) return 'item';
+  return 'status';
+}
+
+function itemLookup(args: AgentSetupToolArgs): string {
+  return readString(args.setupItemId) || readString(args.itemId);
+}
+
+function compactArgs(entries: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function setupStatusArgs(args: AgentSetupToolArgs): Record<string, unknown> {
+  return compactArgs({
+    mode: 'setup_posture',
+    query: args.query,
+    limit: args.limit,
+    includeParameters: args.includeParameters,
+  });
+}
+
+function setupItemArgs(args: AgentSetupToolArgs): Record<string, unknown> {
+  const setupItemId = itemLookup(args);
+  return compactArgs({
+    mode: 'setup_item',
+    setupItemId,
+    target: setupItemId ? undefined : args.target,
+    query: setupItemId ? undefined : args.query,
+    includeParameters: args.includeParameters,
+  });
+}
+
+function confirmedArgs(args: AgentSetupToolArgs): Record<string, unknown> {
+  return compactArgs({
+    confirm: args.confirm,
+    explicitUserRequest: args.explicitUserRequest,
+  });
+}
+
+export function createAgentSetupTool(deps: AgentSetupToolDeps): Tool {
+  const harnessTool = deps.harnessTool ?? createAgentHarnessTool({
+    commandRegistry: deps.commandRegistry,
+    commandContext: deps.commandContext,
+    toolRegistry: deps.toolRegistry,
+  });
+  const settingsImportTool = deps.settingsImportTool ?? createAgentSettingsImportTool(deps.commandContext);
+
+  return {
+    definition: {
+      name: 'setup',
+      description: 'Inspect and complete first-run Agent setup.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['status', 'item', 'repair', 'checkpoint', 'save_checkpoint', 'clear_checkpoint', 'token', 'smoke', 'finish', 'import_settings'],
+            description: 'Setup action; read status/item/checkpoint, confirm mutations.',
+          },
+          mode: { type: 'string', description: 'Alias for action.' },
+          setupItemId: { type: 'string', description: 'Setup item id.' },
+          itemId: { type: 'string', description: 'Alias for setupItemId.' },
+          target: { type: 'string', description: 'Setup item lookup text.' },
+          query: { type: 'string', description: 'Filter setup status or lookup a setup item.' },
+          fields: { type: 'object', description: 'Optional redacted setup-smoke evidence fields.' },
+          includeParameters: { type: 'boolean', description: 'Include bounded route details and parameters where supported.' },
+          limit: { type: 'number', description: 'Optional status list limit.' },
+          confirm: { type: 'boolean', description: 'Required true for setup mutations.' },
+          explicitUserRequest: { type: 'string', description: 'User request authorizing confirmed setup effects.' },
+        },
+        additionalProperties: false,
+      },
+      sideEffects: ['state'],
+      concurrency: 'serial',
+    },
+    execute: async (rawArgs: unknown) => {
+      const args = (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs) ? rawArgs : {}) as AgentSetupToolArgs;
+      const action = readAction(args);
+
+      if (action === 'status') return harnessTool.execute(setupStatusArgs(args));
+      if (action === 'item') return harnessTool.execute(setupItemArgs(args));
+      if (action === 'repair') {
+        return harnessTool.execute(compactArgs({
+          mode: 'setup_repair',
+          setupItemId: itemLookup(args) || undefined,
+          target: itemLookup(args) ? undefined : args.target,
+          query: itemLookup(args) ? undefined : args.query,
+          includeParameters: args.includeParameters,
+        }));
+      }
+      if (action === 'checkpoint') return harnessTool.execute({ mode: 'setup_checkpoint' });
+      if (action === 'save_checkpoint') {
+        return harnessTool.execute({
+          mode: 'mark_setup_checkpoint',
+          ...compactArgs({ setupItemId: itemLookup(args) || undefined }),
+          ...confirmedArgs(args),
+        });
+      }
+      if (action === 'clear_checkpoint') {
+        return harnessTool.execute({
+          mode: 'clear_setup_checkpoint',
+          ...confirmedArgs(args),
+        });
+      }
+      if (action === 'token') {
+        return harnessTool.execute({
+          mode: 'provision_connected_host_token',
+          setupItemId: itemLookup(args) || 'connected-host-auth',
+          ...confirmedArgs(args),
+        });
+      }
+      if (action === 'smoke') {
+        return harnessTool.execute({
+          mode: 'run_setup_smoke',
+          setupItemId: itemLookup(args) || 'install-smoke',
+          ...compactArgs({
+            fields: args.fields,
+            includeParameters: args.includeParameters,
+          }),
+          ...confirmedArgs(args),
+        });
+      }
+      if (action === 'finish') {
+        return harnessTool.execute({
+          mode: 'run_workspace_action',
+          actionId: 'onboarding-apply-close',
+          ...confirmedArgs(args),
+        });
+      }
+      if (action === 'import_settings') {
+        return settingsImportTool.execute({
+          action: readBoolean(args.confirm) ? 'apply' : 'preview',
+          ...confirmedArgs(args),
+        });
+      }
+
+      return error('Unknown setup action. Use action:"status" to inspect first-run setup.');
+    },
+  };
+}
+
+export function registerAgentSetupTool(
+  registry: ToolRegistry,
+  commandRegistry: CommandRegistry,
+  commandContext: CommandContext,
+): void {
+  if (!registry.has('setup')) registry.register(createAgentSetupTool({ commandRegistry, commandContext, toolRegistry: registry }));
+}

package/src/tools/agent-support-tool.ts

@@ -0,0 +1,122 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
+import { createAgentHarnessTool } from './agent-harness-tool.ts';
+
+type AgentSupportAction = 'status' | 'bundle';
+
+interface AgentSupportToolArgs {
+  readonly action?: unknown;
+  readonly mode?: unknown;
+  readonly id?: unknown;
+  readonly bundlePath?: unknown;
+  readonly target?: unknown;
+  readonly query?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+}
+
+interface AgentSupportToolDeps {
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly toolRegistry: ToolRegistry;
+  readonly harnessTool?: Tool;
+}
+
+function error(message: string): { readonly success: false; readonly error: string } {
+  return { success: false, error: message };
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeSupportAction(value: unknown): AgentSupportAction | null {
+  const action = readString(value).toLowerCase().replace(/-/g, '_');
+  if (!action) return null;
+  if (['status', 'summary', 'list', 'catalog', 'routes', 'bundles', 'diagnostics'].includes(action)) return 'status';
+  if (['bundle', 'inspect', 'show', 'get', 'support_bundle'].includes(action)) return 'bundle';
+  return null;
+}
+
+function readAction(args: AgentSupportToolArgs): AgentSupportAction | null {
+  const explicit = normalizeSupportAction(args.action) ?? normalizeSupportAction(args.mode);
+  if (explicit) return explicit;
+  if (readString(args.bundlePath) || readString(args.id)) return 'bundle';
+  return 'status';
+}
+
+function compactArgs(entries: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function statusArgs(args: AgentSupportToolArgs): Record<string, unknown> {
+  return compactArgs({
+    mode: 'support_bundles',
+    query: args.query ?? args.target,
+    includeParameters: args.includeParameters,
+    limit: args.limit,
+  });
+}
+
+function bundleArgs(args: AgentSupportToolArgs): Record<string, unknown> {
+  const bundlePath = readString(args.bundlePath) || readString(args.id);
+  return compactArgs({
+    mode: 'support_bundle',
+    bundlePath,
+    target: bundlePath ? undefined : args.target,
+    query: bundlePath ? undefined : args.query,
+    includeParameters: args.includeParameters,
+  });
+}
+
+export function createAgentSupportTool(deps: AgentSupportToolDeps): Tool {
+  const harnessTool = deps.harnessTool ?? createAgentHarnessTool({
+    commandRegistry: deps.commandRegistry,
+    commandContext: deps.commandContext,
+    toolRegistry: deps.toolRegistry,
+  });
+
+  return {
+    definition: {
+      name: 'support',
+      description: 'Read support-bundle routes and redacted bundle summaries.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['status', 'bundle'],
+            description: 'List support bundle routes or inspect one existing bundle.',
+          },
+          mode: { type: 'string', description: 'Alias for action.' },
+          id: { type: 'string', description: 'Alias for bundlePath.' },
+          bundlePath: { type: 'string', description: 'Workspace-relative support bundle path to inspect.' },
+          target: { type: 'string', description: 'Lookup target or search text.' },
+          query: { type: 'string', description: 'Search text.' },
+          includeParameters: { type: 'boolean', description: 'Include detailed route and policy metadata.' },
+          limit: { type: 'number', description: 'Maximum bundle routes returned.' },
+        },
+        additionalProperties: false,
+      },
+      sideEffects: [],
+      concurrency: 'parallel',
+    },
+    execute: async (rawArgs: unknown) => {
+      const args = (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs) ? rawArgs : {}) as AgentSupportToolArgs;
+      const action = readAction(args);
+      if (!action) return error('Unknown support action. Use action:"status" or action:"bundle".');
+      if (action === 'status') return harnessTool.execute(statusArgs(args));
+      if (action === 'bundle') return harnessTool.execute(bundleArgs(args));
+      return error('Unknown support action. Use action:"status" or action:"bundle".');
+    },
+  };
+}
+
+export function registerAgentSupportTool(
+  registry: ToolRegistry,
+  commandRegistry: CommandRegistry,
+  commandContext: CommandContext,
+): void {
+  if (!registry.has('support')) registry.register(createAgentSupportTool({ commandRegistry, commandContext, toolRegistry: registry }));
+}