@brianli/kimaki 0.4.72-brianli.1

package/dist/kimaki-digital-twin.e2e.test.js

@@ -0,0 +1,165 @@
+// End-to-end test using discord-digital-twin + real Kimaki bot runtime.
+// Verifies onboarding channel creation, message -> thread creation, and assistant reply.
+import fs from 'node:fs';
+import path from 'node:path';
+import { expect, test } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { CachedOpencodeProviderProxy } from 'opencode-cached-provider';
+import { setDataDir } from './config.js';
+import { startDiscordBot } from './discord-bot.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { getOpencodeServers } from './opencode.js';
+const geminiApiKey = process.env['GEMINI_API_KEY'] ||
+    process.env['GOOGLE_GENERATIVE_AI_API_KEY'] ||
+    '';
+const geminiModel = process.env['GEMINI_FLASH_MODEL'] || 'gemini-2.5-flash';
+const e2eTest = geminiApiKey.length > 0 ? test : test.skip;
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'kimaki-digital-twin-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    const providerCacheDbPath = path.join(root, 'provider-cache.db');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return {
+        root,
+        dataDir,
+        projectDirectory,
+        providerCacheDbPath,
+    };
+}
+function chooseLockPort() {
+    return 45_000 + (Date.now() % 2_000);
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+async function cleanupOpencodeServers() {
+    const servers = getOpencodeServers();
+    for (const [, server] of servers) {
+        if (!server.process.killed) {
+            server.process.kill('SIGTERM');
+        }
+    }
+    servers.clear();
+}
+e2eTest('onboarding then message creates thread and assistant reply via digital twin', async () => {
+    const directories = createRunDirectories();
+    const lockPort = chooseLockPort();
+    process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+    setDataDir(directories.dataDir);
+    const proxy = new CachedOpencodeProviderProxy({
+        cacheDbPath: directories.providerCacheDbPath,
+        targetBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+        apiKey: geminiApiKey,
+        cacheMethods: ['POST'],
+    });
+    const testUserId = '100000000000000777';
+    const textChannelId = '100000000000000778';
+    const discord = new DigitalDiscord({
+        guild: {
+            name: 'Kimaki E2E Guild',
+            ownerId: testUserId,
+        },
+        channels: [
+            {
+                id: textChannelId,
+                name: 'kimaki-e2e',
+                type: ChannelType.GuildText,
+            },
+        ],
+        users: [
+            {
+                id: testUserId,
+                username: 'e2e-user',
+            },
+        ],
+    });
+    let botClient = null;
+    try {
+        await Promise.all([proxy.start(), discord.start()]);
+        const opencodeConfig = proxy.buildOpencodeConfig({
+            providerName: 'cached-google',
+            providerNpm: '@ai-sdk/google',
+            model: geminiModel,
+            smallModel: geminiModel,
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: textChannelId,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+            appId: discord.botUserId,
+        });
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        await discord.channel(textChannelId).user(testUserId).sendMessage({
+            content: 'Reply with exactly: kimaki digital twin ok',
+        });
+        const createdThread = await discord.channel(textChannelId).waitForThread({
+            timeout: 60_000,
+            predicate: (thread) => {
+                return thread.name === 'Reply with exactly: kimaki digital twin ok';
+            },
+        });
+        const botReply = await discord.thread(createdThread.id).waitForBotReply({
+            timeout: 120_000,
+        });
+        expect(createdThread.id.length).toBeGreaterThan(0);
+        expect(botReply.content.trim().length).toBeGreaterThan(0);
+    }
+    finally {
+        if (botClient) {
+            botClient.destroy();
+        }
+        await cleanupOpencodeServers();
+        await Promise.all([
+            closeDatabase().catch(() => {
+                return;
+            }),
+            stopHranaServer().catch(() => {
+                return;
+            }),
+            proxy.stop().catch(() => {
+                return;
+            }),
+            discord.stop().catch(() => {
+                return;
+            }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        fs.rmSync(directories.dataDir, { recursive: true, force: true });
+    }
+}, 360_000);

package/dist/limit-heading-depth.js

@@ -0,0 +1,25 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+import { Lexer } from 'marked';
+export function limitHeadingDepth(markdown, maxDepth = 3) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'heading') {
+            const heading = token;
+            if (heading.depth > maxDepth) {
+                const hashes = '#'.repeat(maxDepth);
+                result += hashes + ' ' + heading.text + '\n';
+            }
+            else {
+                result += token.raw;
+            }
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}

package/dist/limit-heading-depth.test.js

@@ -0,0 +1,105 @@
+import { expect, test } from 'vitest';
+import { limitHeadingDepth } from './limit-heading-depth.js';
+test('converts h4 to h3', () => {
+    const input = '#### Fourth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `);
+});
+test('converts h5 to h3', () => {
+    const input = '##### Fifth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `);
+});
+test('converts h6 to h3', () => {
+    const input = '###### Sixth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `);
+});
+test('preserves h3 unchanged', () => {
+    const input = '### Third level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"### Third level heading"`);
+});
+test('preserves h2 unchanged', () => {
+    const input = '## Second level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"## Second level heading"`);
+});
+test('preserves h1 unchanged', () => {
+    const input = '# First level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"# First level heading"`);
+});
+test('handles multiple headings in document', () => {
+    const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`;
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `);
+});
+test('preserves heading with inline formatting', () => {
+    const input = '#### Heading with **bold** and `code`';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `);
+});
+test('handles empty markdown', () => {
+    const result = limitHeadingDepth('');
+    expect(result).toMatchInlineSnapshot(`""`);
+});
+test('handles markdown with no headings', () => {
+    const input = 'Just some text\n\nAnd more text';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `);
+});
+test('allows custom maxDepth', () => {
+    const input = '### Third level';
+    const result = limitHeadingDepth(input, 2);
+    expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `);
+});

package/dist/logger.js

@@ -0,0 +1,160 @@
+// Prefixed logging utility using @clack/prompts for consistent visual style.
+// All log methods use clack's log.message() with appropriate symbols to prevent
+// output interleaving from concurrent async operations.
+import { log as clackLog } from '@clack/prompts';
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import pc from 'picocolors';
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js';
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+    ABORT: 'ABORT',
+    ADD_PROJECT: 'ADD_PROJ',
+    AGENT: 'AGENT',
+    ASK_QUESTION: 'QUESTION',
+    CLI: 'CLI',
+    COMPACT: 'COMPACT',
+    CREATE_PROJECT: 'NEW_PROJ',
+    DB: 'DB',
+    DIFF: 'DIFF',
+    FILE_UPLOAD: 'FILEUP',
+    DISCORD: 'DISCORD',
+    FORK: 'FORK',
+    FORMATTING: 'FORMAT',
+    GENAI: 'GENAI',
+    HEAP: 'HEAP',
+    GENAI_WORKER: 'GENAI_W',
+    INTERACTION: 'INTERACT',
+    IPC: 'IPC',
+    LOGIN: 'LOGIN',
+    MARKDOWN: 'MARKDOWN',
+    MODEL: 'MODEL',
+    OPENAI: 'OPENAI',
+    OPENCODE: 'OPENCODE',
+    PERMISSIONS: 'PERMS',
+    QUEUE: 'QUEUE',
+    REMOVE_PROJECT: 'RM_PROJ',
+    RESUME: 'RESUME',
+    SESSION: 'SESSION',
+    SHARE: 'SHARE',
+    TASK: 'TASK',
+    TOOLS: 'TOOLS',
+    UNDO_REDO: 'UNDO',
+    USER_CMD: 'USER_CMD',
+    VERBOSITY: 'VERBOSE',
+    VOICE: 'VOICE',
+    WORKER: 'WORKER',
+    THINKING: 'THINK',
+    WORKTREE: 'WORKTREE',
+    XML: 'XML',
+};
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(...Object.values(LogPrefix).map((p) => p.length));
+// Log file path is set by initLogFile() after the data directory is known.
+// Before initLogFile() is called, file logging is skipped.
+let logFilePath = null;
+/**
+ * Initialize file logging. Call this after setDataDir() so the log file
+ * is written to `<dataDir>/kimaki.log`. The log file is truncated on
+ * every bot startup so it contains only the current run's logs.
+ */
+export function initLogFile(dataDir) {
+    logFilePath = path.join(dataDir, 'kimaki.log');
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`);
+}
+/**
+ * Set the log file path without truncating. Use this in child processes
+ * (like the opencode plugin) that should append to the same log file
+ * the bot process already created with initLogFile().
+ */
+export function setLogFilePath(dataDir) {
+    logFilePath = path.join(dataDir, 'kimaki.log');
+}
+export function getLogFilePath() {
+    return logFilePath;
+}
+function formatArg(arg) {
+    if (typeof arg === 'string') {
+        return sanitizeSensitiveText(arg, { redactPaths: false });
+    }
+    const safeArg = sanitizeUnknownValue(arg, { redactPaths: false });
+    return util.inspect(safeArg, { colors: true, depth: 4 });
+}
+export function formatErrorWithStack(error) {
+    if (error instanceof Error) {
+        return sanitizeSensitiveText(error.stack ?? `${error.name}: ${error.message}`, { redactPaths: false });
+    }
+    if (typeof error === 'string') {
+        return sanitizeSensitiveText(error, { redactPaths: false });
+    }
+    // Keep this stable and safe for unknown values (handles circular structures).
+    const safeError = sanitizeUnknownValue(error, { redactPaths: false });
+    return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+        redactPaths: false,
+    });
+}
+function writeToFile(level, prefix, args) {
+    if (!logFilePath) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
+    fs.appendFileSync(logFilePath, message);
+}
+function getTimestamp() {
+    const now = new Date();
+    return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+}
+function padPrefix(prefix) {
+    return prefix.padEnd(MAX_PREFIX_LENGTH);
+}
+function formatMessage(timestamp, prefix, args) {
+    return [pc.dim(timestamp), prefix, ...args.map(formatArg)].join(' ');
+}
+const noSpacing = { spacing: 0 };
+// Suppress clack terminal output during vitest runs to avoid flooding
+// test output with hundreds of log lines. File logging still works.
+const isVitest = !!process.env['KIMAKI_VITEST'];
+export function createLogger(prefix) {
+    const paddedPrefix = padPrefix(prefix);
+    const log = (...args) => {
+        writeToFile('LOG', prefix, args);
+        if (isVitest) {
+            return;
+        }
+        clackLog.message(formatMessage(getTimestamp(), pc.cyan(paddedPrefix), args), {
+            ...noSpacing,
+            // symbol: `|`,
+        });
+    };
+    return {
+        log,
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+            if (isVitest) {
+                return;
+            }
+            clackLog.error(formatMessage(getTimestamp(), pc.red(paddedPrefix), args), noSpacing);
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+            if (isVitest) {
+                return;
+            }
+            clackLog.warn(formatMessage(getTimestamp(), pc.yellow(paddedPrefix), args), noSpacing);
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+            if (isVitest) {
+                return;
+            }
+            clackLog.info(formatMessage(getTimestamp(), pc.blue(paddedPrefix), args), noSpacing);
+        },
+        debug: log,
+    };
+}