feat: add internal hooks system

src/commands/onboard-hooks.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { setupInternalHooks } from './onboard-hooks.js';
+import type { ClawdbotConfig } from '../config/config.js';
+import type { RuntimeEnv } from '../runtime.js';
+import type { WizardPrompter } from '../wizard/prompts.js';
+import type { HookStatusReport } from '../hooks/hooks-status.js';
+
+// Mock hook discovery modules
+vi.mock('../hooks/hooks-status.js', () => ({
+  buildWorkspaceHookStatus: vi.fn(),
+}));
+
+vi.mock('../agents/agent-scope.js', () => ({
+  resolveAgentWorkspaceDir: vi.fn().mockReturnValue('/mock/workspace'),
+  resolveDefaultAgentId: vi.fn().mockReturnValue('main'),
+}));
+
+describe('onboard-hooks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const createMockPrompter = (multiselectValue: string[]): WizardPrompter => ({
+    confirm: vi.fn().mockResolvedValue(true),
+    note: vi.fn().mockResolvedValue(undefined),
+    intro: vi.fn().mockResolvedValue(undefined),
+    outro: vi.fn().mockResolvedValue(undefined),
+    text: vi.fn().mockResolvedValue(''),
+    select: vi.fn().mockResolvedValue(''),
+    multiselect: vi.fn().mockResolvedValue(multiselectValue),
+    progress: vi.fn().mockReturnValue({
+      stop: vi.fn(),
+      update: vi.fn(),
+    }),
+  });
+
+  const createMockRuntime = (): RuntimeEnv => ({
+    log: vi.fn(),
+    error: vi.fn(),
+    exit: vi.fn(),
+  });
+
+  const createMockHookReport = (eligible = true): HookStatusReport => ({
+    workspaceDir: '/mock/workspace',
+    managedHooksDir: '/mock/.clawdbot/hooks',
+    hooks: [
+      {
+        name: 'session-memory',
+        description: 'Save session context to memory when /new command is issued',
+        source: 'clawdbot-bundled',
+        emoji: '💾',
+        events: ['command:new'],
+        disabled: false,
+        eligible,
+        requirements: { config: ['workspace.dir'] },
+        missing: {},
+      },
+    ],
+  });
+
+  describe('setupInternalHooks', () => {
+    it('should enable internal hooks when user selects them', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport());
+
+      const cfg: ClawdbotConfig = {};
+      const prompter = createMockPrompter(['session-memory']);
+      const runtime = createMockRuntime();
+
+      const result = await setupInternalHooks(cfg, runtime, prompter);
+
+      expect(result.hooks?.internal?.enabled).toBe(true);
+      expect(result.hooks?.internal?.entries).toEqual({
+        'session-memory': { enabled: true },
+      });
+      expect(prompter.note).toHaveBeenCalledTimes(2);
+      expect(prompter.multiselect).toHaveBeenCalledWith({
+        message: 'Enable internal hooks?',
+        options: [
+          { value: '__skip__', label: 'Skip for now' },
+          {
+            value: 'session-memory',
+            label: '💾 session-memory',
+            hint: 'Save session context to memory when /new command is issued',
+          },
+        ],
+      });
+    });
+
+    it('should not enable hooks when user skips', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport());
+
+      const cfg: ClawdbotConfig = {};
+      const prompter = createMockPrompter(['__skip__']);
+      const runtime = createMockRuntime();
+
+      const result = await setupInternalHooks(cfg, runtime, prompter);
+
+      expect(result.hooks?.internal).toBeUndefined();
+      expect(prompter.note).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle no eligible hooks', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport(false));
+
+      const cfg: ClawdbotConfig = {};
+      const prompter = createMockPrompter([]);
+      const runtime = createMockRuntime();
+
+      const result = await setupInternalHooks(cfg, runtime, prompter);
+
+      expect(result).toEqual(cfg);
+      expect(prompter.multiselect).not.toHaveBeenCalled();
+      expect(prompter.note).toHaveBeenCalledWith(
+        'No eligible hooks found. You can configure hooks later in your config.',
+        'No Hooks Available',
+      );
+    });
+
+    it('should preserve existing hooks config when enabled', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport());
+
+      const cfg: ClawdbotConfig = {
+        hooks: {
+          enabled: true,
+          path: '/webhook',
+          token: 'existing-token',
+        },
+      };
+      const prompter = createMockPrompter(['session-memory']);
+      const runtime = createMockRuntime();
+
+      const result = await setupInternalHooks(cfg, runtime, prompter);
+
+      expect(result.hooks?.enabled).toBe(true);
+      expect(result.hooks?.path).toBe('/webhook');
+      expect(result.hooks?.token).toBe('existing-token');
+      expect(result.hooks?.internal?.enabled).toBe(true);
+      expect(result.hooks?.internal?.entries).toEqual({
+        'session-memory': { enabled: true },
+      });
+    });
+
+    it('should preserve existing config when user skips', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport());
+
+      const cfg: ClawdbotConfig = {
+        agents: { defaults: { workspace: '/workspace' } },
+      };
+      const prompter = createMockPrompter(['__skip__']);
+      const runtime = createMockRuntime();
+
+      const result = await setupInternalHooks(cfg, runtime, prompter);
+
+      expect(result).toEqual(cfg);
+      expect(result.agents?.defaults?.workspace).toBe('/workspace');
+    });
+
+    it('should show informative notes to user', async () => {
+      const { buildWorkspaceHookStatus } = await import('../hooks/hooks-status.js');
+      vi.mocked(buildWorkspaceHookStatus).mockReturnValue(createMockHookReport());
+
+      const cfg: ClawdbotConfig = {};
+      const prompter = createMockPrompter(['session-memory']);
+      const runtime = createMockRuntime();
+
+      await setupInternalHooks(cfg, runtime, prompter);
+
+      const noteCalls = (prompter.note as ReturnType<typeof vi.fn>).mock.calls;
+      expect(noteCalls).toHaveLength(2);
+
+      // First note should explain what internal hooks are
+      expect(noteCalls[0][0]).toContain('Internal hooks');
+      expect(noteCalls[0][0]).toContain('automate actions');
+
+      // Second note should confirm configuration
+      expect(noteCalls[1][0]).toContain('Enabled 1 hook: session-memory');
+      expect(noteCalls[1][0]).toContain('clawdbot hooks internal list');
+    });
+  });
+});

src/commands/onboard-hooks.ts

@@ -0,0 +1,86 @@
+import type { ClawdbotConfig } from "../config/config.js";
+import type { RuntimeEnv } from "../runtime.js";
+import type { WizardPrompter } from "../wizard/prompts.js";
+import { buildWorkspaceHookStatus } from "../hooks/hooks-status.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
+
+export async function setupInternalHooks(
+  cfg: ClawdbotConfig,
+  runtime: RuntimeEnv,
+  prompter: WizardPrompter,
+): Promise<ClawdbotConfig> {
+  await prompter.note(
+    [
+      "Internal hooks let you automate actions when agent commands are issued.",
+      "Example: Save session context to memory when you issue /new.",
+      "",
+      "Learn more: https://docs.clawd.bot/internal-hooks",
+    ].join("\n"),
+    "Internal Hooks",
+  );
+
+  // Discover available hooks using the hook discovery system
+  const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
+  const report = buildWorkspaceHookStatus(workspaceDir, { config: cfg });
+
+  // Filter for eligible and recommended hooks (session-memory is recommended)
+  const recommendedHooks = report.hooks.filter(
+    (h) => h.eligible && h.name === "session-memory",
+  );
+
+  if (recommendedHooks.length === 0) {
+    await prompter.note(
+      "No eligible hooks found. You can configure hooks later in your config.",
+      "No Hooks Available",
+    );
+    return cfg;
+  }
+
+  const toEnable = await prompter.multiselect({
+    message: "Enable internal hooks?",
+    options: [
+      { value: "__skip__", label: "Skip for now" },
+      ...recommendedHooks.map((hook) => ({
+        value: hook.name,
+        label: `${hook.emoji ?? "🔗"} ${hook.name}`,
+        hint: hook.description,
+      })),
+    ],
+  });
+
+  const selected = toEnable.filter((name) => name !== "__skip__");
+  if (selected.length === 0) {
+    return cfg;
+  }
+
+  // Enable selected hooks using the new entries config format
+  const entries = { ...cfg.hooks?.internal?.entries };
+  for (const name of selected) {
+    entries[name] = { enabled: true };
+  }
+
+  const next: ClawdbotConfig = {
+    ...cfg,
+    hooks: {
+      ...cfg.hooks,
+      internal: {
+        enabled: true,
+        entries,
+      },
+    },
+  };
+
+  await prompter.note(
+    [
+      `Enabled ${selected.length} hook${selected.length > 1 ? "s" : ""}: ${selected.join(", ")}`,
+      "",
+      "You can manage hooks later with:",
+      "  clawdbot hooks internal list",
+      "  clawdbot hooks internal enable <name>",
+      "  clawdbot hooks internal disable <name>",
+    ].join("\n"),
+    "Hooks Configured",
+  );
+
+  return next;
+}