runwork 0.5.0 → 0.6.0

package/dist/agents/__tests__/codex-stats.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    statSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/mock/home'),
+    platform: vi.fn(() => 'darwin'),
+}));
+vi.mock('child_process', () => ({
+    execFileSync: vi.fn(),
+}));
+vi.mock('../../utils/sqlite.js', () => ({
+    querySqlite: vi.fn(() => ''),
+}));
+vi.mock('smol-toml', () => ({
+    parse: vi.fn(() => ({})),
+    stringify: vi.fn(() => ''),
+}));
+// Mock utility imports so the module loads cleanly
+vi.mock('../utils/json-config.js', () => ({
+    mergeJsonMcpServers: vi.fn(),
+}));
+vi.mock('../utils/instruction-hint.js', () => ({
+    writeHintToFile: vi.fn(),
+}));
+vi.mock('../registry.js', () => ({
+    resolvePlatformString: vi.fn((s) => s),
+    resolveToAbsolute: vi.fn((s) => s),
+}));
+import { existsSync, readFileSync } from 'fs';
+import { querySqlite } from '../../utils/sqlite.js';
+import { CodexAdapter } from '../codex.js';
+const CODEX_DIR = '/mock/home/.codex';
+const DB_PATH = `${CODEX_DIR}/state_5.sqlite`;
+const HISTORY_PATH = `${CODEX_DIR}/history.jsonl`;
+const VERSION_PATH = `${CODEX_DIR}/version.json`;
+function createCodexAdapter() {
+    return new CodexAdapter();
+}
+describe('CodexAdapter (codex).readUsageStats', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = createCodexAdapter();
+    });
+    it('queries threads table for session count since lastSyncAt', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '3';
+            if (sql.includes('sum(tokens_used)'))
+                return '15000';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '1.0.0\n0.9.0';
+            return '';
+        });
+        const syncAt = new Date(1711000000000).toISOString();
+        const result = await adapter.readUsageStats(syncAt);
+        expect(result).not.toBeNull();
+        expect(result.sessionCount).toBe(3);
+        expect(result.hasNewActivity).toBe(true);
+        // Verify querySqlite was called with the DB path
+        expect(querySqlite).toHaveBeenCalledWith(DB_PATH, expect.stringContaining('count(*)'));
+    });
+    it('sums tokens_used from threads', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '2';
+            if (sql.includes('sum(tokens_used)'))
+                return '25000';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.tokensUsed).toBe(25000);
+    });
+    it('gets latest activity timestamp', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '1';
+            if (sql.includes('sum(tokens_used)'))
+                return '5000';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        // 1712100000 seconds -> milliseconds
+        expect(result.lastActiveAt).toBe(new Date(1712100000 * 1000).toISOString());
+    });
+    it('gets CLI versions from threads', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '2';
+            if (sql.includes('sum(tokens_used)'))
+                return '0';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '1.2.0\n1.1.0';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.extra).toEqual({ cliVersions: ['1.2.0', '1.1.0'] });
+    });
+    it('counts messages from history.jsonl since lastSyncAt', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            if (p === HISTORY_PATH)
+                return true;
+            return false;
+        });
+        const historyContent = [
+            '{"session_id":"old","ts":1700000000,"text":"old prompt"}',
+            '{"session_id":"new","ts":1712000000,"text":"recent prompt"}',
+            '{"session_id":"newest","ts":1712100000,"text":"newest prompt"}',
+        ].join('\n');
+        readFileSync.mockReturnValue(historyContent);
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '2';
+            if (sql.includes('sum(tokens_used)'))
+                return '0';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '';
+            return '';
+        });
+        // sinceSec = 1711000000 (in seconds)
+        const syncAt = new Date(1711000000000).toISOString();
+        const result = await adapter.readUsageStats(syncAt);
+        expect(result).not.toBeNull();
+        // Two entries have ts > 1711000 (in seconds): 1712000000 and 1712100000
+        expect(result.messageCount).toBe(2);
+    });
+    it('returns null when ~/.codex does not exist', async () => {
+        existsSync.mockReturnValue(false);
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('returns null when state_5.sqlite does not exist', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            return false;
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('handles empty threads result', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockReturnValue('');
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('handles malformed history.jsonl lines', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CODEX_DIR)
+                return true;
+            if (p === DB_PATH)
+                return true;
+            if (p === HISTORY_PATH)
+                return true;
+            return false;
+        });
+        const historyContent = [
+            '{{{invalid json',
+            '{"session_id":"good","ts":1712000000,"text":"valid"}',
+            'not json at all',
+        ].join('\n');
+        readFileSync.mockReturnValue(historyContent);
+        querySqlite.mockImplementation((_db, sql) => {
+            if (sql.includes('count(*)'))
+                return '1';
+            if (sql.includes('sum(tokens_used)'))
+                return '0';
+            if (sql.includes('max(updated_at)'))
+                return '1712100000';
+            if (sql.includes('DISTINCT cli_version'))
+                return '';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        // Only the valid line with ts > 0 counts
+        expect(result.messageCount).toBe(1);
+    });
+});
+describe('CodexAdapter (codex).readVersion', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = createCodexAdapter();
+    });
+    it('reads version from version.json', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === VERSION_PATH)
+                return true;
+            return false;
+        });
+        readFileSync.mockReturnValue(JSON.stringify({ latest_version: '0.117.0', last_checked_at: '2026-03-30' }));
+        const version = await adapter.readVersion();
+        expect(version).toBe('0.117.0');
+    });
+    it('returns null when version.json does not exist', async () => {
+        existsSync.mockReturnValue(false);
+        const version = await adapter.readVersion();
+        expect(version).toBeNull();
+    });
+});

package/dist/agents/__tests__/cursor-stats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agents/__tests__/cursor-stats.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    statSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/mock/home'),
+    platform: vi.fn(() => 'darwin'),
+}));
+vi.mock('child_process', () => ({
+    execFileSync: vi.fn(),
+}));
+vi.mock('../../utils/sqlite.js', () => ({
+    querySqlite: vi.fn(() => ''),
+}));
+// Mock utility imports so the module loads cleanly
+vi.mock('../utils/json-config.js', () => ({
+    mergeJsonMcpServers: vi.fn(),
+}));
+vi.mock('../utils/instruction-hint.js', () => ({
+    writeHintToFile: vi.fn(),
+}));
+import { existsSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { querySqlite } from '../../utils/sqlite.js';
+import { CursorAdapter } from '../cursor.js';
+const GLOBAL_DB_PATH = '/mock/home/Library/Application Support/Cursor/User/globalStorage/state.vscdb';
+const TRACKING_DB_PATH = '/mock/home/.cursor/ai-tracking/ai-code-tracking.db';
+// Fixture data: composerData entries (one per line, as querySqlite returns)
+function makeComposerLine(overrides = {}) {
+    return JSON.stringify({
+        createdAt: 1712000000000,
+        totalLinesAdded: 50,
+        totalLinesRemoved: 10,
+        unifiedMode: 'agent',
+        ...overrides,
+    });
+}
+describe('CursorAdapter.readUsageStats', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = new CursorAdapter();
+    });
+    it('parses composerData entries and counts sessions since lastSyncAt', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            return false;
+        });
+        const oldLine = makeComposerLine({ createdAt: 1700000000000 });
+        const newLine = makeComposerLine({ createdAt: 1712000000000 });
+        querySqlite.mockReturnValue(`${oldLine}\n${newLine}`);
+        const syncAt = new Date(1711000000000).toISOString();
+        const result = await adapter.readUsageStats(syncAt);
+        expect(result).not.toBeNull();
+        expect(result.sessionCount).toBe(1);
+    });
+    it('calculates totalLinesAdded and totalLinesRemoved from composerData', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            return false;
+        });
+        const line1 = makeComposerLine({ createdAt: 1712000000000, totalLinesAdded: 100, totalLinesRemoved: 20 });
+        const line2 = makeComposerLine({ createdAt: 1712100000000, totalLinesAdded: 50, totalLinesRemoved: 5 });
+        querySqlite.mockReturnValue(`${line1}\n${line2}`);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.aiLinesAdded).toBe(150);
+        expect(result.aiLinesRemoved).toBe(25);
+    });
+    it('breaks down agentic vs chat sessions', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            return false;
+        });
+        const agentLine = makeComposerLine({ createdAt: 1712000000000, unifiedMode: 'agent' });
+        const chatLine = makeComposerLine({ createdAt: 1712100000000, unifiedMode: 'chat' });
+        const isAgenticLine = makeComposerLine({ createdAt: 1712200000000, unifiedMode: undefined, isAgentic: true });
+        querySqlite.mockReturnValue(`${agentLine}\n${chatLine}\n${isAgenticLine}`);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.extra.agenticSessions).toBe(2);
+        expect(result.extra.chatSessions).toBe(1);
+    });
+    it('reads scored_commits for AI contribution percentage', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            if (p === TRACKING_DB_PATH)
+                return true;
+            return false;
+        });
+        const composerLine = makeComposerLine({ createdAt: 1712000000000 });
+        querySqlite.mockImplementation((dbPath) => {
+            if (dbPath === GLOBAL_DB_PATH)
+                return composerLine;
+            if (dbPath === TRACKING_DB_PATH)
+                return '5|72.5';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.extra.aiCommitCount).toBe(5);
+        expect(result.extra.avgAiContributionPercent).toBe(73); // Math.round(72.5)
+    });
+    it('returns null when Cursor not installed (state.vscdb does not exist)', async () => {
+        existsSync.mockReturnValue(false);
+        querySqlite.mockReturnValue('');
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('returns null when cursorDiskKV has no composerData entries', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            return false;
+        });
+        querySqlite.mockReturnValue('');
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('handles malformed composerData JSON values', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            return false;
+        });
+        const badLine = '{{{not valid json';
+        const goodLine = makeComposerLine({ createdAt: 1712000000000 });
+        querySqlite.mockReturnValue(`${badLine}\n${goodLine}`);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.sessionCount).toBe(1);
+    });
+    it('handles empty scored_commits (no AI% in result)', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === GLOBAL_DB_PATH)
+                return true;
+            if (p === TRACKING_DB_PATH)
+                return true;
+            return false;
+        });
+        const composerLine = makeComposerLine({ createdAt: 1712000000000 });
+        querySqlite.mockImplementation((dbPath) => {
+            if (dbPath === GLOBAL_DB_PATH)
+                return composerLine;
+            if (dbPath === TRACKING_DB_PATH)
+                return '0|';
+            return '';
+        });
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        // aiCommitCount is 0, so it should not appear in extra
+        expect(result.extra.aiCommitCount).toBeUndefined();
+        expect(result.extra.avgAiContributionPercent).toBeUndefined();
+    });
+});
+describe('CursorAdapter.readVersion', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = new CursorAdapter();
+    });
+    it('returns version from cursor --version', async () => {
+        execFileSync.mockReturnValue(Buffer.from('0.49.2\n'));
+        const version = await adapter.readVersion();
+        expect(version).toBe('0.49.2');
+    });
+    it('returns null when cursor command fails', async () => {
+        execFileSync.mockImplementation(() => {
+            throw new Error('command not found');
+        });
+        const version = await adapter.readVersion();
+        expect(version).toBeNull();
+    });
+});

package/dist/agents/__tests__/graceful-degradation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agents/__tests__/graceful-degradation.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(() => false),
+    readFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
+    readdirSync: vi.fn(() => []),
+    statSync: vi.fn(() => { throw new Error('ENOENT'); }),
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/nonexistent/home'),
+    platform: vi.fn(() => 'darwin'),
+}));
+vi.mock('child_process', () => ({
+    execFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
+}));
+vi.mock('../../utils/sqlite.js', () => ({
+    querySqlite: vi.fn(() => ''),
+}));
+vi.mock('smol-toml', () => ({
+    parse: vi.fn(() => ({})),
+    stringify: vi.fn(() => ''),
+}));
+vi.mock('better-sqlite3', () => ({
+    default: vi.fn(() => { throw new Error('not available'); }),
+}));
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { execFileSync } from 'child_process';
+import { ClaudeCodeAdapter } from '../claude-code.js';
+import { ClaudeDesktopAdapter } from '../claude-desktop.js';
+import { CursorAdapter } from '../cursor.js';
+import { CodexAdapter } from '../codex.js';
+const adapters = [
+    { name: 'claude-code', adapter: new ClaudeCodeAdapter() },
+    { name: 'claude-desktop', adapter: new ClaudeDesktopAdapter() },
+    { name: 'cursor', adapter: new CursorAdapter() },
+    { name: 'codex', adapter: new CodexAdapter() },
+];
+beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: everything fails
+    vi.mocked(homedir).mockReturnValue('/nonexistent/home');
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(readFileSync).mockImplementation(() => { throw new Error('ENOENT'); });
+    vi.mocked(readdirSync).mockReturnValue([]);
+    vi.mocked(statSync).mockImplementation(() => { throw new Error('ENOENT'); });
+    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('ENOENT'); });
+});
+describe('Graceful degradation: all adapters return null on errors', () => {
+    for (const { name, adapter } of adapters) {
+        describe(`${name} adapter`, () => {
+            it('readUsageStats returns null when homedir points to nonexistent path', async () => {
+                vi.mocked(homedir).mockReturnValue('/totally/nonexistent/path');
+                vi.mocked(existsSync).mockReturnValue(false);
+                const result = await adapter.readUsageStats(null);
+                expect(result).toBeNull();
+            });
+            it('readUsageStats returns null when existsSync throws', async () => {
+                vi.mocked(existsSync).mockImplementation(() => {
+                    throw new Error('Unexpected filesystem error');
+                });
+                const result = await adapter.readUsageStats(null);
+                expect(result).toBeNull();
+            });
+            it('readUsageStats returns null when readFileSync throws EACCES', async () => {
+                vi.mocked(existsSync).mockReturnValue(true);
+                vi.mocked(readFileSync).mockImplementation(() => {
+                    const err = new Error('EACCES: permission denied');
+                    err.code = 'EACCES';
+                    throw err;
+                });
+                vi.mocked(readdirSync).mockImplementation(() => {
+                    const err = new Error('EACCES: permission denied');
+                    err.code = 'EACCES';
+                    throw err;
+                });
+                const result = await adapter.readUsageStats(null);
+                expect(result).toBeNull();
+            });
+            it('readUsageStats never throws even on unexpected errors', async () => {
+                vi.mocked(existsSync).mockImplementation(() => {
+                    throw new TypeError('Cannot read properties of undefined');
+                });
+                // Must not throw, must return null
+                await expect(adapter.readUsageStats(null)).resolves.toBeNull();
+            });
+            if (adapter.readVersion) {
+                it('readVersion returns null when command/file not found', async () => {
+                    vi.mocked(execFileSync).mockImplementation(() => {
+                        throw new Error('ENOENT: command not found');
+                    });
+                    vi.mocked(existsSync).mockReturnValue(false);
+                    const result = await adapter.readVersion();
+                    expect(result).toBeNull();
+                });
+            }
+        });
+    }
+    // Claude Code is the only adapter with readSkillUsage
+    describe('claude-code readSkillUsage', () => {
+        const ccAdapter = new ClaudeCodeAdapter();
+        it('readSkillUsage returns null when skills dir does not exist', async () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+            const result = await ccAdapter.readSkillUsage(null);
+            expect(result).toBeNull();
+        });
+        it('readSkillUsage returns null when readdirSync throws', async () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readdirSync).mockImplementation(() => {
+                throw new Error('EACCES: permission denied');
+            });
+            const result = await ccAdapter.readSkillUsage(null);
+            expect(result).toBeNull();
+        });
+        it('readSkillUsage never throws even on unexpected errors', async () => {
+            vi.mocked(existsSync).mockImplementation(() => {
+                throw new TypeError('Unexpected error');
+            });
+            await expect(ccAdapter.readSkillUsage(null)).resolves.toBeNull();
+        });
+    });
+});

package/dist/agents/__tests__/instruction-hint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agents/__tests__/instruction-hint.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeHintToFile } from '../utils/instruction-hint.js';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+let testDir;
+beforeEach(() => {
+    testDir = join(tmpdir(), `runwork-hint-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testDir, { recursive: true });
+});
+afterEach(() => {
+    // Clean up
+    try {
+        const { rmSync } = require('fs');
+        rmSync(testDir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+});
+describe('writeHintToFile', () => {
+    it('creates new file with hint', () => {
+        const filePath = join(testDir, 'CLAUDE.md');
+        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nHello\n<!-- runwork:end -->');
+        const content = readFileSync(filePath, 'utf-8');
+        expect(content).toContain('## Runwork');
+        expect(content).toContain('Hello');
+    });
+    it('appends to existing file', () => {
+        const filePath = join(testDir, 'CLAUDE.md');
+        writeFileSync(filePath, '# My Instructions\n\nDo stuff.\n');
+        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nHello\n<!-- runwork:end -->');
+        const content = readFileSync(filePath, 'utf-8');
+        expect(content).toContain('# My Instructions');
+        expect(content).toContain('Do stuff.');
+        expect(content).toContain('## Runwork');
+        expect(content).toContain('Hello');
+    });
+    it('replaces existing runwork section', () => {
+        const filePath = join(testDir, 'CLAUDE.md');
+        writeFileSync(filePath, [
+            '# My Instructions',
+            '',
+            '<!-- runwork:start -->',
+            '## Runwork',
+            'Old content',
+            '<!-- runwork:end -->',
+            '',
+            '# Other stuff',
+        ].join('\n'));
+        writeHintToFile(filePath, '<!-- runwork:start -->\n## Runwork\nNew content\n<!-- runwork:end -->');
+        const content = readFileSync(filePath, 'utf-8');
+        expect(content).toContain('New content');
+        expect(content).not.toContain('Old content');
+        expect(content).toContain('# My Instructions');
+        expect(content).toContain('# Other stuff');
+    });
+    it('creates parent directories', () => {
+        const filePath = join(testDir, 'nested', 'dir', 'CLAUDE.md');
+        writeHintToFile(filePath, '<!-- runwork:start -->\nTest\n<!-- runwork:end -->');
+        expect(existsSync(filePath)).toBe(true);
+        expect(readFileSync(filePath, 'utf-8')).toContain('Test');
+    });
+    it('preserves content before and after markers', () => {
+        const filePath = join(testDir, 'CLAUDE.md');
+        writeFileSync(filePath, 'BEFORE\n<!-- runwork:start -->\nold\n<!-- runwork:end -->\nAFTER');
+        writeHintToFile(filePath, '<!-- runwork:start -->\nnew\n<!-- runwork:end -->');
+        const content = readFileSync(filePath, 'utf-8');
+        expect(content).toBe('BEFORE\n<!-- runwork:start -->\nnew\n<!-- runwork:end -->\nAFTER');
+    });
+});

package/dist/agents/__tests__/intro-skill.test.d.ts

@@ -0,0 +1 @@
+export {};