@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

package/dist/src/util/project-context.js

@@ -0,0 +1,105 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { isFileNotFoundError } from './fs-helpers.js';
+/**
+ * Recursively discover all project-level Claude files:
+ *   - every `CLAUDE.md` found anywhere in the repo tree
+ *   - every file under `.claude/` recursively
+ *
+ * Returns a de-duplicated, deterministically sorted array of
+ * { relativePath, content } entries. Empty/blank files are skipped.
+ */
+export async function discoverProjectClaudeFiles(cwd) {
+    const seen = new Set();
+    const results = [];
+    // 1. Walk the entire tree for CLAUDE.md files.
+    await walkForClaudeMd(cwd, cwd, seen, results);
+    // 2. Walk .claude/ recursively for any file.
+    await walkDotClaudeDir(cwd, seen, results);
+    // Deterministic: sort by relativePath (lexicographic).
+    results.sort((a, b) => a.relativePath < b.relativePath ? -1 : a.relativePath > b.relativePath ? 1 : 0);
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/** Recursively walk `dir` looking for files named `CLAUDE.md`. */
+async function walkForClaudeMd(root, dir, seen, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return;
+        throw err;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip node_modules, .git, and hidden dirs other than .claude
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            await walkForClaudeMd(root, fullPath, seen, out);
+        }
+        else if (entry.name === 'CLAUDE.md') {
+            const rel = toForwardSlash(relative(root, fullPath));
+            if (seen.has(rel))
+                continue;
+            const content = await tryReadText(fullPath);
+            if (content !== null) {
+                seen.add(rel);
+                out.push({ relativePath: rel, content });
+            }
+        }
+    }
+}
+/** Recursively walk `.claude/` and collect every file. */
+async function walkDotClaudeDir(root, seen, out) {
+    const dotClaudeDir = join(root, '.claude');
+    await walkAllFiles(root, dotClaudeDir, seen, out);
+}
+/** Recursively collect all files under `dir`. */
+async function walkAllFiles(root, dir, seen, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return;
+        throw err;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkAllFiles(root, fullPath, seen, out);
+        }
+        else if (entry.isFile()) {
+            const rel = toForwardSlash(relative(root, fullPath));
+            if (seen.has(rel))
+                continue;
+            const content = await tryReadText(fullPath);
+            if (content !== null) {
+                seen.add(rel);
+                out.push({ relativePath: rel, content });
+            }
+        }
+    }
+}
+/** Read a file as UTF-8, returning trimmed content or null if empty/missing. */
+async function tryReadText(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const trimmed = raw.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return null;
+        throw err;
+    }
+}
+function toForwardSlash(p) {
+    return p.replace(/\\/g, '/');
+}

package/dist/src/util/transcript-append.d.ts

@@ -0,0 +1,7 @@
+import type { ClaudeSessionEvent } from '../types/contracts.js';
+export declare function stripTrailingPartials(events: ClaudeSessionEvent[]): ClaudeSessionEvent[];
+/**
+ * Append transcript events for run-state persistence: at most one trailing
+ * `partial`, dropped whenever a non-partial event is appended.
+ */
+export declare function appendTranscriptEvents(events: ClaudeSessionEvent[], incoming: ClaudeSessionEvent[]): ClaudeSessionEvent[];

package/dist/src/util/transcript-append.js

@@ -0,0 +1,29 @@
+export function stripTrailingPartials(events) {
+    let end = events.length;
+    while (end > 0 && events[end - 1].type === 'partial') {
+        end -= 1;
+    }
+    return end === events.length ? events : events.slice(0, end);
+}
+/**
+ * Append transcript events for run-state persistence: at most one trailing
+ * `partial`, dropped whenever a non-partial event is appended.
+ */
+export function appendTranscriptEvents(events, incoming) {
+    let next = events;
+    for (const event of incoming) {
+        if (event.type === 'partial') {
+            if (next.length > 0 && next[next.length - 1].type === 'partial') {
+                next = [...next.slice(0, -1), event];
+            }
+            else {
+                next = [...next, event];
+            }
+        }
+        else {
+            next = stripTrailingPartials(next);
+            next = [...next, event];
+        }
+    }
+    return next;
+}

package/dist/test/claude-agent-sdk-adapter.test.d.ts

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

package/dist/test/claude-agent-sdk-adapter.test.js

@@ -0,0 +1,459 @@
+import { describe, expect, it } from 'vitest';
+import { ClaudeAgentSdkAdapter } from '../src/claude/claude-agent-sdk-adapter.js';
+function createFakeQuery(messages) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            for (const message of messages) {
+                yield message;
+            }
+        },
+        close() {
+            return undefined;
+        },
+        supportedCommands: async () => [
+            {
+                name: 'review',
+                description: 'Review changes',
+                argumentHint: '<path>',
+            },
+        ],
+        supportedAgents: async () => [
+            {
+                name: 'researcher',
+                description: 'Looks around the repo',
+                model: 'claude-sonnet-4-5',
+            },
+        ],
+        supportedModels: async () => [{ value: 'claude-sonnet-4-5' }],
+    };
+}
+describe('ClaudeAgentSdkAdapter', () => {
+    it('normalizes streamed Claude session events', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_123' },
+                {
+                    type: 'assistant',
+                    session_id: 'ses_123',
+                    message: {
+                        content: [{ type: 'text', text: 'Working through the task.' }],
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_123',
+                    is_error: false,
+                    result: 'Done.',
+                    num_turns: 2,
+                    total_cost_usd: 0.42,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+            includePartialMessages: true,
+        });
+        expect(result.sessionId).toBe('ses_123');
+        expect(result.finalText).toBe('Done.');
+        expect(result.events.map((event) => event.type)).toEqual(['init', 'assistant', 'result']);
+    });
+    it('splits assistant turns into text and tool_call events', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_tool' },
+                {
+                    type: 'assistant',
+                    session_id: 'ses_tool',
+                    message: {
+                        content: [
+                            { type: 'text', text: 'Searching.' },
+                            {
+                                type: 'tool_use',
+                                name: 'Grep',
+                                id: 'toolu_1',
+                                input: { pattern: 'foo', path: '.' },
+                            },
+                        ],
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_tool',
+                    is_error: false,
+                    result: 'Found.',
+                    num_turns: 1,
+                    total_cost_usd: 0.02,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Search',
+            includePartialMessages: true,
+        });
+        expect(result.events.map((e) => e.type)).toEqual(['init', 'assistant', 'tool_call', 'result']);
+        expect(result.events[2]).toMatchObject({ type: 'tool_call' });
+        expect(result.events[2]?.text).toContain('Grep');
+        expect(result.events[2]?.text).toContain('toolu_1');
+    });
+    it('emits user messages with tool_result content', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_u' },
+                {
+                    type: 'user',
+                    session_id: 'ses_u',
+                    parent_tool_use_id: null,
+                    message: {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: 'toolu_1',
+                                content: 'file.ts:42: match',
+                            },
+                        ],
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_u',
+                    is_error: false,
+                    result: 'OK',
+                    num_turns: 1,
+                    total_cost_usd: 0,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Run',
+            includePartialMessages: true,
+        });
+        expect(result.events.map((e) => e.type)).toEqual(['init', 'user', 'result']);
+        expect(result.events[1]?.text).toContain('tool_result:toolu_1');
+        expect(result.events[1]?.text).toContain('file.ts');
+    });
+    it('drops stream_event payloads when includePartialMessages is false', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_123' },
+                {
+                    type: 'stream_event',
+                    session_id: 'ses_123',
+                    event: {
+                        type: 'content_block_delta',
+                        delta: { text: 'Partial output' },
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_123',
+                    is_error: false,
+                    result: 'Done.',
+                    num_turns: 1,
+                    total_cost_usd: 0.01,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+            includePartialMessages: false,
+        });
+        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
+    });
+    it('collapses partials and drops them before the final result', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_123' },
+                {
+                    type: 'stream_event',
+                    session_id: 'ses_123',
+                    event: {
+                        type: 'content_block_delta',
+                        delta: { text: 'Partial ' },
+                    },
+                },
+                {
+                    type: 'stream_event',
+                    session_id: 'ses_123',
+                    event: {
+                        type: 'content_block_delta',
+                        delta: { text: 'output' },
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_123',
+                    is_error: false,
+                    result: 'Done.',
+                    num_turns: 1,
+                    total_cost_usd: 0.01,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+            includePartialMessages: true,
+        });
+        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
+    });
+    it('ignores structural stream events without text payloads', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_123' },
+                {
+                    type: 'stream_event',
+                    session_id: 'ses_123',
+                    event: { type: 'message_start' },
+                },
+                {
+                    type: 'stream_event',
+                    session_id: 'ses_123',
+                    event: {
+                        type: 'content_block_delta',
+                        delta: { text: 'Partial output' },
+                    },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_123',
+                    is_error: false,
+                    result: 'Done.',
+                    num_turns: 1,
+                    total_cost_usd: 0.01,
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+            includePartialMessages: true,
+        });
+        expect(result.events.map((event) => event.type)).toEqual(['init', 'result']);
+    });
+    it('probes supported commands, agents, and models', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const capabilities = await adapter.probeCapabilities('/tmp/project');
+        expect(capabilities.commands[0]).toMatchObject({ name: 'review' });
+        expect(capabilities.agents[0]).toMatchObject({ name: 'researcher' });
+        expect(capabilities.models).toEqual(['claude-sonnet-4-5']);
+    });
+    it('defaults permissionMode to acceptEdits when omitted', async () => {
+        let capturedPermissionMode;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedPermissionMode = params.options?.permissionMode;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_pm',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+        });
+        expect(capturedPermissionMode).toBe('acceptEdits');
+    });
+    it('merges Skill into allowedTools for SDK Agent Skills', async () => {
+        let capturedAllowed;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedAllowed = params.options?.allowedTools;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_skill',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Use a skill',
+        });
+        expect(capturedAllowed).toEqual(['Skill']);
+    });
+    it('appends Skill once when allowedTools is provided', async () => {
+        let capturedAllowed;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedAllowed = params.options?.allowedTools;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_skill',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'x',
+            allowedTools: ['Read', 'Grep'],
+        });
+        expect(capturedAllowed).toEqual(['Read', 'Grep', 'Skill']);
+    });
+    it('does not add Skill when Skill is disallowed', async () => {
+        let capturedAllowed;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedAllowed = params.options?.allowedTools;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_skill',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'x',
+            disallowedTools: ['Skill'],
+        });
+        expect(capturedAllowed).toBeUndefined();
+    });
+    it('extracts full usage from result with camelCase modelUsage', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                { type: 'system', subtype: 'init', session_id: 'ses_usage' },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_usage',
+                    is_error: false,
+                    result: 'Done.',
+                    num_turns: 5,
+                    total_cost_usd: 1.23,
+                    usage: { input_tokens: 50_000, output_tokens: 8_000 },
+                    modelUsage: {
+                        'claude-opus-4-6': { contextWindow: 200_000 },
+                    },
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do work',
+        });
+        expect(result.turns).toBe(5);
+        expect(result.totalCostUsd).toBe(1.23);
+        expect(result.inputTokens).toBe(50_000);
+        expect(result.outputTokens).toBe(8_000);
+        expect(result.contextWindowSize).toBe(200_000);
+    });
+    it('extracts usage from snake_case model_usage fallback', async () => {
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: () => createFakeQuery([
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    session_id: 'ses_snake',
+                    is_error: false,
+                    result: 'Ok.',
+                    num_turns: 1,
+                    total_cost_usd: 0.01,
+                    usage: { input_tokens: 1000, output_tokens: 200 },
+                    model_usage: {
+                        'claude-sonnet-4-5': { context_window: 180_000 },
+                    },
+                },
+            ]),
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        const result = await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'x',
+        });
+        expect(result.inputTokens).toBe(1000);
+        expect(result.outputTokens).toBe(200);
+        expect(result.contextWindowSize).toBe(180_000);
+    });
+    it('passes through explicit permissionMode', async () => {
+        let capturedPermissionMode;
+        const adapter = new ClaudeAgentSdkAdapter({
+            query: (params) => {
+                capturedPermissionMode = params.options?.permissionMode;
+                return createFakeQuery([
+                    {
+                        type: 'result',
+                        subtype: 'success',
+                        session_id: 'ses_pm',
+                        is_error: false,
+                        result: 'ok',
+                        num_turns: 1,
+                        total_cost_usd: 0,
+                    },
+                ]);
+            },
+            listSessions: async () => [],
+            getSessionMessages: async () => [],
+        });
+        await adapter.runSession({
+            cwd: '/tmp/project',
+            prompt: 'Do the thing',
+            permissionMode: 'plan',
+        });
+        expect(capturedPermissionMode).toBe('plan');
+    });
+});

package/dist/test/claude-manager.plugin.test.d.ts

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