@brianli/kimaki 0.4.72-brianli.1

package/dist/xml.js

@@ -0,0 +1,92 @@
+// XML/HTML tag content extractor.
+// Parses XML-like tags from strings (e.g., channel topics) to extract
+// Kimaki configuration like directory paths and app IDs.
+import { DomHandler, Parser, ElementType } from 'htmlparser2';
+import { createLogger, LogPrefix } from './logger.js';
+const xmlLogger = createLogger(LogPrefix.XML);
+export function extractTagsArrays({ xml, tags, }) {
+    const result = {
+        others: [],
+    };
+    // Initialize arrays for each tag
+    tags.forEach((tag) => {
+        result[tag] = [];
+    });
+    try {
+        const handler = new DomHandler((error, dom) => {
+            if (error) {
+                xmlLogger.error('Error parsing XML:', error);
+            }
+            else {
+                const findTags = (nodes, path = []) => {
+                    nodes.forEach((node) => {
+                        if (node.type === ElementType.Tag) {
+                            const element = node;
+                            const currentPath = [...path, element.name];
+                            const pathString = currentPath.join('.');
+                            // Extract content using original string positions
+                            const extractContent = () => {
+                                // Use element's own indices but exclude the tags
+                                if (element.startIndex !== null &&
+                                    element.endIndex !== null) {
+                                    // Extract the full element including tags
+                                    const fullElement = xml.substring(element.startIndex, element.endIndex + 1);
+                                    // Find where content starts (after opening tag)
+                                    const contentStart = fullElement.indexOf('>') + 1;
+                                    // Find where content ends (before this element's closing tag)
+                                    const closingTag = `</${element.name}>`;
+                                    const contentEnd = fullElement.lastIndexOf(closingTag);
+                                    if (contentStart > 0 && contentEnd > contentStart) {
+                                        return fullElement.substring(contentStart, contentEnd);
+                                    }
+                                    return '';
+                                }
+                                return '';
+                            };
+                            // Check both single tag names and nested paths
+                            if (tags.includes(element.name)) {
+                                const content = extractContent();
+                                result[element.name]?.push(content);
+                            }
+                            // Check for nested path matches
+                            if (tags.includes(pathString)) {
+                                const content = extractContent();
+                                result[pathString]?.push(content);
+                            }
+                            if (element.children) {
+                                findTags(element.children, currentPath);
+                            }
+                        }
+                        else if (node.type === ElementType.Text &&
+                            node.parent?.type === ElementType.Root) {
+                            const textNode = node;
+                            if (textNode.data.trim()) {
+                                // console.log('node.parent',node.parent)
+                                result.others?.push(textNode.data.trim());
+                            }
+                        }
+                    });
+                };
+                findTags(dom);
+            }
+        }, {
+            withStartIndices: true,
+            withEndIndices: true,
+            xmlMode: true,
+        });
+        const parser = new Parser(handler, {
+            xmlMode: true,
+            decodeEntities: false,
+        });
+        parser.write(xml);
+        parser.end();
+    }
+    catch (error) {
+        xmlLogger.error('Unexpected error in extractTags:', error);
+    }
+    return result;
+}
+export function extractNonXmlContent(xml) {
+    const result = extractTagsArrays({ xml, tags: [] });
+    return result.others.join('\n');
+}

package/dist/xml.test.js

@@ -0,0 +1,32 @@
+import { describe, test, expect } from 'vitest';
+import { extractNonXmlContent } from './xml.js';
+describe('extractNonXmlContent', () => {
+    test('removes xml tags and returns only text content', () => {
+        const xml = 'Hello <tag>content</tag> world <nested><inner>deep</inner></nested> end';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`
+      "Hello
+      world
+      end"
+    `);
+    });
+    test('handles multiple text segments', () => {
+        const xml = 'Start <a>tag1</a> middle <b>tag2</b> finish';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`
+      "Start
+      middle
+      finish"
+    `);
+    });
+    test('handles only xml without text', () => {
+        const xml = '<root><child>content</child></root>';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`""`);
+    });
+    test('handles only text without xml', () => {
+        const xml = 'Just plain text';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`"Just plain text"`);
+    });
+    test('handles empty string', () => {
+        const xml = '';
+        expect(extractNonXmlContent(xml)).toMatchInlineSnapshot(`""`);
+    });
+});

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@brianli/kimaki",
+  "module": "index.ts",
+  "type": "module",
+  "version": "0.4.72-brianli.1",
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "prepublishOnly": "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",
+    "generate:sql": "rm -f dev.db && prisma db push --url 'file:dev.db' --accept-data-loss && echo '-- This file is generated by pnpm generate:sql. Do not edit manually.' > src/schema.sql && sqlite3 dev.db '.schema' >> src/schema.sql",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test": "vitest",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts",
+    "format": "oxfmt src",
+    "sync-skills": "tsx scripts/sync-skills.ts"
+  },
+  "repository": "https://github.com/remorses/kimaki",
+  "bin": "bin.js",
+  "files": [
+    "dist",
+    "src",
+    "skills",
+    "schema.prisma",
+    "bin.js"
+  ],
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/heic-convert": "^2.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/json-schema": "^7.0.15",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^24.3.0",
+    "discord-digital-twin": "workspace:^",
+    "opencode-cached-provider": "workspace:^",
+    "opencode-deterministic-provider": "workspace:^",
+    "prisma": "7.3.0",
+    "tsx": "^4.20.5"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^3.0.30",
+    "@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",
+    "@libsql/client": "^0.15.15",
+    "@opencode-ai/plugin": "^1.1.53",
+    "@opencode-ai/sdk": "^1.1.53",
+    "@parcel/watcher": "^2.5.6",
+    "@prisma/adapter-libsql": "7.3.0",
+    "@prisma/client": "7.3.0",
+    "@purinton/resampler": "^1.0.4",
+    "@sentry/node": "^10.40.0",
+    "cron-parser": "^5.5.0",
+    "discord.js": "^14.25.1",
+    "domhandler": "^5.0.3",
+    "errore": "workspace:^",
+    "goke": "^6.1.2",
+    "htmlparser2": "^10.0.0",
+    "js-yaml": "^4.1.0",
+    "libsql": "^0.5.22",
+    "marked": "^16.3.0",
+    "mime": "^4.1.0",
+    "picocolors": "^1.1.1",
+    "pretty-ms": "^9.3.0",
+    "string-dedent": "^3.0.2",
+    "traforo": "workspace:^",
+    "undici": "^7.16.0",
+    "xdg-basedir": "^5.1.0",
+    "zod": "^4.3.6",
+    "zustand": "^5.0.11"
+  },
+  "optionalDependencies": {
+    "@discordjs/opus": "^0.10.0",
+    "heic-convert": "^2.1.0",
+    "prism-media": "^1.3.5",
+    "sharp": "^0.34.5"
+  }
+}

package/schema.prisma

@@ -0,0 +1,246 @@
+generator client {
+  provider = "prisma-client"
+  output   = "./src/generated"
+}
+
+datasource db {
+  provider = "sqlite"
+}
+
+model thread_sessions {
+  thread_id  String    @id
+  session_id String
+  created_at DateTime? @default(now())
+
+  part_messages   part_messages[]
+  scheduled_tasks scheduled_tasks[]
+  thread_worktree thread_worktrees?
+  ipc_requests    ipc_requests[]
+}
+
+model part_messages {
+  part_id    String    @id
+  message_id String
+  thread_id  String
+  created_at DateTime? @default(now())
+
+  thread thread_sessions @relation(fields: [thread_id], references: [thread_id])
+}
+
+model bot_tokens {
+  app_id     String    @id
+  token      String
+  created_at DateTime? @default(now())
+
+  api_keys           bot_api_keys?
+  channels           channel_directories[]
+  forum_sync_configs forum_sync_configs[]
+  global_model       global_models?
+}
+
+model channel_directories {
+  channel_id   String    @id
+  directory    String
+  channel_type String
+  app_id       String?
+  created_at   DateTime? @default(now())
+
+  bot                  bot_tokens?           @relation(fields: [app_id], references: [app_id])
+  channel_model        channel_models?
+  channel_agent        channel_agents?
+  channel_worktree     channel_worktrees?
+  channel_verbosity    channel_verbosity?
+  channel_mention_mode channel_mention_mode?
+  scheduled_tasks      scheduled_tasks[]
+}
+
+model bot_api_keys {
+  app_id         String    @id
+  gemini_api_key String?
+  openai_api_key String?
+  xai_api_key    String?
+  created_at     DateTime? @default(now())
+
+  bot bot_tokens @relation(fields: [app_id], references: [app_id])
+}
+
+// status: 'pending' while creating, 'ready' when done, 'error' if failed
+model thread_worktrees {
+  thread_id          String    @id
+  worktree_name      String
+  worktree_directory String?
+  project_directory  String
+  status             String?   @default("pending")
+  error_message      String?
+  created_at         DateTime? @default(now())
+
+  thread thread_sessions @relation(fields: [thread_id], references: [thread_id])
+}
+
+model channel_models {
+  channel_id String    @id
+  model_id   String
+  variant    String?
+  created_at DateTime? @default(now())
+  updated_at DateTime? @default(now()) @updatedAt
+
+  channel channel_directories @relation(fields: [channel_id], references: [channel_id])
+}
+
+model session_models {
+  session_id String    @id
+  model_id   String
+  variant    String?
+  created_at DateTime? @default(now())
+}
+
+model channel_agents {
+  channel_id String    @id
+  agent_name String
+  created_at DateTime? @default(now())
+  updated_at DateTime? @default(now()) @updatedAt
+
+  channel channel_directories @relation(fields: [channel_id], references: [channel_id])
+}
+
+model session_agents {
+  session_id String    @id
+  agent_name String
+  created_at DateTime? @default(now())
+}
+
+model channel_worktrees {
+  channel_id String    @id
+  enabled    Int       @default(0)
+  created_at DateTime? @default(now())
+  updated_at DateTime? @default(now()) @updatedAt
+
+  channel channel_directories @relation(fields: [channel_id], references: [channel_id])
+}
+
+model channel_verbosity {
+  channel_id String    @id
+  verbosity  String    @default("tools-and-text")
+  updated_at DateTime? @default(now()) @updatedAt
+
+  channel channel_directories @relation(fields: [channel_id], references: [channel_id])
+}
+
+model channel_mention_mode {
+  channel_id String    @id
+  enabled    Int       @default(0)
+  created_at DateTime? @default(now())
+  updated_at DateTime? @default(now()) @updatedAt
+
+  channel channel_directories @relation(fields: [channel_id], references: [channel_id])
+}
+
+model global_models {
+  app_id     String    @id
+  model_id   String
+  variant    String?
+  created_at DateTime? @default(now())
+  updated_at DateTime? @default(now()) @updatedAt
+
+  bot bot_tokens @relation(fields: [app_id], references: [app_id])
+}
+
+enum task_status {
+  planned
+  running
+  completed
+  cancelled
+  failed
+}
+
+enum task_schedule_kind {
+  at
+  cron
+}
+
+model scheduled_tasks {
+  id                 Int                @id @default(autoincrement())
+  status             task_status        @default(planned)
+  schedule_kind      task_schedule_kind
+  run_at             DateTime?
+  cron_expr          String?
+  timezone           String?
+  next_run_at        DateTime
+  running_started_at DateTime?
+  last_run_at        DateTime?
+  last_error         String?
+  attempts           Int                @default(0)
+  payload_json       String
+  prompt_preview     String
+  channel_id         String?
+  thread_id          String?
+  session_id         String?
+  project_directory  String?
+  created_at         DateTime?          @default(now())
+  updated_at         DateTime?          @default(now()) @updatedAt
+
+  channel               channel_directories?    @relation(fields: [channel_id], references: [channel_id], onDelete: SetNull, onUpdate: Cascade)
+  thread                thread_sessions?        @relation(fields: [thread_id], references: [thread_id], onDelete: SetNull, onUpdate: Cascade)
+  session_start_sources session_start_sources[]
+
+  @@index([status, next_run_at])
+  @@index([channel_id, status])
+  @@index([thread_id, status])
+}
+
+model session_start_sources {
+  session_id         String             @id
+  schedule_kind      task_schedule_kind
+  scheduled_task_id  Int?
+  created_at         DateTime?          @default(now())
+  updated_at         DateTime?          @default(now()) @updatedAt
+
+  scheduled_task scheduled_tasks? @relation(fields: [scheduled_task_id], references: [id], onDelete: SetNull, onUpdate: Cascade)
+
+  @@index([scheduled_task_id])
+}
+
+model forum_sync_configs {
+  id               Int       @id @default(autoincrement())
+  app_id           String
+  forum_channel_id String
+  output_dir       String
+  direction        String    @default("bidirectional")
+  created_at       DateTime? @default(now())
+  updated_at       DateTime? @default(now()) @updatedAt
+
+  bot bot_tokens @relation(fields: [app_id], references: [app_id], onDelete: Cascade, onUpdate: Cascade)
+
+  @@unique([app_id, forum_channel_id])
+}
+
+enum ipc_request_type {
+  file_upload
+  action_buttons
+}
+
+enum ipc_request_status {
+  pending
+  processing
+  completed
+  cancelled
+}
+
+// IPC bridge between the opencode plugin process and the Discord bot process.
+// Replaces the old HTTP lock server for file-upload and action-buttons requests.
+// Plugin inserts a pending row, bot polls and dispatches, then writes the response.
+model ipc_requests {
+  id         String             @id @default(uuid())
+  type       ipc_request_type
+  session_id String
+  thread_id  String
+  payload    String             // JSON-encoded request data
+  response   String?            // JSON-encoded response, null while pending
+  status     ipc_request_status @default(pending)
+  created_at DateTime           @default(now())
+  updated_at DateTime           @default(now()) @updatedAt
+
+  thread thread_sessions @relation(fields: [thread_id], references: [thread_id])
+
+  @@index([status, created_at])
+}

package/skills/batch/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: batch
+description: >
+  Research and plan a large-scale change, then execute it in parallel across
+  5-30 isolated worktree agents that each open a PR. Use when the user wants
+  to make a sweeping, mechanical change across many files (migrations,
+  refactors, bulk renames) that can be decomposed into independent parallel
+  units.
+argument-hint: "<instruction>"
+source-path: cli.js (line 7359, function mGz)
+source-package: "@anthropic-ai/claude-code@2.1.63"
+source-date: 2026-02-28
+---
+
+# Batch: Parallel Work Orchestration
+
+You are orchestrating a large, parallelizable change across this codebase.
+
+## User Instruction
+
+$instruction
+
+## Phase 1: Research and Plan (Plan Mode)
+
+Enter plan mode, then:
+
+1. **Understand the scope.** Launch one or more Explore agents (in the foreground — you need their results) to deeply research what this instruction touches. Find all the files, patterns, and call sites that need to change. Understand the existing conventions so the migration is consistent.
+
+2. **Decompose into independent units.** Break the work into 5–30 self-contained units. Each unit must:
+   - Be independently implementable in an isolated git worktree (no shared state with sibling units)
+   - Be mergeable on its own without depending on another unit's PR landing first
+   - Be roughly uniform in size (split large units, merge trivial ones)
+
+   Scale the count to the actual work: few files → closer to 5; hundreds of files → closer to 30. Prefer per-directory or per-module slicing over arbitrary file lists.
+
+3. **Determine the e2e test recipe.** Figure out how a worker can verify its change actually works end-to-end — not just that unit tests pass. Look for:
+   - A browser-automation tool (for UI changes: click through the affected flow, screenshot the result)
+   - A tmux or CLI-verifier skill (for CLI changes: launch the app interactively, exercise the changed behavior)
+   - A dev-server + curl pattern (for API changes: start the server, hit the affected endpoints)
+   - An existing e2e/integration test suite the worker can run
+
+   If you cannot find a concrete e2e path, ask the user how to verify this change end-to-end. Offer 2–3 specific options based on what you found (e.g., "Screenshot via chrome extension", "Run `bun run dev` and curl the endpoint", "No e2e — unit tests are sufficient"). Do not skip this — the workers cannot ask the user themselves.
+
+   Write the recipe as a short, concrete set of steps that a worker can execute autonomously. Include any setup (start a dev server, build first) and the exact command/interaction to verify.
+
+4. **Write the plan.** In your plan file, include:
+   - A summary of what you found during research
+   - A numbered list of work units — for each: a short title, the list of files/directories it covers, and a one-line description of the change
+   - The e2e test recipe (or "skip e2e because …" if the user chose that)
+   - The exact worker instructions you will give each agent (the shared template)
+
+5. Present the plan for approval.
+
+## Phase 2: Spawn Workers (After Plan Approval)
+
+Once the plan is approved, spawn one background agent per work unit using the Task tool. **All agents must use `isolation: "worktree"` and `run_in_background: true`.** Launch them all in a single message block so they run in parallel.
+
+For each agent, the prompt must be fully self-contained. Include:
+- The overall goal (the user's instruction)
+- This unit's specific task (title, file list, change description — copied verbatim from your plan)
+- Any codebase conventions you discovered that the worker needs to follow
+- The e2e test recipe from your plan (or "skip e2e because …")
+- The worker instructions below, copied verbatim:
+
+```
+After you finish implementing the change:
+1. **Simplify** — Invoke the simplify skill to review and clean up your changes.
+2. **Run unit tests** — Run the project's test suite (check for package.json scripts, Makefile targets, or common commands like `npm test`, `bun test`, `pytest`, `go test`). If tests fail, fix them.
+3. **Test end-to-end** — Follow the e2e test recipe from the coordinator's prompt (below). If the recipe says to skip e2e for this unit, skip it.
+4. **Commit and push** — Commit all changes with a clear message, push the branch, and create a PR with `gh pr create`. Use a descriptive title. If `gh` is not available or the push fails, note it in your final message.
+5. **Report** — End with a single line: `PR: <url>` so the coordinator can track it. If no PR was created, end with `PR: none — <reason>`.
+```
+
+Use `subagent_type: "general-purpose"` unless a more specific agent type fits.
+
+## Phase 3: Track Progress
+
+After launching all workers, render an initial status table:
+
+| # | Unit | Status | PR |
+|---|------|--------|----|
+| 1 | <title> | running | — |
+| 2 | <title> | running | — |
+
+As background-agent completion notifications arrive, parse the `PR: <url>` line from each agent's result and re-render the table with updated status (`done` / `failed`) and PR links. Keep a brief failure note for any agent that did not produce a PR.
+
+When all agents have reported, render the final table and a one-line summary (e.g., "22/24 units landed as PRs").

package/skills/critique/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: critique
+description: >
+  Git diff viewer and AI reviewer. Renders diffs as web pages, images, and PDFs
+  with syntax highlighting. Also provides AI-powered diff reviews via
+  `critique review --web`. Use this skill when working with critique for showing
+  diffs, generating diff URLs, selective hunk staging, or AI code reviews.
+---
+
+# critique
+
+Git diff viewer that renders diffs as **web pages**, **images**, and **PDFs** with syntax highlighting.
+
+Agents running in headless environments (kimaki on Discord, openclaw on Slack/Telegram) have no terminal to show diffs. critique uploads diffs to critique.work and returns a shareable URL you can paste into chat. Users click the link and see a syntax-highlighted split-view diff with mobile support and dark/light mode — no install needed.
+
+**Always run `critique --help` first** to see the latest flags and commands. The help output is the source of truth.
+
+## Web — shareable diff URLs
+
+Always pass a title to describe what the diff contains.
+
+```bash
+# Working tree changes
+critique --web "Add retry logic to database connections"
+
+# Staged changes
+critique --staged --web "Refactor auth middleware"
+
+# Branch diff (three-dot: changes since diverging from base)
+critique main...HEAD --web "Feature branch changes"
+critique main...feature-branch --web "Compare branches"
+
+# Last N commits
+critique HEAD~3 --web "Recent changes"
+
+# Specific commit
+critique --commit HEAD --web "Latest commit"
+critique --commit abc1234 --web "Fix race condition"
+
+# Filter to specific files
+critique --web "API changes" --filter "src/api.ts" --filter "src/utils.ts"
+
+# JSON output for programmatic use (returns {url, id, files})
+critique --web "Deploy changes" --json
+```
+
+Share the returned URL with the user so they can see the diff.
+
+## PDF
+
+```bash
+critique --pdf                              # working tree to PDF
+critique --staged --pdf                     # staged changes
+critique main...HEAD --pdf                   # branch diff
+critique --commit HEAD --pdf                # single commit
+critique --pdf output.pdf                   # custom filename
+critique --pdf --pdf-page-size a4-portrait  # page size options
+critique main...HEAD --pdf --open            # open in viewer
+```
+
+## Image
+
+```bash
+critique --image              # renders to /tmp as WebP
+critique main...HEAD --image  # branch diff as images
+```
+
+## Selective hunk staging
+
+When multiple agents work on the same repo, each agent should only commit its own changes. `critique hunks` lets you stage individual hunks instead of whole files — like a scriptable `git add -p`.
+
+```bash
+# List hunks with stable IDs
+critique hunks list
+critique hunks list --filter "src/**/*.ts"
+
+# Stage specific hunks by ID
+critique hunks add 'src/main.ts:@-10,6+10,7'
+critique hunks add 'src/main.ts:@-10,6+10,7' 'src/utils.ts:@-5,3+5,4'
+```
+
+Hunk ID format: `file:@-oldStart,oldLines+newStart,newLines` — derived from the `@@` diff header, stable across runs.
+
+**Typical workflow:**
+
+```bash
+critique hunks list                          # see all unstaged hunks
+critique hunks add 'file:@-10,6+10,7'       # stage only your hunks
+git commit -m "your changes"                 # commit separately
+```
+
+## AI-powered diff review
+
+`critique review --web` spawns a separate opencode session that analyzes a diff, groups related
+changes, and produces a structured review with explanations, diagrams, and suggestions. Uploads
+the result as a shareable URL — much richer than a plain diff link.
+
+**This command is very slow (up to 20 minutes for large diffs).** Only run when the user
+explicitly asks for a code review or diff explanation. Warn the user it will take a while.
+Set Bash tool timeout to at least 25 minutes (`timeout: 1_500_000`).
+
+Always pass `--agent opencode` and `--session <current_session_id>` so the reviewer has context
+about why the changes were made. If you know other session IDs that produced the diff, pass them
+too with additional `--session` flags.
+
+```bash
+# Review working tree changes
+critique review --web --agent opencode --session <session_id>
+
+# Review a specific commit
+critique review --commit HEAD --web --agent opencode --session <session_id>
+
+# Review branch changes compared to main
+critique review main...HEAD --web --agent opencode --session <session_id>
+
+# Review with multiple session contexts
+critique review --commit abc1234 --web --agent opencode --session <session_id> --session <other_session_id>
+
+# Review only specific files
+critique review --web --agent opencode --session <session_id> --filter "src/**/*.ts"
+```
+
+The command prints a preview URL when done — share that URL with the user.
+
+## Notes
+
+- Requires **Bun** — use `bunx critique` or global `critique`
+- Lock files and diffs >6000 lines are auto-hidden
+- `--web` URLs expire after 7 days (content-hashed, same diff = same URL)