kimaki 0.4.82 → 0.4.84

package/dist/undo-redo.e2e.test.js

@@ -13,8 +13,10 @@
 // Uses opencode-deterministic-provider (no real LLM calls).
 // Poll timeouts: 4s max, 100ms interval.
 import { describe, test, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForFooterMessage } from './test-utils.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 import { getThreadSession } from './database.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
 const TEXT_CHANNEL_ID = '200000000000001200';
@@ -27,27 +29,28 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         username: 'undo-tester',
     });
     test('undo sets revert state, next message cleans up reverted messages', async () => {
+        const markerPath = path.join(ctx.directories.projectDirectory, 'tmp', 'undo-marker.txt');
         // 1. Send a message and wait for complete session (footer)
         await ctx.discord
             .channel(TEXT_CHANNEL_ID)
             .user(TEST_USER_ID)
             .sendMessage({
-            content: 'Reply with exactly: undo-test-message',
+            content: 'UNDO_FILE_MARKER',
         });
         const thread = await ctx.discord
             .channel(TEXT_CHANNEL_ID)
             .waitForThread({
-            timeout: 4_000,
+            timeout: 8_000,
             predicate: (t) => {
-                return t.name === 'Reply with exactly: undo-test-message';
+                return t.name === 'UNDO_FILE_MARKER';
             },
         });
         const th = ctx.discord.thread(thread.id);
-        await th.waitForBotReply({ timeout: 4_000 });
+        await th.waitForBotReply({ timeout: 8_000 });
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
-            timeout: 4_000,
+            timeout: 8_000,
         });
         // 2. Get session ID and verify it has messages
         const sessionId = await getThreadSession(thread.id);
@@ -70,6 +73,7 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         });
         expect(beforeUserMessages.length).toBeGreaterThan(0);
         expect(beforeAssistantMessages.length).toBeGreaterThan(0);
+        expect(fs.existsSync(markerPath)).toBe(true);
         // Verify no revert state yet
         const beforeSession = await getClient().session.get({
             sessionID: sessionId,
@@ -84,22 +88,12 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
             timeout: 4_000,
         });
         expect(undoAck).toBeDefined();
-        // Wait for the undo reply to appear (deferred reply gets edited)
-        if (undoAck.messageId) {
-            const start = Date.now();
-            while (Date.now() - start < 4_000) {
-                const messages = await th.getMessages();
-                const undoMessage = messages.find((m) => {
-                    return m.id === undoAck.messageId;
-                });
-                if (undoMessage && undoMessage.content.length > 0) {
-                    break;
-                }
-                await new Promise((r) => {
-                    setTimeout(r, 100);
-                });
-            }
-        }
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Undone - reverted last assistant message',
+            timeout: 8_000,
+        });
         // 4. Verify session now has revert state set
         const afterSession = await getClient().session.get({
             sessionID: sessionId,
@@ -120,7 +114,7 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
-            timeout: 4_000,
+            timeout: 8_000,
             afterMessageIncludes: 'after-undo-message',
         });
         // 6. Verify reverted messages were cleaned up
@@ -151,9 +145,10 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         // 7. Snapshot the Discord thread
         expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (undo-tester)
-        Reply with exactly: undo-test-message
+        UNDO_FILE_MARKER
         --- from: assistant (TestBot)
-        ⬥ ok
+        ⬥ creating undo file
+        ⬥ undo file created
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         Undone - reverted last assistant message
         --- from: user (undo-tester)

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.82",
+  "version": "0.4.84",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -24,18 +24,18 @@
     "lintcn": "^0.3.0",
     "prisma": "7.4.2",
     "tsx": "^4.20.5",
+    "discord-digital-twin": "^0.1.0",
     "opencode-cached-provider": "^0.0.1",
-    "db": "^0.0.0",
     "opencode-deterministic-provider": "^0.0.1",
-    "discord-digital-twin": "^0.1.0"
+    "db": "^0.0.0"
   },
   "dependencies": {
-    "@ai-sdk/google": "^3.0.30",
+    "@ai-sdk/google": "^3.0.53",
     "@ai-sdk/openai": "^3.0.31",
     "@ai-sdk/provider": "^3.0.8",
     "@clack/prompts": "^1.0.0",
     "@discordjs/voice": "^0.19.0",
-    "@google/genai": "^1.34.0",
+    "@google/genai": "^1.46.0",
     "@libsql/client": "^0.15.15",
     "@openauthjs/openauth": "^0.4.3",
     "@opencode-ai/plugin": "^1.2.27",
@@ -52,9 +52,11 @@
     "goke": "^6.3.0",
     "htmlparser2": "^10.0.0",
     "js-yaml": "^4.1.0",
+    "kitty-graphics-agent": "^0.0.5",
     "libsql": "^0.5.22",
     "marked": "^16.3.0",
     "mime": "^4.1.0",
+    "opusscript": "^0.1.1",
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
     "proper-lockfile": "^4.1.2",
@@ -65,7 +67,8 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
-    "traforo": "^0.1.0"
+    "libsqlproxy": "^0.1.0",
+    "traforo": "^0.2.0"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",
@@ -76,6 +79,7 @@
   },
   "scripts": {
     "dev": "tsx src/cli.ts",
+    "build": "pnpm generate && pnpm tsc",
     "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
     "watch": "tsx scripts/watch-session.ts",
     "generate": "prisma generate && pnpm generate:sql",

package/schema.prisma

@@ -14,6 +14,7 @@ datasource db {
 model thread_sessions {
   thread_id  String    @id
   session_id String
+  source     ThreadSessionSource @default(kimaki)
   created_at DateTime? @default(now())
 
   part_messages   part_messages[]
@@ -23,6 +24,11 @@ model thread_sessions {
   ipc_requests    ipc_requests[]
 }
 
+enum ThreadSessionSource {
+  kimaki
+  external_poll
+}
+
 model session_events {
   id               Int       @id @default(autoincrement())
   session_id       String

package/skills/errore/SKILL.md

@@ -432,11 +432,11 @@ return res.status(response.status).json(response.body)
 
 > `matchError` routes by `_tag` and requires an `Error` fallback for plain Error instances. Use `matchErrorPartial` when you only need to handle some cases.
 
-### Resource Cleanup (defer)
+### Resource Cleanup (defer) — Replacing try/finally with `using`
 
-errore ships `DisposableStack` and `AsyncDisposableStack` polyfills that work in every runtime. Use them with TypeScript's `using` / `await using` for Go-like `defer` cleanup.
+`try/finally` has a structural problem: **every resource adds a nesting level**. Two resources = two levels of indentation. The business logic gets buried deeper with each resource, and cleanup is split across `finally` blocks far from where the resource was acquired. `await using` + `DisposableStack` keeps the function flat — one `cleanup.defer()` per resource, same indentation whether you have one resource or ten. Cleanup runs automatically in reverse order on every exit path.
 
-**tsconfig requirement:** add `"ESNext.Disposable"` to `lib` so TypeScript knows about `Disposable`, `AsyncDisposable`, `using`, and `await using`:
+**tsconfig requirement:** add `"ESNext.Disposable"` to `lib`:
 
 ```jsonc
 {
@@ -446,28 +446,51 @@ errore ships `DisposableStack` and `AsyncDisposableStack` polyfills that work in
 }
 ```
 
-Without this, `using`/`await using` declarations and `Symbol.dispose`/`Symbol.asyncDispose` will produce type errors. The errore polyfill handles the runtime side — this setting handles the type side.
+**Before — nested try/finally:**
 
 ```ts
-import * as errore from 'errore'
+async function importData(url: string, dbUrl: string) {
+  const db = await connectDb(dbUrl)
+  try {
+    const tmpFile = await createTempFile()
+    try {
+      const data = await (await fetch(url)).text()
+      await tmpFile.write(data)
+      await db.import(tmpFile.path)
+      return { rows: await db.count() }
+    } finally {
+      await tmpFile.delete()
+    }
+  } finally {
+    await db.close()
+  }
+}
+```
+
+**After — flat with `await using`:**
 
-async function processRequest(id: string): Promise<DbError | Result> {
+```ts
+async function importData(url: string, dbUrl: string): Promise<ImportError | { rows: number }> {
   await using cleanup = new errore.AsyncDisposableStack()
 
-  const db = await connectDb().catch((e) => new DbError({ cause: e }))
+  const db = await connectDb(dbUrl).catch((e) => new ImportError({ reason: 'db connect', cause: e }))
   if (db instanceof Error) return db
   cleanup.defer(() => db.close())
 
-  const cache = await openCache().catch((e) => new CacheError({ cause: e }))
-  if (cache instanceof Error) return cache
-  cleanup.defer(() => cache.flush())
+  const tmpFile = await createTempFile()
+  cleanup.defer(() => tmpFile.delete())
+
+  const response = await fetch(url).catch((e) => new ImportError({ reason: 'fetch', cause: e }))
+  if (response instanceof Error) return response
 
-  return result
-  // cleanup runs in LIFO order: cache.flush(), then db.close()
+  await tmpFile.write(await response.text())
+  await db.import(tmpFile.path)
+  return { rows: await db.count() }
+  // cleanup: tmpFile.delete() → db.close()
 }
 ```
 
-> `await using` guarantees cleanup runs when the scope exits — whether by return, early error return, or thrown exception. Resources are released in reverse order (LIFO), just like Go's `defer`. No `try/finally` nesting.
+> `await using` guarantees cleanup on every exit path — normal return, early error return, or exception. Resources release in LIFO order. Adding a resource is one line (`cleanup.defer()`), not another nesting level. The errore polyfill handles the runtime; the tsconfig `lib` entry handles the types.
 
 ### Fallback Values
 
@@ -608,6 +631,10 @@ for (const item of items) {
 
 > Place `signal.aborted` checks **before** expensive operations (network, db writes, file I/O). Check `isAbortError` **after** async calls that received the signal. Both keep the function responsive to cancellation.
 
+## Linting
+
+If the project uses [lintcn](https://github.com/remorses/lintcn), read `docs/lintcn.md` for the `no-unhandled-error` rule that catches discarded `Error | T` return values.
+
 ## Pitfalls
 
 ### CustomError | Error is ambiguous when CustomError extends Error

package/skills/goke/SKILL.md

@@ -602,6 +602,18 @@ cli.version('1.0.0')
 cli.parse()
 ```
 
+## `openInBrowser(url)`
+
+Opens a URL in the default browser. In non-TTY environments (CI, piped output, agents), prints the URL to stdout instead of opening a browser.
+
+```ts
+import { openInBrowser } from 'goke'
+
+openInBrowser('https://example.com/dashboard')
+```
+
+Use this after generating URLs (OAuth callbacks, dashboards, docs links) so interactive users get a browser tab and non-interactive environments get a printable URL.
+
 ## Exposing your CLI as a skill
 
 When you build a CLI with goke, the optimal way to create a skill for it is a minimal SKILL.md that tells agents to run `--help` before using the CLI. This way descriptions, examples, and usage patterns live in the CLI code (collocated with the implementation) instead of a separate markdown file that can go stale.