@doingdev/opencode-claude-manager-plugin 0.1.9 → 0.1.11

package/README.md

@@ -4,13 +4,13 @@ This package provides an OpenCode plugin that lets an OpenCode-side manager agen
 
 ## Overview
 
-Use this when you want OpenCode to act as a manager over Claude Code instead of talking to Claude directly. The plugin gives OpenCode a stable tool surface for discovering Claude metadata, delegating work to Claude sessions, splitting tasks into subagents, and coordinating optional git worktrees.
+Use this when you want OpenCode to act as a manager over Claude Code instead of talking to Claude directly. The plugin gives OpenCode a stable tool surface for discovering Claude metadata, delegating work to Claude sessions, and splitting tasks into subagents (all using the same working directory).
 
 ## Features
 
 - Runs Claude Code tasks from OpenCode through `@anthropic-ai/claude-agent-sdk`.
 - Discovers repo-local Claude metadata from `.claude/skills`, `.claude/commands`, `CLAUDE.md`, and settings hooks.
-- Splits multi-step tasks into subagents, optionally assigning dedicated git worktrees.
+- Splits multi-step tasks into subagents that run sequentially in the same repository directory.
 - Persists manager runs under `.claude-manager/runs` so sessions can be inspected later.
 - Exposes manager-facing tools instead of relying on undocumented plugin-defined slash commands.
 
@@ -19,21 +19,20 @@ Use this when you want OpenCode to act as a manager over Claude Code instead of
 - Node `22+`
 - OpenCode with plugin loading enabled
 - Access to Claude Code / Claude Agent SDK on the machine where OpenCode is running
-- A git repository if you want automatic worktree allocation
 
 ## Installation
 
-Install from npm:
+Install from the npm registry:
 
 ```bash
-npm install @doingdev/opencode-claude-manager-plugin
+pnpm add @doingdev/opencode-claude-manager-plugin
 ```
 
 Or for local development in this repo:
 
 ```bash
-npm install
-npm run build
+pnpm install
+pnpm run build
 ```
 
 ## OpenCode Config
@@ -50,11 +49,10 @@ If you are testing locally, point OpenCode at the local package or plugin file u
 
 ## OpenCode tools
 
-- `claude_manager_run` - run a task through Claude with optional splitting and worktrees; returns a compact output summary and a `runId` for deeper inspection
+- `claude_manager_run` - run a task through Claude with optional splitting into subagents; returns a compact output summary and a `runId` for deeper inspection
 - `claude_manager_metadata` - inspect available Claude commands, skills, hooks, and settings
 - `claude_manager_sessions` - list Claude sessions or inspect a saved transcript
 - `claude_manager_runs` - inspect persisted manager run records
-- `claude_manager_cleanup_run` - explicitly remove worktrees created for a prior manager run
 
 ## Plugin-provided agents and commands
 
@@ -77,7 +75,7 @@ Typical flow inside OpenCode:
 Example task:
 
 ```text
-Use claude_manager_run to split this implementation into subagents, use worktrees, and summarize the final result.
+Use claude_manager_run to split this implementation into subagents and summarize the final result.
 ```
 
 ## Local Development
@@ -85,11 +83,11 @@ Use claude_manager_run to split this implementation into subagents, use worktree
 Clone the repo and run:
 
 ```bash
-npm install
-npm run lint
-npm run typecheck
-npm run test
-npm run build
+pnpm install
+pnpm run lint
+pnpm run typecheck
+pnpm run test
+pnpm run build
 ```
 
 The compiled plugin output is written to `dist/`.
@@ -119,13 +117,13 @@ Notes for trusted publishing:
 Release flow:
 
 ```bash
-npm login
-npm whoami
-npm version patch
-npm run lint
-npm run typecheck
-npm run test
-npm run build
+pnpm login
+pnpm whoami
+pnpm version patch
+pnpm run lint
+pnpm run typecheck
+pnpm run test
+pnpm run build
 ```
 
 Then publish from GitHub by either:
@@ -138,14 +136,13 @@ After trusted publishing is working, you can tighten npm package security by dis
 ## Limitations
 
 - Claude slash commands and skills come primarily from filesystem discovery; SDK probing is available but optional.
-- Worktree creation only activates when the current directory is a git repo and multiple subtasks are planned.
-- Worktrees are preserved by default so you can inspect changes; clean them up explicitly with `claude_manager_cleanup_run`.
+- Multiple subagents share one working directory and run one after another to avoid overlapping edits.
 - Run state is local to the repo under `.claude-manager/` and is ignored by git.
 
 ## Scripts
 
-- `npm run build`
-- `npm run typecheck`
-- `npm run lint`
-- `npm run format`
-- `npm run test`
+- `pnpm run build`
+- `pnpm run typecheck`
+- `pnpm run lint`
+- `pnpm run format`
+- `pnpm run test`

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

@@ -1,39 +1,59 @@
 import { getSessionMessages, listSessions, query, } from '@anthropic-ai/claude-agent-sdk';
+import { appendTranscriptEvents } from '../util/transcript-append.js';
 const defaultFacade = {
     query,
     listSessions,
     getSessionMessages,
 };
+const TOOL_INPUT_PREVIEW_MAX = 2000;
+const USER_MESSAGE_MAX = 4000;
 export class ClaudeAgentSdkAdapter {
     sdkFacade;
     constructor(sdkFacade = defaultFacade) {
         this.sdkFacade = sdkFacade;
     }
     async runSession(input, onEvent) {
+        const options = this.buildOptions(input);
+        const includePartials = options.includePartialMessages === true;
         const sessionQuery = this.sdkFacade.query({
             prompt: input.prompt,
-            options: this.buildOptions(input),
+            options,
         });
-        const events = [];
+        let events = [];
         let finalText = '';
         let sessionId;
         let turns;
         let totalCostUsd;
+        let inputTokens;
+        let outputTokens;
+        let contextWindowSize;
         try {
             for await (const message of sessionQuery) {
-                const event = normalizeSdkMessage(message);
-                if (!event) {
-                    continue;
+                const batch = normalizeSdkMessages(message, includePartials);
+                for (const event of batch) {
+                    sessionId ??= event.sessionId;
+                    if (event.type === 'result') {
+                        finalText = event.text;
+                        turns = event.turns;
+                        totalCostUsd = event.totalCostUsd;
+                    }
+                    events = appendTranscriptEvents(events, [event]);
+                    if (onEvent) {
+                        await onEvent(event);
+                    }
                 }
-                sessionId ??= event.sessionId;
-                if (event.type === 'result') {
-                    finalText = event.text;
-                    turns = event.turns;
-                    totalCostUsd = event.totalCostUsd;
-                }
-                events.push(event);
-                if (onEvent) {
-                    await onEvent(event);
+                // Extract usage data from result messages
+                if (message.type === 'result') {
+                    const usage = extractUsageFromResult(message);
+                    if (usage.inputTokens !== undefined) {
+                        inputTokens = usage.inputTokens;
+                    }
+                    if (usage.outputTokens !== undefined) {
+                        outputTokens = usage.outputTokens;
+                    }
+                    if (usage.contextWindowSize !== undefined) {
+                        contextWindowSize = usage.contextWindowSize;
+                    }
                 }
             }
         }
@@ -46,6 +66,9 @@ export class ClaudeAgentSdkAdapter {
             finalText,
             turns,
             totalCostUsd,
+            inputTokens,
+            outputTokens,
+            contextWindowSize,
         };
     }
     async listSavedSessions(cwd) {
@@ -110,7 +133,7 @@ export class ClaudeAgentSdkAdapter {
             settingSources: input.settingSources,
             maxTurns: input.maxTurns,
             model: input.model,
-            permissionMode: input.permissionMode,
+            permissionMode: input.permissionMode ?? 'acceptEdits',
             systemPrompt: input.systemPrompt
                 ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
                 : { type: 'preset', preset: 'claude_code' },
@@ -125,73 +148,210 @@ export class ClaudeAgentSdkAdapter {
         return options;
     }
 }
-function normalizeSdkMessage(message) {
+function normalizeSdkMessages(message, includePartials) {
     const sessionId = 'session_id' in message ? message.session_id : undefined;
     if (message.type === 'assistant') {
-        return {
-            type: 'assistant',
-            sessionId,
-            text: extractText(message.message),
-            rawType: message.type,
-        };
+        return normalizeAssistantSdkMessage(message, sessionId);
     }
     if (message.type === 'stream_event') {
+        if (!includePartials) {
+            return [];
+        }
         const partialText = extractPartialEventText(message.event);
         if (!partialText) {
-            return null;
+            return [];
         }
-        return {
-            type: 'partial',
-            sessionId,
-            text: partialText,
-            rawType: message.type,
-        };
+        return [
+            {
+                type: 'partial',
+                sessionId,
+                text: partialText,
+                rawType: message.type,
+            },
+        ];
     }
     if (message.type === 'result') {
-        return {
-            type: message.is_error ? 'error' : 'result',
-            sessionId,
-            text: message.subtype === 'success'
-                ? message.result
-                : message.errors.join('\n') || message.subtype,
-            turns: message.num_turns,
-            totalCostUsd: message.total_cost_usd,
-            rawType: `${message.type}:${message.subtype}`,
-        };
+        return [
+            {
+                type: message.is_error ? 'error' : 'result',
+                sessionId,
+                text: message.subtype === 'success'
+                    ? message.result
+                    : message.errors.join('\n') || message.subtype,
+                turns: message.num_turns,
+                totalCostUsd: message.total_cost_usd,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
     }
     if (message.type === 'system') {
-        return {
-            type: message.subtype === 'init' ? 'init' : 'system',
-            sessionId,
-            text: message.subtype,
-            rawType: `${message.type}:${message.subtype}`,
-        };
+        return [
+            {
+                type: message.subtype === 'init' ? 'init' : 'system',
+                sessionId,
+                text: message.subtype,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
     }
     if (message.type === 'auth_status') {
-        return {
-            type: 'system',
-            sessionId,
-            text: message.output.join('\n') || 'auth_status',
-            rawType: message.type,
-        };
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.output.join('\n') || 'auth_status',
+                rawType: message.type,
+            },
+        ];
     }
     if (message.type === 'prompt_suggestion') {
-        return {
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.suggestion,
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'user') {
+        return normalizeUserSdkMessage(message, sessionId);
+    }
+    return [
+        {
             type: 'system',
             sessionId,
-            text: message.suggestion,
+            text: message.type,
             rawType: message.type,
-        };
-    }
-    if (message.type === 'user') {
-        return null;
+        },
+    ];
+}
+function normalizeAssistantSdkMessage(message, sessionId) {
+    const raw = message.message;
+    if (!isRecord(raw) || !Array.isArray(raw.content)) {
+        const text = extractText(raw);
+        return text.trim()
+            ? [
+                {
+                    type: 'assistant',
+                    sessionId,
+                    text,
+                    rawType: 'assistant',
+                },
+            ]
+            : [];
     }
-    return {
-        type: 'system',
-        sessionId,
-        text: message.type,
-        rawType: message.type,
+    const out = [];
+    let textBuffer = '';
+    const flushText = () => {
+        if (textBuffer.trim()) {
+            out.push({
+                type: 'assistant',
+                sessionId,
+                text: textBuffer,
+                rawType: 'assistant',
+            });
+        }
+        textBuffer = '';
     };
+    for (const block of raw.content) {
+        if (!isRecord(block)) {
+            continue;
+        }
+        if (block.type === 'text' && typeof block.text === 'string') {
+            textBuffer += block.text;
+        }
+        else if (block.type === 'tool_use' && typeof block.name === 'string') {
+            flushText();
+            const id = typeof block.id === 'string' ? block.id : '';
+            const preview = truncateJsonish(block.input, TOOL_INPUT_PREVIEW_MAX);
+            out.push({
+                type: 'tool_call',
+                sessionId,
+                text: JSON.stringify({
+                    name: block.name,
+                    id,
+                    input: preview,
+                }),
+                rawType: 'assistant:tool_use',
+            });
+        }
+    }
+    flushText();
+    return out;
+}
+function normalizeUserSdkMessage(message, sessionId) {
+    let payload = serializeUserMessageContent(message.message);
+    if (message.tool_use_result !== undefined) {
+        const extra = truncateJsonish(message.tool_use_result, 1500);
+        if (extra) {
+            payload = payload
+                ? `${payload}\n[tool_use_result] ${extra}`
+                : `[tool_use_result] ${extra}`;
+        }
+    }
+    payload = truncateString(payload, USER_MESSAGE_MAX);
+    if (!payload.trim()) {
+        return [];
+    }
+    return [
+        {
+            type: 'user',
+            sessionId,
+            text: payload,
+            rawType: 'user',
+        },
+    ];
+}
+function serializeUserMessageContent(message) {
+    if (typeof message === 'string') {
+        return message;
+    }
+    if (!isRecord(message)) {
+        return '';
+    }
+    const content = message.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return truncateJsonish(message, USER_MESSAGE_MAX);
+    }
+    const lines = [];
+    for (const part of content) {
+        if (!isRecord(part)) {
+            continue;
+        }
+        if (part.type === 'text' && typeof part.text === 'string') {
+            lines.push(part.text);
+        }
+        else if (part.type === 'tool_result') {
+            const id = typeof part.tool_use_id === 'string' ? part.tool_use_id : '';
+            const body = truncateJsonish(part.content, TOOL_INPUT_PREVIEW_MAX);
+            lines.push(`[tool_result:${id}] ${body}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function truncateJsonish(value, max) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return truncateString(value, max);
+    }
+    try {
+        return truncateString(JSON.stringify(value), max);
+    }
+    catch {
+        return truncateString(String(value), max);
+    }
+}
+function truncateString(s, max) {
+    if (s.length <= max) {
+        return s;
+    }
+    return s.slice(0, max);
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -257,3 +417,30 @@ function mapAgent(agent) {
         source: 'sdk',
     };
 }
+function extractUsageFromResult(message) {
+    if (message.type !== 'result') {
+        return {};
+    }
+    const result = {};
+    // Extract from usage field
+    const usage = message.usage;
+    if (isRecord(usage)) {
+        if (typeof usage.input_tokens === 'number') {
+            result.inputTokens = usage.input_tokens;
+        }
+        if (typeof usage.output_tokens === 'number') {
+            result.outputTokens = usage.output_tokens;
+        }
+    }
+    // Extract contextWindow from modelUsage
+    const modelUsage = message.model_usage;
+    if (isRecord(modelUsage)) {
+        for (const model of Object.values(modelUsage)) {
+            if (isRecord(model) && typeof model.context_window === 'number') {
+                result.contextWindowSize = model.context_window;
+                break;
+            }
+        }
+    }
+    return result;
+}

package/dist/claude/delegated-can-use-tool.d.ts

@@ -0,0 +1,7 @@
+import type { CanUseTool } from '@anthropic-ai/claude-agent-sdk';
+import type { DelegatedToolPermissionPolicy } from '../types/contracts.js';
+export type DelegatedCanUseToolOptions = {
+    /** Override TTY detection (for tests or custom hosts). */
+    isInteractiveTerminal?: () => boolean;
+};
+export declare function createDelegatedCanUseTool(policy: DelegatedToolPermissionPolicy, factoryOptions?: DelegatedCanUseToolOptions): CanUseTool;

package/dist/claude/delegated-can-use-tool.js

@@ -0,0 +1,178 @@
+import { createInterface } from 'node:readline/promises';
+function defaultIsInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function formatToolRequest(toolName, input, meta) {
+    const headline = meta.title?.trim() ||
+        [meta.displayName, toolName].filter(Boolean).join(': ') ||
+        toolName;
+    const lines = [headline];
+    if (meta.description?.trim()) {
+        lines.push(meta.description.trim());
+    }
+    if (meta.decisionReason?.trim()) {
+        lines.push(`Reason: ${meta.decisionReason.trim()}`);
+    }
+    if (toolName === 'Bash' && typeof input.command === 'string') {
+        lines.push(`Command: ${input.command}`);
+        if (typeof input.description === 'string' && input.description) {
+            lines.push(`Intent: ${input.description}`);
+        }
+    }
+    else if (toolName !== 'AskUserQuestion') {
+        lines.push(`Input: ${JSON.stringify(input, null, 2)}`);
+    }
+    return lines.join('\n');
+}
+function applyDefaultAskUserAnswers(input) {
+    const rawQuestions = input.questions;
+    if (!Array.isArray(rawQuestions)) {
+        return input;
+    }
+    const answers = {};
+    for (const entry of rawQuestions) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const questionText = entry.question;
+        if (typeof questionText !== 'string') {
+            continue;
+        }
+        const options = entry.options;
+        if (!Array.isArray(options) || options.length === 0) {
+            continue;
+        }
+        const first = options[0];
+        if (isRecord(first) && typeof first.label === 'string') {
+            answers[questionText] = first.label;
+        }
+    }
+    return {
+        ...input,
+        questions: rawQuestions,
+        answers,
+    };
+}
+async function promptLine(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function handleAskUserQuestionInteractive(input, toolUseID) {
+    const rawQuestions = input.questions;
+    if (!Array.isArray(rawQuestions)) {
+        return {
+            behavior: 'deny',
+            message: 'AskUserQuestion invoked without a questions array; cannot collect answers interactively.',
+            toolUseID,
+        };
+    }
+    const answers = {};
+    for (const entry of rawQuestions) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const questionText = entry.question;
+        const header = entry.header;
+        if (typeof questionText !== 'string') {
+            continue;
+        }
+        const label = typeof header === 'string' && header.trim()
+            ? `${header.trim()}: ${questionText}`
+            : questionText;
+        const options = entry.options;
+        if (!Array.isArray(options) || options.length === 0) {
+            return {
+                behavior: 'deny',
+                message: `Question "${questionText}" has no options to choose from.`,
+                toolUseID,
+            };
+        }
+        process.stdout.write(`\n${label}\n`);
+        for (const [index, opt] of options.entries()) {
+            if (isRecord(opt) && typeof opt.label === 'string') {
+                const desc = typeof opt.description === 'string' ? ` — ${opt.description}` : '';
+                process.stdout.write(`  ${index + 1}. ${opt.label}${desc}\n`);
+            }
+        }
+        const multi = entry.multiSelect === true
+            ? ' (numbers separated by commas, or type your own answer)'
+            : ' (number, or type your own answer)';
+        const response = await promptLine(`Your choice${multi}: `);
+        const parsed = parseChoiceResponse(response, options);
+        answers[questionText] = parsed;
+    }
+    return {
+        behavior: 'allow',
+        updatedInput: {
+            ...input,
+            questions: rawQuestions,
+            answers,
+        },
+        toolUseID,
+    };
+}
+function parseChoiceResponse(response, options) {
+    const indices = response
+        .split(',')
+        .map((part) => Number.parseInt(part.trim(), 10) - 1)
+        .filter((index) => Number.isFinite(index));
+    const labels = indices
+        .filter((index) => index >= 0 && index < options.length)
+        .map((index) => {
+        const opt = options[index];
+        if (isRecord(opt) && typeof opt.label === 'string') {
+            return opt.label;
+        }
+        return '';
+    })
+        .filter(Boolean);
+    return labels.length > 0 ? labels.join(', ') : response;
+}
+export function createDelegatedCanUseTool(policy, factoryOptions) {
+    const isInteractiveTerminal = factoryOptions?.isInteractiveTerminal ?? defaultIsInteractiveTerminal;
+    return async (toolName, input, options) => {
+        const usePrompt = policy === 'prompt_if_tty' && isInteractiveTerminal();
+        if (toolName === 'AskUserQuestion') {
+            if (usePrompt) {
+                return handleAskUserQuestionInteractive(input, options.toolUseID);
+            }
+            return {
+                behavior: 'allow',
+                updatedInput: applyDefaultAskUserAnswers(input),
+                toolUseID: options.toolUseID,
+            };
+        }
+        if (policy === 'allow_all' || !usePrompt) {
+            return {
+                behavior: 'allow',
+                updatedInput: input,
+                toolUseID: options.toolUseID,
+            };
+        }
+        const summary = formatToolRequest(toolName, input, options);
+        const answer = await promptLine(`${summary}\nAllow this action? [y/N] `);
+        if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+            return {
+                behavior: 'allow',
+                updatedInput: input,
+                toolUseID: options.toolUseID,
+            };
+        }
+        return {
+            behavior: 'deny',
+            message: 'User denied this tool action in the delegated Claude Code session (TTY prompt).',
+            toolUseID: options.toolUseID,
+        };
+    };
+}