@otto-assistant/bridge 0.4.92

package/dist/worktrees.test.js

@@ -0,0 +1,189 @@
+// Tests for reusable worktree and submodule initialization helpers.
+// Uses temporary local git repositories to validate submodule behavior end to end.
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test } from 'vitest';
+import { buildSubmoduleReferencePlan, createWorktreeWithSubmodules, execAsync, parseGitmodulesFileContent, } from './worktrees.js';
+const GIT_TIMEOUT_MS = 60_000;
+function gitCommand(args) {
+    return `git ${args
+        .map((arg) => {
+        return JSON.stringify(arg);
+    })
+        .join(' ')}`;
+}
+async function git({ cwd, args, }) {
+    const result = await execAsync(gitCommand(args), {
+        cwd,
+        timeout: GIT_TIMEOUT_MS,
+    });
+    return result.stdout.trim();
+}
+function createTestRoot() {
+    const tmpRoot = path.resolve(process.cwd(), 'tmp');
+    fs.mkdirSync(tmpRoot, { recursive: true });
+    return fs.mkdtempSync(path.join(tmpRoot, 'worktrees-test-'));
+}
+describe('worktrees', () => {
+    test('parseGitmodulesFileContent parses paths and urls', () => {
+        const parsed = parseGitmodulesFileContent(`
+[submodule "errore"]
+  path = errore
+  url = https://github.com/remorses/errore.git
+[submodule "gateway-proxy"]
+  path = gateway-proxy
+  url = https://github.com/remorses/gateway-proxy.git
+`);
+        expect(parsed).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "errore",
+          "path": "errore",
+          "url": "https://github.com/remorses/errore.git",
+        },
+        {
+          "name": "gateway-proxy",
+          "path": "gateway-proxy",
+          "url": "https://github.com/remorses/gateway-proxy.git",
+        },
+      ]
+    `);
+    });
+    test('buildSubmoduleReferencePlan uses local references when available', () => {
+        const sourceDirectory = '/repo';
+        const plan = buildSubmoduleReferencePlan({
+            sourceDirectory,
+            submodulePaths: ['errore', 'gateway-proxy', 'traforo'],
+            existingSourceSubmoduleDirectories: new Set([
+                '/repo/errore',
+                '/repo/gateway-proxy',
+            ]),
+        });
+        expect(plan).toMatchInlineSnapshot(`
+      [
+        {
+          "path": "errore",
+          "referenceDirectory": "/repo/errore",
+        },
+        {
+          "path": "gateway-proxy",
+          "referenceDirectory": "/repo/gateway-proxy",
+        },
+        {
+          "path": "traforo",
+          "referenceDirectory": null,
+        },
+      ]
+    `);
+    });
+    test('createWorktreeWithSubmodules resolves local-only submodule commits from local source checkout', async () => {
+        const sandbox = createTestRoot();
+        const submoduleRemote = path.join(sandbox, 'errore-remote.git');
+        const submoduleLocal = path.join(sandbox, 'errore-local');
+        const parentRepo = path.join(sandbox, 'parent');
+        const worktreeName = `opencode/kimaki-local-submodule-${Date.now()}`;
+        let createdWorktreeDirectory = '';
+        try {
+            fs.mkdirSync(parentRepo, { recursive: true });
+            await git({ cwd: sandbox, args: ['init', '--bare', '-b', 'main', submoduleRemote] });
+            await git({ cwd: sandbox, args: ['clone', submoduleRemote, submoduleLocal] });
+            await git({
+                cwd: submoduleLocal,
+                args: ['config', 'user.email', 'kimaki-tests@example.com'],
+            });
+            await git({
+                cwd: submoduleLocal,
+                args: ['config', 'user.name', 'Kimaki Tests'],
+            });
+            fs.writeFileSync(path.join(submoduleLocal, 'README.md'), 'v1\n', 'utf-8');
+            await git({ cwd: submoduleLocal, args: ['add', 'README.md'] });
+            await git({ cwd: submoduleLocal, args: ['commit', '-m', 'v1'] });
+            await git({ cwd: submoduleLocal, args: ['push', 'origin', 'HEAD:main'] });
+            await git({ cwd: parentRepo, args: ['init', '-b', 'main'] });
+            await git({
+                cwd: parentRepo,
+                args: ['config', 'user.email', 'kimaki-tests@example.com'],
+            });
+            await git({
+                cwd: parentRepo,
+                args: ['config', 'user.name', 'Kimaki Tests'],
+            });
+            await git({
+                cwd: parentRepo,
+                args: ['config', 'protocol.file.allow', 'always'],
+            });
+            fs.writeFileSync(path.join(parentRepo, 'README.md'), 'parent\n', 'utf-8');
+            await git({ cwd: parentRepo, args: ['add', 'README.md'] });
+            await git({ cwd: parentRepo, args: ['commit', '-m', 'init parent'] });
+            await git({
+                cwd: parentRepo,
+                args: [
+                    '-c',
+                    'protocol.file.allow=always',
+                    'submodule',
+                    'add',
+                    submoduleRemote,
+                    'errore',
+                ],
+            });
+            await git({ cwd: parentRepo, args: ['commit', '-am', 'add submodule at v1'] });
+            fs.writeFileSync(path.join(submoduleLocal, 'README.md'), 'v2-local-only\n', 'utf-8');
+            await git({ cwd: submoduleLocal, args: ['add', 'README.md'] });
+            await git({ cwd: submoduleLocal, args: ['commit', '-m', 'v2 local only'] });
+            const localOnlySha = await git({
+                cwd: submoduleLocal,
+                args: ['rev-parse', 'HEAD'],
+            });
+            await git({
+                cwd: path.join(parentRepo, 'errore'),
+                args: ['fetch', submoduleLocal, localOnlySha],
+            });
+            await git({
+                cwd: path.join(parentRepo, 'errore'),
+                args: ['checkout', localOnlySha],
+            });
+            await git({
+                cwd: parentRepo,
+                args: ['add', 'errore'],
+            });
+            await git({
+                cwd: parentRepo,
+                args: ['commit', '-m', 'pin local-only submodule commit'],
+            });
+            const worktreeResult = await createWorktreeWithSubmodules({
+                directory: parentRepo,
+                name: worktreeName,
+            });
+            if (worktreeResult instanceof Error) {
+                throw worktreeResult;
+            }
+            createdWorktreeDirectory = worktreeResult.directory;
+            const worktreeSubmoduleSha = await git({
+                cwd: path.join(worktreeResult.directory, 'errore'),
+                args: ['rev-parse', 'HEAD'],
+            });
+            expect({
+                localOnlyShaLength: localOnlySha.length,
+                worktreeSubmoduleShaLength: worktreeSubmoduleSha.length,
+                sameCommit: localOnlySha === worktreeSubmoduleSha,
+            }).toMatchInlineSnapshot(`
+        {
+          "localOnlyShaLength": 40,
+          "sameCommit": true,
+          "worktreeSubmoduleShaLength": 40,
+        }
+      `);
+        }
+        finally {
+            if (createdWorktreeDirectory) {
+                await git({
+                    cwd: parentRepo,
+                    args: ['worktree', 'remove', '--force', createdWorktreeDirectory],
+                }).catch(() => {
+                    return '';
+                });
+            }
+            fs.rmSync(sandbox, { recursive: true, force: true });
+        }
+    });
+});

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,98 @@
+{
+  "name": "@otto-assistant/bridge",
+  "module": "index.ts",
+  "type": "module",
+  "version": "0.4.92",
+  "scripts": {
+    "dev": "tsx src/bin.ts",
+    "prepublishOnly": "pnpm generate && pnpm tsc",
+    "build": "pnpm generate && pnpm tsc",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/bin.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",
+    "validate-typing-indicator": "doppler run -- tsx scripts/validate-typing-indicator.ts",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts",
+    "lint": "lintcn lint",
+    "format": "oxfmt src",
+    "sync-skills": "tsx scripts/sync-skills.ts"
+  },
+  "repository": "https://github.com/otto-assistant/bridge",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "bin": "bin.js",
+  "files": [
+    "dist",
+    "src",
+    "skills",
+    "schema.prisma",
+    "bin.js"
+  ],
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/heic-convert": "^2.1.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^24.3.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/ws": "^8.18.1",
+    "db": "workspace:^",
+    "discord-digital-twin": "workspace:^",
+    "eventsource-parser": "^3.0.6",
+    "lintcn": "^0.7.1",
+    "opencode-cached-provider": "workspace:^",
+    "opencode-deterministic-provider": "workspace:^",
+    "prisma": "7.4.2",
+    "tsx": "^4.20.5",
+    "undici": "^8.0.2"
+  },
+  "dependencies": {
+    "@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.46.0",
+    "@libsql/client": "^0.17.2",
+    "@opencode-ai/plugin": "^1.3.7",
+    "@opencode-ai/sdk": "^1.3.7",
+    "@parcel/watcher": "^2.5.6",
+    "@prisma/adapter-libsql": "7.4.2",
+    "@prisma/client": "7.4.2",
+    "@purinton/resampler": "^1.0.4",
+    "cron-parser": "^5.5.0",
+    "discord.js": "^14.25.1",
+    "domhandler": "^6.0.1",
+    "errore": "workspace:^",
+    "goke": "^6.3.2",
+    "htmlparser2": "^12.0.0",
+    "kitty-graphics-agent": "^0.0.5",
+    "libsql": "^0.5.22",
+    "libsqlproxy": "workspace:^",
+    "marked": "^17.0.5",
+    "mime": "^4.1.0",
+    "opencode-injection-guard": "workspace:^",
+    "opusscript": "^0.0.8",
+    "picocolors": "^1.1.1",
+    "pretty-ms": "^9.3.0",
+    "proper-lockfile": "^4.1.2",
+    "string-dedent": "^3.0.2",
+    "traforo": "workspace:^",
+    "ws": "^8.19.0",
+    "xdg-basedir": "^5.1.0",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6",
+    "zustand": "^5.0.11"
+  },
+  "optionalDependencies": {
+    "@snazzah/davey": "^0.1.10",
+    "heic-convert": "^2.1.0",
+    "prism-media": "^1.3.5",
+    "sharp": "^0.34.5"
+  }
+}