kimaki 0.4.76 → 0.4.78

package/dist/worktree-lifecycle.e2e.test.js

@@ -0,0 +1,308 @@
+// E2e test for worktree lifecycle: /new-worktree inside an existing thread,
+// then verify the session still works after sdkDirectory switches.
+// Validates that handleDirectoryChanged() reconnects the event listener
+// so events from the worktree Instance reach the runtime (PR #75 fix).
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval (except worktree creation which
+// involves real git operations — 10s timeout there).
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { describe, beforeAll, afterAll, test, expect } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { store } from './store.js';
+import { startDiscordBot } from './discord-bot.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+import { execAsync } from './worktrees.js';
+const TEST_USER_ID = '200000000000000901';
+const TEXT_CHANNEL_ID = '200000000000000902';
+// Unique worktree name per run to avoid collisions with leftover worktrees
+const WORKTREE_SUFFIX = Date.now().toString(36).slice(-6);
+const WORKTREE_NAME = `wt-e2e-${WORKTREE_SUFFIX}`;
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'worktree-lifecycle-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+/** Initialize a git repo with an initial commit so worktrees can be created. */
+async function initGitRepo(directory) {
+    // Check if already a git repo (directory may persist across runs)
+    const isRepo = fs.existsSync(path.join(directory, '.git'));
+    if (isRepo) {
+        // Commit any new/changed files (opencode.json may have been rewritten)
+        await execAsync('git add -A && git diff --cached --quiet || git commit -m "update"', {
+            cwd: directory,
+        }).catch(() => { return; });
+        return;
+    }
+    await execAsync('git init', { cwd: directory });
+    await execAsync('git config user.email "test@test.com"', { cwd: directory });
+    await execAsync('git config user.name "Test"', { cwd: directory });
+    await execAsync('git add -A && git commit -m "initial"', { cwd: directory });
+}
+function createDeterministicMatchers() {
+    const userReplyMatcher = {
+        id: 'user-reply',
+        priority: 10,
+        when: {
+            lastMessageRole: 'user',
+            rawPromptIncludes: 'Reply with exactly:',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'default-reply' },
+                { type: 'text-delta', id: 'default-reply', delta: 'ok' },
+                { type: 'text-end', id: 'default-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 100, 0, 0, 0],
+        },
+    };
+    return [userReplyMatcher];
+}
+describe('worktree lifecycle', () => {
+    let directories;
+    let discord;
+    let botClient;
+    let previousDefaultVerbosity = null;
+    let testStartTime = Date.now();
+    beforeAll(async () => {
+        testStartTime = Date.now();
+        directories = createRunDirectories();
+        const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
+        process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+        setDataDir(directories.dataDir);
+        previousDefaultVerbosity = store.getState().defaultVerbosity;
+        store.setState({ defaultVerbosity: 'tools_and_text' });
+        const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+        discord = new DigitalDiscord({
+            guild: {
+                name: 'Worktree E2E Guild',
+                ownerId: TEST_USER_ID,
+            },
+            channels: [
+                {
+                    id: TEXT_CHANNEL_ID,
+                    name: 'worktree-e2e',
+                    type: ChannelType.GuildText,
+                },
+            ],
+            users: [
+                {
+                    id: TEST_USER_ID,
+                    username: 'worktree-tester',
+                },
+            ],
+            dbUrl: `file:${digitalDiscordDbPath}`,
+        });
+        await discord.start();
+        const providerNpm = url
+            .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+            .toString();
+        const opencodeConfig = buildDeterministicOpencodeConfig({
+            providerName: 'deterministic-provider',
+            providerNpm,
+            model: 'deterministic-v2',
+            smallModel: 'deterministic-v2',
+            settings: {
+                strict: false,
+                matchers: createDeterministicMatchers(),
+            },
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        // Initialize git repo after writing opencode.json so the initial commit
+        // includes it. Worktrees require at least one commit.
+        await initGitRepo(directories.projectDirectory);
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: TEXT_CHANNEL_ID,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools_and_text');
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        // Pre-warm the opencode server
+        const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
+        if (warmup instanceof Error) {
+            throw warmup;
+        }
+    }, 60_000);
+    afterAll(async () => {
+        if (directories) {
+            await cleanupTestSessions({
+                projectDirectory: directories.projectDirectory,
+                testStartTime,
+            });
+        }
+        if (botClient) {
+            botClient.destroy();
+        }
+        await stopOpencodeServer();
+        await Promise.all([
+            closeDatabase().catch(() => { return; }),
+            stopHranaServer().catch(() => { return; }),
+            discord?.stop().catch(() => { return; }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        if (previousDefaultVerbosity) {
+            store.setState({ defaultVerbosity: previousDefaultVerbosity });
+        }
+        // Clean up the git worktree created during the test
+        if (directories) {
+            const worktreeBranch = `opencode/kimaki-${WORKTREE_NAME}`;
+            await execAsync(`git worktree list --porcelain`, { cwd: directories.projectDirectory }).then(({ stdout }) => {
+                // Find and remove any worktree for our test branch
+                const lines = stdout.split('\n');
+                let currentPath = '';
+                for (const line of lines) {
+                    if (line.startsWith('worktree ')) {
+                        currentPath = line.slice('worktree '.length);
+                    }
+                    if (line.startsWith('branch ') && line.includes(worktreeBranch) && currentPath) {
+                        return execAsync(`git worktree remove --force ${JSON.stringify(currentPath)}`, { cwd: directories.projectDirectory });
+                    }
+                }
+            }).catch(() => { return; });
+            await execAsync(`git branch -D ${JSON.stringify(`opencode/kimaki-${WORKTREE_NAME}`)}`, { cwd: directories.projectDirectory }).catch(() => { return; });
+            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+        }
+    }, 10_000);
+    test('session responds after /new-worktree switches sdkDirectory in existing thread', async () => {
+        // 1. Send a message to create a thread and establish a session
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: before-worktree',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: before-worktree';
+            },
+        });
+        const th = discord.thread(thread.id);
+        // Wait for first run to fully complete (footer appears)
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '*project',
+            timeout: 4_000,
+        });
+        // Capture runtime — should survive the directory switch
+        const runtimeBefore = getRuntime(thread.id);
+        expect(runtimeBefore).toBeDefined();
+        expect(runtimeBefore.sdkDirectory).toBe(directories.projectDirectory);
+        // 2. Run /new-worktree inside the thread (in-thread flow).
+        // This creates a pending worktree, then background creates the git worktree,
+        // then marks it ready. Next message will pick up the worktree directory.
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'new-worktree',
+            options: [{ name: 'name', type: 3, value: WORKTREE_NAME }],
+        });
+        // Wait for the slash command ack
+        await discord
+            .channel(thread.id)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 3. Wait for worktree to become ready — the background creation
+        // edits the starter message to include the branch name.
+        // Git worktree creation involves real git operations, so allow more time.
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Branch:',
+            timeout: 10_000,
+        });
+        // 4. Send a message after the worktree is ready.
+        // Without handleDirectoryChanged (PR #75), the event listener is still
+        // subscribed to the old project directory's Instance, so this message
+        // gets processed but the response events never reach the runtime.
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: after-worktree',
+        });
+        // 5. Verify the bot actually responds — this is the core assertion.
+        // If the listener wasn't reconnected, this will time out.
+        await waitForBotReplyAfterUserMessage({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'after-worktree',
+            timeout: 4_000,
+        });
+        // Wait for the footer to confirm full completion
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'deterministic-v2',
+            afterUserMessageIncludes: 'after-worktree',
+            timeout: 4_000,
+        });
+        // Runtime instance should be the same (not recreated)
+        const runtimeAfter = getRuntime(thread.id);
+        expect(runtimeAfter).toBe(runtimeBefore);
+        // sdkDirectory should now point to the worktree path
+        expect(runtimeAfter.sdkDirectory).not.toBe(directories.projectDirectory);
+        expect(runtimeAfter.sdkDirectory).toContain(`kimaki-${WORKTREE_NAME}`);
+        // Snapshot uses dynamic worktree name so we verify structure, not exact text
+        const text = await th.text();
+        expect(text).toContain('Reply with exactly: before-worktree');
+        expect(text).toContain('⬥ ok');
+        expect(text).toContain('Worktree:');
+        expect(text).toContain('Branch:');
+        expect(text).toContain('Reply with exactly: after-worktree');
+        // The second "⬥ ok" proves the bot responded after the worktree switch
+        const okCount = (text.match(/⬥ ok/g) || []).length;
+        expect(okCount).toBe(2);
+    }, 30_000);
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.76",
+  "version": "0.4.78",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -42,6 +42,7 @@
     "@prisma/client": "7.4.2",
     "@purinton/resampler": "^1.0.4",
     "@sentry/node": "^10.40.0",
+    "@types/ws": "^8.18.1",
     "cron-parser": "^5.5.0",
     "discord.js": "^14.25.1",
     "domhandler": "^5.0.3",
@@ -55,6 +56,7 @@
     "pretty-ms": "^9.3.0",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
+    "ws": "^8.19.0",
     "xdg-basedir": "^5.1.0",
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
@@ -69,7 +71,7 @@
     "sharp": "^0.34.5"
   },
   "scripts": {
-    "dev": "tsx --env-file .env src/cli.ts",
+    "dev": "tsx src/cli.ts",
     "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
     "watch": "tsx scripts/watch-session.ts",
     "generate": "prisma generate && pnpm generate:sql",

package/skills/critique/SKILL.md

@@ -122,6 +122,23 @@ critique review --web --agent opencode --session <session_id> --filter "src/**/*
 
 The command prints a preview URL when done — share that URL with the user.
 
+## Raw patch access
+
+Every `--web` upload also stores the raw unified diff. Append `.patch` to any critique URL to get it:
+
+```bash
+# View the raw patch
+curl https://critique.work/v/<id>.patch
+
+# Apply the patch to current repo
+curl -s https://critique.work/v/<id>.patch | git apply
+
+# Reverse the patch (undo the changes)
+curl -s https://critique.work/v/<id>.patch | git apply --reverse
+```
+
+Useful when an agent shares a critique URL and you want to programmatically apply or revert those changes.
+
 ## Notes
 
 - Requires **Bun** — use `bunx critique` or global `critique`

package/skills/egaki/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: egaki
+description: >
+  AI image generation CLI. Generates images from text prompts using Google Imagen
+  and Gemini multimodal models via the Vercel AI SDK. Supports image editing,
+  inpainting, and multiple output formats.
+---
+
+# egaki
+
+AI image generation from the terminal. Text-to-image, image editing, and inpainting
+with Google Imagen and Gemini models.
+
+Run `egaki --help` before using this CLI. The help output has all commands,
+options, defaults, and usage examples.
+
+For subcommand details: `egaki <command> --help` (e.g. `egaki image --help`, `egaki login --help`)
+
+## Quick start
+
+```bash
+# configure an API key
+egaki login
+
+# generate an image
+egaki image "a sunset over mars"
+
+# edit an existing image (local file or URL)
+egaki image "add a wizard hat" --input photo.jpg
+egaki image "make it pop art" --input https://example.com/photo.jpg
+
+# pipe to another tool
+egaki image "logo" --stdout | convert - -resize 512x512 logo.png
+```
+

package/skills/event-sourcing-state/SKILL.md

@@ -0,0 +1,252 @@
+---
+name: event-sourcing-state
+description: >
+  Event-sourced application state pattern for TypeScript apps. Prefer bounded
+  event logs plus pure derivation functions over mirrored mutable lifecycle
+  flags. Use when state transitions are driven by events and bugs can be
+  reproduced from a saved event stream.
+version: 0.2.0
+---
+
+<!-- Skill for event-sourced state and fixture-driven debugging. -->
+
+# Event-Sourcing State
+
+Use this skill when an app keeps adding mutable fields to track lifecycle,
+phase, status, or UI state that could instead be derived from an event log.
+
+## Core idea
+
+Do not store the answer when you can store the evidence.
+
+Coding agents overproduce state. Every bug looks like it wants one more flag,
+one more cached answer, one more special case. Every field feels locally
+justified. Globally you are building a machine nobody can hold in their head.
+
+Every boolean you add:
+
+1. doubles your app's possible states
+2. doubles your bugs
+3. doubles the coverage you need in the worst case
+
+The fix is not a better set of flags. The fix is deleting the flags.
+
+Stop storing conclusions and store evidence instead. If a decision depends on
+what actually happened, keep the events and derive the answer from them.
+
+## Anti-pattern: mirrored flags
+
+To answer one yes/no UI question ("should the footer show?"), an agent will
+mirror facts into state:
+
+```ts
+type ThreadState = {
+  wasInterrupted: boolean
+  didAssistantFinish: boolean
+  didAssistantError: boolean
+  wasToolCallOnly: boolean
+}
+
+function shouldShowFooter(state: ThreadState): boolean {
+  return state.didAssistantFinish
+    && !state.wasInterrupted
+    && !state.didAssistantError
+    && !state.wasToolCallOnly
+}
+```
+
+Four flags to answer one question. Each flag caches a fact already present in
+the event that produced it. Then a function recombines them back into one
+boolean. None of these fields looks insane on its own — that is the trap.
+
+## Pattern: derive from events
+
+Keep the raw events and compute the answer when needed:
+
+```ts
+type SessionEvent =
+  | { type: 'session.status'; status: 'busy' | 'idle' }
+  | { type: 'session.aborted' }
+  | {
+      type: 'message.updated'
+      role: 'assistant'
+      completed: boolean
+      error: boolean
+      finish: 'stop' | 'tool-calls'
+    }
+
+function getLatestAssistantMessage(events: SessionEvent[]) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i]
+    if (event?.type === 'message.updated' && event.role === 'assistant') {
+      return event
+    }
+  }
+  return undefined
+}
+
+function isNaturalCompletion(message: {
+  completed: boolean
+  error: boolean
+  finish: 'stop' | 'tool-calls'
+}): boolean {
+  if (!message.completed) {
+    return false
+  }
+  if (message.error) {
+    return false
+  }
+  return message.finish !== 'tool-calls'
+}
+
+function shouldShowFooter(events: SessionEvent[]): boolean {
+  const msg = getLatestAssistantMessage(events)
+  if (!msg) {
+    return false
+  }
+  return isNaturalCompletion(msg)
+}
+```
+
+Notice what disappeared:
+
+1. no interruption flag
+2. no finished flag
+3. no special footer state
+4. no extra state machine to explain another state machine
+
+You keep the raw thing that happened, then compute the answer when needed.
+
+## Rules
+
+1. Keep events immutable and versioned.
+2. Prefer one bounded event buffer over many mirrored flags.
+3. Derive lifecycle state with pure functions.
+4. Persist the event stream when it helps reproduce bugs.
+5. Write tests against fixtures, not against live mutable runtime state.
+
+## Good fit
+
+- session lifecycle state
+- workflow engines
+- chat or agent runtimes
+- typing/idle/footer decisions
+- retry and interruption logic
+
+## Bad fit
+
+- raw high-volume telemetry that is never read back
+- tiny local state better kept inside a closure
+- data that is already a stable source of truth elsewhere
+
+## Testing workflow
+
+1. Export a failing event stream from production or local runtime.
+2. Save it as a fixture (jsonl file).
+3. Write a pure test around the derivation function.
+4. Fix the derivation code.
+5. Keep the fixture so the bug stays dead.
+
+Any model can one-shot these problems because the feedback loop is obvious:
+events in, answer out.
+
+```ts
+import fs from 'node:fs'
+
+function loadEvents(file: string): SessionEvent[] {
+  return fs
+    .readFileSync(file, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      return JSON.parse(line) as SessionEvent
+    })
+}
+
+test('footer is hidden for aborted runs', () => {
+  const events = loadEvents('./fixtures/aborted-session.jsonl')
+  expect(shouldShowFooter(events)).toBe(false)
+})
+```
+
+The reproduction artifact is just data:
+
+1. no mocking the runtime
+2. no mocking timers
+3. no begging the runtime to reproduce the exact bad interleaving again
+4. just events in, answer out
+
+## Persistency
+
+If you want persistence you just store the events. Events are easily versioned
+and type-safe.
+
+The trade is this:
+
+- **Storing cached state**: if a user hits a broken state and you persist it,
+  the project is gone. Opening it crashes the app. To fix it you need migration
+  code that patches the corrupted state. Tedious and fragile.
+- **Storing the event stream**: you fix the derivation functions, release a new
+  version, the user opens the project, and it works again. What matters is
+  keeping events immutable and versioned so derivation functions are guaranteed
+  to process events from older app versions and return valid state.
+
+State is cached conclusions. Events are stored evidence. Evidence ages better.
+
+If you can derive it, don't store it.
+
+## State encapsulation
+
+The next best thing after no state is state you don't care about because it is
+encapsulated.
+
+Not everything needs event sourcing. The second-best option is state you
+successfully hide. A good example is React `useState`: state can only be
+written in event handlers within the component subtree and can only be read in
+the current component. It is local and easy to reason about.
+
+The same applies to backend code. Instead of promoting a timer or counter into
+a class field visible to all methods, encapsulate it in a closure:
+
+```ts
+// bad: timer is a class field, visible to all methods, agents will touch it
+class MessageWriter {
+  private debounceTimeout: ReturnType<typeof setTimeout> | null = null
+
+  queueSend(text: string): void {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout)
+    }
+    this.debounceTimeout = setTimeout(() => {
+      this.write(text)
+    }, 300)
+  }
+}
+
+// good: timer is trapped in a tiny box, no other consumer can touch it
+function createDebouncedAction(callback: () => void, delayMs = 300) {
+  let timeout: ReturnType<typeof setTimeout> | null = null
+
+  function clear(): void {
+    if (!timeout) {
+      return
+    }
+    clearTimeout(timeout)
+    timeout = null
+  }
+
+  function trigger(): void {
+    clear()
+    timeout = setTimeout(() => {
+      timeout = null
+      callback()
+    }, delayMs)
+  }
+
+  return { trigger, clear }
+}
+```
+
+A global variable has the potential of doubling your app state. An encapsulated
+closure can only double the states of that tiny function. Given it is so small
+you don't care — spotting a bug inside it is easy for you and agents.

package/skills/goke/SKILL.md

@@ -430,6 +430,7 @@ cli
       return
     }
     // Interactive path (humans)
+    // NEVER use hint in clack select options. looks ugly
     const provider = await select({ message: 'Select provider', options: [...] })
     if (isCancel(provider)) { cancel(); process.exit(0) }
     const key = await password({ message: 'Paste API key' })