disunday 1.0.0

package/dist/voice.js

@@ -0,0 +1,344 @@
+// Audio transcription service using Google Gemini.
+// Transcribes voice messages with code-aware context, using grep/glob tools
+// to verify technical terms, filenames, and function names in the codebase.
+// Uses errore for type-safe error handling.
+import { GoogleGenAI, Type } from '@google/genai';
+import * as errore from 'errore';
+import { createLogger, LogPrefix } from './logger.js';
+import { glob } from 'glob';
+import { ripGrep } from 'ripgrep-js';
+import { ApiKeyMissingError, InvalidAudioFormatError, TranscriptionError, EmptyTranscriptionError, NoResponseContentError, NoToolResponseError, GrepSearchError, GlobSearchError, } from './errors.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
+function runGrep({ pattern, directory }) {
+    return errore.tryAsync({
+        try: async () => {
+            const results = await ripGrep(directory, {
+                string: pattern,
+                globs: ['!node_modules/**', '!.git/**', '!dist/**', '!build/**'],
+            });
+            if (results.length === 0) {
+                return 'No matches found';
+            }
+            const output = results
+                .slice(0, 10)
+                .map((match) => {
+                return `${match.path.text}:${match.line_number}: ${match.lines.text.trim()}`;
+            })
+                .join('\n');
+            return output.slice(0, 2000);
+        },
+        catch: (e) => new GrepSearchError({ pattern, cause: e }),
+    });
+}
+function runGlob({ pattern, directory }) {
+    return errore.tryAsync({
+        try: async () => {
+            const files = await glob(pattern, {
+                cwd: directory,
+                nodir: false,
+                ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+                maxDepth: 10,
+            });
+            if (files.length === 0) {
+                return 'No files found';
+            }
+            return files.slice(0, 30).join('\n');
+        },
+        catch: (e) => new GlobSearchError({ pattern, cause: e }),
+    });
+}
+const grepToolDeclaration = {
+    name: 'grep',
+    description: 'Search for a pattern in file contents to verify if a technical term, function name, or variable exists in the code. Use this to check if transcribed words match actual code.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The search pattern (case-insensitive). Can be a word, function name, or partial match.',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const globToolDeclaration = {
+    name: 'glob',
+    description: 'Search for files by name pattern. Use this to verify if a filename or directory mentioned in the audio actually exists in the project.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            pattern: {
+                type: Type.STRING,
+                description: 'The glob pattern to match files. Examples: "*.ts", "**/*.json", "**/config*", "src/**/*.tsx"',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+const transcriptionResultToolDeclaration = {
+    name: 'transcriptionResult',
+    description: 'MANDATORY: You MUST call this tool to complete the task. This is the ONLY way to return results - text responses are ignored. Call this with your transcription, even if imperfect. An imperfect transcription is better than none.',
+    parameters: {
+        type: Type.OBJECT,
+        properties: {
+            transcription: {
+                type: Type.STRING,
+                description: 'The final transcription of the audio. MUST be non-empty. If audio is unclear, transcribe your best interpretation. If silent, use "[inaudible audio]".',
+            },
+        },
+        required: ['transcription'],
+    },
+};
+function createToolRunner({ directory }) {
+    const hasDirectory = directory && directory.trim().length > 0;
+    return async ({ name, args }) => {
+        if (name === 'transcriptionResult') {
+            return {
+                type: 'result',
+                transcription: args?.transcription || '',
+            };
+        }
+        if (name === 'grep' && hasDirectory) {
+            const pattern = args?.pattern || '';
+            voiceLogger.log(`Grep search: "${pattern}"`);
+            const result = await runGrep({ pattern, directory });
+            const output = (() => {
+                if (result instanceof Error) {
+                    voiceLogger.error('grep search failed:', result);
+                    return 'grep search failed';
+                }
+                return result;
+            })();
+            voiceLogger.log(`Grep result: ${output.slice(0, 100)}...`);
+            return { type: 'toolResponse', name: 'grep', output };
+        }
+        if (name === 'glob' && hasDirectory) {
+            const pattern = args?.pattern || '';
+            voiceLogger.log(`Glob search: "${pattern}"`);
+            const result = await runGlob({ pattern, directory });
+            const output = (() => {
+                if (result instanceof Error) {
+                    voiceLogger.error('glob search failed:', result);
+                    return 'glob search failed';
+                }
+                return result;
+            })();
+            voiceLogger.log(`Glob result: ${output.slice(0, 100)}...`);
+            return { type: 'toolResponse', name: 'glob', output };
+        }
+        return { type: 'skip' };
+    };
+}
+export async function runTranscriptionLoop({ genAI, model, initialContents, tools, temperature, toolRunner, maxSteps = 10, }) {
+    // Wrap external API call that can throw
+    const initialResponse = await errore.tryAsync({
+        try: () => genAI.models.generateContent({
+            model,
+            contents: initialContents,
+            config: {
+                temperature,
+                thinkingConfig: {
+                    thinkingBudget: 1024,
+                },
+                tools,
+            },
+        }),
+        catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
+    });
+    if (initialResponse instanceof Error) {
+        return initialResponse;
+    }
+    let response = initialResponse;
+    const conversationHistory = [...initialContents];
+    let stepsRemaining = maxSteps;
+    while (true) {
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            const text = response.text?.trim();
+            if (text) {
+                voiceLogger.log(`No parts but got text response: "${text.slice(0, 100)}..."`);
+                return text;
+            }
+            return new NoResponseContentError();
+        }
+        const functionCalls = candidate.content.parts.filter((part) => 'functionCall' in part && !!part.functionCall);
+        if (functionCalls.length === 0) {
+            const text = response.text?.trim();
+            if (text) {
+                voiceLogger.log(`No function calls but got text: "${text.slice(0, 100)}..."`);
+                return text;
+            }
+            return new TranscriptionError({ reason: 'Model did not produce a transcription' });
+        }
+        conversationHistory.push({
+            role: 'model',
+            parts: candidate.content.parts,
+        });
+        const functionResponseParts = [];
+        for (const part of functionCalls) {
+            const call = part.functionCall;
+            const args = call.args;
+            const result = await toolRunner({ name: call.name || '', args });
+            if (result.type === 'result') {
+                const transcription = result.transcription?.trim() || '';
+                voiceLogger.log(`Transcription result received: "${transcription.slice(0, 100)}..."`);
+                if (!transcription) {
+                    return new EmptyTranscriptionError();
+                }
+                return transcription;
+            }
+            if (result.type === 'toolResponse') {
+                stepsRemaining--;
+                const stepsWarning = (() => {
+                    if (stepsRemaining <= 0) {
+                        return '\n\n[CRITICAL: Tool limit reached. You MUST call transcriptionResult NOW. No more grep/glob allowed. Call transcriptionResult immediately with your best transcription.]';
+                    }
+                    if (stepsRemaining === 1) {
+                        return '\n\n[URGENT: FINAL STEP. You MUST call transcriptionResult NOW. Do NOT call grep or glob. Call transcriptionResult with your transcription immediately.]';
+                    }
+                    if (stepsRemaining <= 3) {
+                        return `\n\n[WARNING: Only ${stepsRemaining} steps remaining. Finish searching soon and call transcriptionResult. Do not wait until the last step.]`;
+                    }
+                    return '';
+                })();
+                functionResponseParts.push({
+                    functionResponse: {
+                        name: result.name,
+                        response: { output: result.output + stepsWarning },
+                    },
+                });
+            }
+        }
+        if (functionResponseParts.length === 0) {
+            return new NoToolResponseError();
+        }
+        conversationHistory.push({
+            role: 'user',
+            parts: functionResponseParts,
+        });
+        // Wrap external API call that can throw
+        const nextResponse = await errore.tryAsync({
+            try: () => genAI.models.generateContent({
+                model,
+                contents: conversationHistory,
+                config: {
+                    temperature,
+                    thinkingConfig: {
+                        thinkingBudget: 512,
+                    },
+                    tools: stepsRemaining <= 0
+                        ? [{ functionDeclarations: [transcriptionResultToolDeclaration] }]
+                        : tools,
+                },
+            }),
+            catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
+        });
+        if (nextResponse instanceof Error) {
+            return nextResponse;
+        }
+        response = nextResponse;
+    }
+}
+export function transcribeAudio({ audio, prompt, language, temperature, geminiApiKey, directory, currentSessionContext, lastSessionContext, }) {
+    const apiKey = geminiApiKey || process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        return Promise.resolve(new ApiKeyMissingError({ service: 'Gemini' }));
+    }
+    const genAI = new GoogleGenAI({ apiKey });
+    const audioBase64 = (() => {
+        if (typeof audio === 'string') {
+            return audio;
+        }
+        if (audio instanceof Buffer) {
+            return audio.toString('base64');
+        }
+        if (audio instanceof Uint8Array) {
+            return Buffer.from(audio).toString('base64');
+        }
+        if (audio instanceof ArrayBuffer) {
+            return Buffer.from(audio).toString('base64');
+        }
+        return '';
+    })();
+    if (!audioBase64) {
+        return Promise.resolve(new InvalidAudioFormatError());
+    }
+    const languageHint = language ? `The audio is in ${language}.\n\n` : '';
+    // build session context section
+    const sessionContextParts = [];
+    if (lastSessionContext) {
+        sessionContextParts.push(`<last_session>
+${lastSessionContext}
+</last_session>`);
+    }
+    if (currentSessionContext) {
+        sessionContextParts.push(`<current_session>
+${currentSessionContext}
+</current_session>`);
+    }
+    const sessionContextSection = sessionContextParts.length > 0
+        ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
+        : '';
+    const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
+
+CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
+- The transcriptionResult tool is the ONLY way to return results
+- Text responses are completely ignored - only tool calls work
+- You MUST call transcriptionResult even if you run out of tool calls
+- An imperfect transcription is better than no transcription
+- DO NOT end without calling transcriptionResult
+
+This is a software development environment. The speaker is giving instructions to an AI coding assistant. Expect:
+- File paths, function names, CLI commands, package names, API endpoints
+
+RULES:
+1. If audio is unclear, transcribe your best interpretation, interpreting words event with strong accents are present, identifying the accent being used first so you can guess what the words meawn
+2. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
+3. Use the session context below to understand technical terms, file names, function names mentioned
+
+Common corrections (apply without tool calls):
+- "reacked" → "React", "jason" → "JSON", "get hub" → "GitHub", "no JS" → "Node.js", "dacker" → "Docker"
+
+Project file structure:
+<file_tree>
+${prompt}
+</file_tree>
+${sessionContextSection}
+
+REMEMBER: Call "transcriptionResult" tool with your transcription. This is mandatory.
+
+Note: "critique" is a CLI tool for showing diffs in the browser.`;
+    // const hasDirectory = directory && directory.trim().length > 0
+    const tools = [
+        {
+            functionDeclarations: [
+                transcriptionResultToolDeclaration,
+                // grep/glob disabled - was causing transcription to hang
+                // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+            ],
+        },
+    ];
+    const initialContents = [
+        {
+            role: 'user',
+            parts: [
+                { text: transcriptionPrompt },
+                {
+                    inlineData: {
+                        data: audioBase64,
+                        mimeType: 'audio/mpeg',
+                    },
+                },
+            ],
+        },
+    ];
+    const toolRunner = createToolRunner({ directory });
+    return runTranscriptionLoop({
+        genAI,
+        model: 'gemini-2.5-flash',
+        initialContents,
+        tools,
+        temperature: temperature ?? 0.3,
+        toolRunner,
+    });
+}

package/dist/worker-types.js

@@ -0,0 +1,4 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
+export {};

package/dist/worktree-utils.js

@@ -0,0 +1,134 @@
+// Worktree utility functions.
+// Wrapper for OpenCode worktree creation that also initializes git submodules.
+// Also handles capturing and applying git diffs when creating worktrees from threads.
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createLogger, LogPrefix } from './logger.js';
+export const execAsync = promisify(exec);
+const logger = createLogger(LogPrefix.WORKTREE);
+/**
+ * Create a worktree using OpenCode SDK and initialize git submodules.
+ * This wrapper ensures submodules are properly set up in new worktrees.
+ *
+ * If diff is provided, it's applied BEFORE submodule update to ensure
+ * any submodule pointer changes in the diff are respected.
+ */
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, diff, }) {
+    // 1. Create worktree via OpenCode SDK
+    const response = await clientV2.worktree.create({
+        directory,
+        worktreeCreateInput: { name },
+    });
+    if (response.error) {
+        return new Error(`SDK error: ${JSON.stringify(response.error)}`);
+    }
+    if (!response.data) {
+        return new Error('No worktree data returned from SDK');
+    }
+    const worktreeDir = response.data.directory;
+    let diffApplied = false;
+    // 2. Apply diff BEFORE submodule update (if provided)
+    // This ensures any submodule pointer changes in the diff are applied first,
+    // so submodule update checks out the correct commits.
+    if (diff) {
+        logger.log(`Applying diff to ${worktreeDir} before submodule init`);
+        diffApplied = await applyGitDiff(worktreeDir, diff);
+    }
+    // 3. Init submodules in new worktree (don't block on failure)
+    // Uses --init to initialize, --recursive for nested submodules.
+    // Submodules will be checked out at the commit specified by the (possibly updated) index.
+    try {
+        logger.log(`Initializing submodules in ${worktreeDir}`);
+        await execAsync('git submodule update --init --recursive', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Submodules initialized in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - submodules might not exist
+        logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // 4. Install dependencies using ni (detects package manager from lockfile)
+    try {
+        logger.log(`Installing dependencies in ${worktreeDir}`);
+        await execAsync('npx -y ni', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Dependencies installed in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - might not be a JS project or might fail for various reasons
+        logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return { ...response.data, diffApplied };
+}
+/**
+ * Capture git diff from a directory (both staged and unstaged changes).
+ * Returns null if no changes or on error.
+ */
+export async function captureGitDiff(directory) {
+    try {
+        // Capture unstaged changes
+        const unstagedResult = await execAsync('git diff', { cwd: directory });
+        const unstaged = unstagedResult.stdout.trim();
+        // Capture staged changes
+        const stagedResult = await execAsync('git diff --staged', { cwd: directory });
+        const staged = stagedResult.stdout.trim();
+        if (!unstaged && !staged) {
+            return null;
+        }
+        return { unstaged, staged };
+    }
+    catch (e) {
+        logger.warn(`Failed to capture git diff from ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+/**
+ * Run a git command with stdin input.
+ * Uses spawn to pipe the diff content to git apply.
+ */
+function runGitWithStdin(args, cwd, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr || `git ${args.join(' ')} failed with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+        child.stdin?.write(input);
+        child.stdin?.end();
+    });
+}
+/**
+ * Apply a captured git diff to a directory.
+ * Applies staged changes first, then unstaged.
+ */
+export async function applyGitDiff(directory, diff) {
+    try {
+        // Apply staged changes first (and stage them)
+        if (diff.staged) {
+            logger.log(`Applying staged diff to ${directory}`);
+            await runGitWithStdin(['apply', '--index'], directory, diff.staged);
+        }
+        // Apply unstaged changes (don't stage them)
+        if (diff.unstaged) {
+            logger.log(`Applying unstaged diff to ${directory}`);
+            await runGitWithStdin(['apply'], directory, diff.unstaged);
+        }
+        logger.log(`Successfully applied diff to ${directory}`);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`Failed to apply git diff to ${directory}: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}

package/dist/xml.js

@@ -0,0 +1,90 @@
+// 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(`""`);
+    });
+});