kimaki 0.4.90 → 0.4.91

package/dist/queue-advanced-question.e2e.test.js

@@ -3,46 +3,94 @@
 // The user's message must appear as a real user message in the thread, not
 // get consumed as a tool result answer (which lost voice/image content).
 import { describe, test, expect, afterEach } from 'vitest';
-import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
-import { pendingQuestionContexts } from './commands/ask-question.js';
+import { setupQueueAdvancedSuite, TEST_USER_ID } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage } from './test-utils.js';
 import { store } from './store.js';
+import { getOpencodeClient } from './opencode.js';
+import { getThreadSession } from './database.js';
 const TEXT_CHANNEL_ID = '200000000000001007';
 const VOICE_CHANNEL_ID = '200000000000001017';
-async function waitForPendingQuestion({ threadId, timeoutMs, }) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
-            return context.thread.id === threadId;
-        });
-        if (entry) {
-            return { contextHash: entry[0] };
-        }
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
+function setDeterministicTranscription(config) {
+    store.setState({
+        test: { deterministicTranscription: config },
+    });
+}
+function getOpencodeClientForTest(projectDirectory) {
+    const client = getOpencodeClient(projectDirectory);
+    if (!client) {
+        throw new Error('OpenCode client not found for project directory');
     }
-    throw new Error('Timed out waiting for pending question context');
+    return client;
+}
+function getTextFromParts(parts) {
+    return parts.flatMap((part) => {
+        if (part.type === 'text') {
+            return [part.text];
+        }
+        return [];
+    });
+}
+function normalizeSessionText(text) {
+    return text
+        .replace(/\[current git branch is [^\]]+\]/g, '')
+        .replace(/<discord-user[^>]*\/>/g, '<discord-user />')
+        .trim();
 }
-async function waitForNoPendingQuestion({ threadId, timeoutMs, }) {
+function getSessionRoleTextTimeline(messages) {
+    return messages.flatMap((message) => {
+        const text = normalizeSessionText(getTextFromParts(message.parts).join(''));
+        if (!text.trim()) {
+            return [];
+        }
+        return [{ role: message.info.role, text }];
+    });
+}
+function getSessionMessageSummary(messages) {
+    return messages.map((message) => {
+        return {
+            role: message.info.role,
+            parts: message.parts.map((part) => {
+                if (part.type === 'text') {
+                    return {
+                        type: part.type,
+                        text: normalizeSessionText(part.text),
+                    };
+                }
+                if (part.type === 'tool') {
+                    return {
+                        type: part.type,
+                        tool: part.tool,
+                        status: part.state.status,
+                        title: part.state.status === 'completed' ? part.state.title : undefined,
+                        output: part.state.status === 'completed' ? part.state.output : undefined,
+                    };
+                }
+                return { type: part.type };
+            }),
+        };
+    });
+}
+async function waitForSessionMessages({ projectDirectory, sessionId, timeoutMs, predicate, }) {
+    const client = getOpencodeClientForTest(projectDirectory);
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
-        const stillPending = [...pendingQuestionContexts.values()].some((context) => {
-            return context.thread.id === threadId;
+        const response = await client.session.messages({
+            sessionID: sessionId,
+            directory: projectDirectory,
         });
-        if (!stillPending) {
-            return;
+        const messages = response.data ?? [];
+        if (predicate(messages)) {
+            return messages;
         }
         await new Promise((resolve) => {
             setTimeout(resolve, 100);
         });
     }
-    throw new Error('Timed out waiting for question context cleanup');
-}
-function setDeterministicTranscription(config) {
-    store.setState({
-        test: { deterministicTranscription: config },
+    const finalResponse = await client.session.messages({
+        sessionID: sessionId,
+        directory: projectDirectory,
     });
+    return finalResponse.data ?? [];
 }
 describe('queue advanced: question tool answer', () => {
     const ctx = setupQueueAdvancedSuite({
@@ -130,12 +178,16 @@ describe('queue advanced: voice message during pending question', () => {
             timeout: 12_000,
         });
         // Send a voice message while the question is pending.
-        // message.content is "" for voice messages — only the attachment exists.
+        // Reproduction: Discord voice messages can still carry non-empty
+        // message.content. The bug consumed that raw text before transcription,
+        // so the session never received the spoken content.
         setDeterministicTranscription({
             transcription: 'I want option Alpha please',
             queueMessage: false,
         });
-        await th.user(TEST_USER_ID).sendVoiceMessage();
+        await th.user(TEST_USER_ID).sendVoiceMessage({
+            content: 'VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL',
+        });
         // Give time for question cleanup to propagate
         await new Promise((r) => {
             setTimeout(r, 1_000);
@@ -155,21 +207,54 @@ describe('queue advanced: voice message during pending question', () => {
             afterMessageIncludes: 'I want option Alpha please',
             afterAuthorId: ctx.discord.botUserId,
         });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeTruthy();
+        const sessionMessages = await waitForSessionMessages({
+            projectDirectory: ctx.directories.projectDirectory,
+            sessionId: sessionId,
+            timeoutMs: 8_000,
+            predicate: (messages) => {
+                const timeline = getSessionRoleTextTimeline(messages);
+                return timeline.some((entry) => {
+                    return entry.text.includes('I want option Alpha please');
+                });
+            },
+        });
+        const sessionTimeline = getSessionRoleTextTimeline(sessionMessages);
+        const sessionSummary = getSessionMessageSummary(sessionMessages);
+        const latestUserText = sessionTimeline
+            .filter((entry) => {
+            return entry.role === 'user';
+        })
+            .at(-1)?.text;
+        const assistantTexts = sessionTimeline.flatMap((entry) => {
+            if (entry.role === 'assistant') {
+                return [entry.text];
+            }
+            return [];
+        });
+        expect(latestUserText).toContain('I want option Alpha please');
+        expect(latestUserText).not.toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL');
+        expect(assistantTexts).toContain('ok');
+        expect(sessionSummary.some((message) => {
+            return message.role === 'user'
+                && message.parts.some((part) => {
+                    return part.type === 'text' && part.text.includes('I want option Alpha please');
+                });
+        })).toBe(true);
+        expect(sessionSummary.some((message) => {
+            return message.role === 'assistant'
+                && message.parts.some((part) => {
+                    return part.type === 'text' && part.text === 'ok';
+                });
+        })).toBe(true);
         const timeline = await th.text({ showInteractions: true });
-        expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (queue-question-tester)
-        QUESTION_TEXT_ANSWER_MARKER
-        --- from: assistant (TestBot)
-        **Pick one**
-        Which option do you prefer?
-        --- from: user (queue-question-tester)
-        [attachment: voice-message.ogg]
-        --- from: assistant (TestBot)
-        🎤 Transcribing voice message...
-        📝 **Transcribed message:** I want option Alpha please
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
+        expect(timeline).toContain('QUESTION_TEXT_ANSWER_MARKER');
+        expect(timeline).toContain('Which option do you prefer?');
+        expect(timeline).toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL');
+        expect(timeline).toContain('🎤 Transcribing voice message...');
+        expect(timeline).toContain('📝 **Transcribed message:** I want option Alpha please');
+        expect(timeline).toContain('⬥ ok');
         // Voice content must be present as a real transcribed message, not lost
         expect(timeline).toContain('I want option Alpha please');
     }, 20_000);

package/dist/sentry.js

@@ -1,123 +1,16 @@
-// Sentry error tracking initialization and notifyError helper.
-// Uses @sentry/node for the Node.js runtime (bot process, plugin process, worker threads).
-// Must be initialized early in both the bot process (cli.ts) and plugin process
-// (kimaki-opencode-plugin.ts). The plugin process receives the DSN via KIMAKI_SENTRY_DSN env var.
-import * as Sentry from '@sentry/node';
-import * as errore from 'errore';
-import { createRequire } from 'node:module';
-import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js';
-// DSN placeholder — replace with your Sentry project DSN.
-// Users can also set KIMAKI_SENTRY_DSN env var.
-const HARDCODED_DSN = 'https://3b87e21ac01cb9c66225719ea65111d2@o4510952031715328.ingest.us.sentry.io/4510952088469504';
-function readKimakiVersion() {
-    try {
-        const require = createRequire(import.meta.url);
-        const pkg = require('../package.json');
-        const version = pkg.version;
-        if (!version) {
-            return 'unknown';
-        }
-        return version;
-    }
-    catch {
-        return 'unknown';
-    }
-}
-const kimakiVersion = readKimakiVersion();
-const kimakiRelease = `kimaki@${kimakiVersion}`;
-let initialized = false;
+// Sentry stubs. @sentry/node was removed — these are no-op placeholders
+// so the 20+ files importing notifyError/initSentry don't need changing.
+// If Sentry is re-enabled in the future, replace these stubs with real calls.
 /**
- * Initialize Sentry. Call once at process startup.
- * No-op if DSN is empty or --no-sentry was passed.
+ * Initialize Sentry. Currently a no-op.
  */
-export function initSentry({ dsn } = {}) {
-    if (process.env.KIMAKI_SENTRY_DISABLED === '1') {
-        return;
-    }
-    const resolvedDsn = dsn || process.env.KIMAKI_SENTRY_DSN || HARDCODED_DSN;
-    if (!resolvedDsn || initialized) {
-        return;
-    }
-    Sentry.init({
-        dsn: resolvedDsn,
-        release: kimakiRelease,
-        integrations: [],
-        tracesSampleRate: 0,
-        sendDefaultPii: false,
-        profilesSampleRate: 0,
-        beforeSend(event, hint) {
-            // Skip in development — too noisy, errors appear in terminal
-            if (process.env.NODE_ENV === 'development') {
-                return null;
-            }
-            // Skip abort errors — walks the cause chain so wrapped aborts are caught
-            if (errore.isAbortError(hint.originalException)) {
-                return null;
-            }
-            try {
-                const sanitizedEvent = sanitizeUnknownValue(event, {
-                    redactPaths: false,
-                });
-                if (sanitizedEvent && typeof sanitizedEvent === 'object') {
-                    return sanitizedEvent;
-                }
-            }
-            catch {
-                return event;
-            }
-            return event;
-        },
-    });
-    Sentry.setTag('kimaki_version', kimakiVersion);
-    initialized = true;
-}
+export function initSentry(_opts) { }
 /**
- * Report an unexpected error to Sentry.
+ * Report an unexpected error. Currently a no-op.
  * Safe to call even if Sentry is not initialized.
  * Fire-and-forget only: use `void notifyError(error, msg)` and never await it.
- * This helper must never throw.
- * Use this at terminal error handlers — the "last catch" in a chain
- * where the error would otherwise be invisible.
  */
-export function notifyError(error, msg) {
-    try {
-        if (!initialized) {
-            return;
-        }
-        // TODO re enable sentry?
-        if (!process.env.KIMAKI_SENTRY)
-            return;
-        const safeMsg = (() => {
-            if (!msg) {
-                return undefined;
-            }
-            try {
-                return sanitizeSensitiveText(msg, { redactPaths: false });
-            }
-            catch {
-                return msg;
-            }
-        })();
-        const safeError = (() => {
-            try {
-                return sanitizeUnknownValue(error, { redactPaths: false });
-            }
-            catch {
-                return error;
-            }
-        })();
-        Sentry.captureException(error, {
-            tags: { kimaki_version: kimakiVersion },
-            extra: { msg: safeMsg, kimakiVersion, error: safeError },
-        });
-        void Sentry.flush(1000).catch(() => {
-            return;
-        });
-    }
-    catch {
-        return;
-    }
-}
+export function notifyError(_error, _msg) { }
 /**
  * User-readable error class. Messages from AppError instances
  * are forwarded to the user as-is; regular Error messages may be obfuscated.

package/dist/session-handler/event-stream-state.js

@@ -5,7 +5,7 @@
 import { getOpencodeEventSessionId } from './opencode-session-event-log.js';
 function getTaskChildSessionId({ part, }) {
     // Event-shape reference:
-    // - discord/src/session-handler/event-stream-fixtures/real-session-task-three-parallel-sleeps.jsonl
+    // - cli/src/session-handler/event-stream-fixtures/real-session-task-three-parallel-sleeps.jsonl
     // - In real task events, state.metadata.sessionId appears on running/completed
     //   tool updates and is the canonical child-session identifier.
     // We intentionally do not parse state.output because it is user-facing text

package/dist/session-handler/thread-runtime-state.js

@@ -15,6 +15,7 @@ import { store } from '../store.js';
 export function initialThreadState() {
     return {
         sessionId: undefined,
+        sessionUsername: undefined,
         queueItems: [],
         listenerController: undefined,
         sentPartIds: new Set(),
@@ -60,6 +61,14 @@ export function removeThread(threadId) {
 export function setSessionId(threadId, sessionId) {
     updateThread(threadId, (t) => ({ ...t, sessionId }));
 }
+export function setSessionUsername(threadId, username) {
+    updateThread(threadId, (t) => {
+        if (t.sessionUsername) {
+            return t;
+        }
+        return { ...t, sessionUsername: username };
+    });
+}
 export function enqueueItem(threadId, item) {
     updateThread(threadId, (t) => ({
         ...t,