@doingdev/opencode-claude-manager-plugin 0.1.19 → 0.1.21

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

@@ -1,27 +0,0 @@
-import { type Options, type Query, type SDKSessionInfo, type SessionMessage, type SettingSource } from '@anthropic-ai/claude-agent-sdk';
-import type { ClaudeCapabilitySnapshot, ClaudeSessionEvent, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
-import type { ToolApprovalManager } from './tool-approval-manager.js';
-export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
-interface ClaudeAgentSdkFacade {
-    query(params: {
-        prompt: string;
-        options?: Options;
-    }): Query;
-    listSessions(options?: {
-        dir?: string;
-    }): Promise<SDKSessionInfo[]>;
-    getSessionMessages(sessionId: string, options?: {
-        dir?: string;
-    }): Promise<SessionMessage[]>;
-}
-export declare class ClaudeAgentSdkAdapter {
-    private readonly sdkFacade;
-    private readonly approvalManager?;
-    constructor(sdkFacade?: ClaudeAgentSdkFacade, approvalManager?: ToolApprovalManager | undefined);
-    runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
-    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    probeCapabilities(cwd: string, settingSources?: SettingSource[]): Promise<ClaudeCapabilitySnapshot>;
-    private buildOptions;
-}
-export {};

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

@@ -1,520 +0,0 @@
-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;
-/**
- * Ensures the Claude Agent SDK Skill tool is pre-approved per
- * https://docs.anthropic.com/en/docs/claude-code/sdk/skills
- * Subagents inherit the parent session tool surface unless given a narrower `tools` list.
- */
-function mergeSkillIntoAllowedTools(allowedTools, disallowedTools) {
-    if (disallowedTools?.includes('Skill')) {
-        return allowedTools;
-    }
-    if (allowedTools === undefined) {
-        return ['Skill'];
-    }
-    return allowedTools.includes('Skill')
-        ? allowedTools
-        : [...allowedTools, 'Skill'];
-}
-export class ClaudeAgentSdkAdapter {
-    sdkFacade;
-    approvalManager;
-    constructor(sdkFacade = defaultFacade, approvalManager) {
-        this.sdkFacade = sdkFacade;
-        this.approvalManager = approvalManager;
-    }
-    async runSession(input, onEvent) {
-        const options = this.buildOptions(input);
-        const includePartials = options.includePartialMessages === true;
-        const abortController = new AbortController();
-        options.abortController = abortController;
-        const externalSignal = input.abortSignal;
-        let onAbort;
-        if (externalSignal) {
-            if (externalSignal.aborted) {
-                abortController.abort();
-            }
-            else {
-                onAbort = () => abortController.abort();
-                externalSignal.addEventListener('abort', onAbort, { once: true });
-            }
-        }
-        const sessionQuery = this.sdkFacade.query({
-            prompt: input.prompt,
-            options,
-        });
-        let events = [];
-        let finalText = '';
-        let sessionId;
-        let turns;
-        let totalCostUsd;
-        let inputTokens;
-        let outputTokens;
-        let contextWindowSize;
-        try {
-            for await (const message of sessionQuery) {
-                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);
-                    }
-                }
-                // 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;
-                    }
-                }
-            }
-        }
-        finally {
-            if (onAbort && externalSignal) {
-                externalSignal.removeEventListener('abort', onAbort);
-            }
-            sessionQuery.close();
-        }
-        return {
-            sessionId,
-            events,
-            finalText,
-            turns,
-            totalCostUsd,
-            inputTokens,
-            outputTokens,
-            contextWindowSize,
-        };
-    }
-    async listSavedSessions(cwd) {
-        const sessions = await this.sdkFacade.listSessions(cwd ? { dir: cwd } : undefined);
-        return sessions.map((session) => ({
-            sessionId: session.sessionId,
-            summary: session.summary,
-            cwd: session.cwd,
-            gitBranch: session.gitBranch,
-            createdAt: session.createdAt,
-            lastModified: session.lastModified,
-        }));
-    }
-    async getTranscript(sessionId, cwd) {
-        const messages = await this.sdkFacade.getSessionMessages(sessionId, cwd ? { dir: cwd } : undefined);
-        return messages.map((message) => ({
-            role: message.type,
-            sessionId: message.session_id,
-            messageId: message.uuid,
-            text: extractText(message.message),
-        }));
-    }
-    async probeCapabilities(cwd, settingSources = ['project']) {
-        const sessionQuery = this.sdkFacade.query({
-            prompt: 'Reply with OK.',
-            options: {
-                cwd,
-                maxTurns: 1,
-                permissionMode: 'plan',
-                persistSession: false,
-                tools: [],
-                settingSources,
-            },
-        });
-        try {
-            const [commands, agents, models] = await Promise.all([
-                sessionQuery.supportedCommands(),
-                sessionQuery.supportedAgents(),
-                sessionQuery.supportedModels(),
-            ]);
-            return {
-                commands: commands.map(mapSlashCommand),
-                agents: agents.map(mapAgent),
-                models: models.map((model) => model.value),
-            };
-        }
-        finally {
-            sessionQuery.close();
-        }
-    }
-    buildOptions(input) {
-        const options = {
-            cwd: input.cwd,
-            tools: { type: 'preset', preset: 'claude_code' },
-            allowedTools: mergeSkillIntoAllowedTools(input.allowedTools, input.disallowedTools),
-            disallowedTools: input.disallowedTools,
-            continue: input.continueSession,
-            resume: input.resumeSessionId,
-            forkSession: input.forkSession,
-            persistSession: input.persistSession,
-            includePartialMessages: input.includePartialMessages,
-            settingSources: input.settingSources,
-            maxTurns: input.maxTurns,
-            model: input.model,
-            effort: input.effort,
-            permissionMode: input.permissionMode ?? 'acceptEdits',
-            systemPrompt: input.systemPrompt
-                ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
-                : { type: 'preset', preset: 'claude_code' },
-            env: {
-                ...process.env,
-                CLAUDE_AGENT_SDK_CLIENT_APP: 'opencode-claude-manager-plugin/0.1.0',
-            },
-        };
-        if (!input.resumeSessionId) {
-            delete options.resume;
-        }
-        if (this.approvalManager) {
-            const manager = this.approvalManager;
-            options.canUseTool = async (toolName, toolInput, opts) => {
-                return manager.evaluate(toolName, toolInput, {
-                    title: opts.title,
-                    agentID: opts.agentID,
-                });
-            };
-        }
-        return options;
-    }
-}
-function normalizeSdkMessages(message, includePartials) {
-    const sessionId = 'session_id' in message ? message.session_id : undefined;
-    if (message.type === 'assistant') {
-        return normalizeAssistantSdkMessage(message, sessionId);
-    }
-    if (message.type === 'stream_event') {
-        if (!includePartials) {
-            return [];
-        }
-        const partialText = extractPartialEventText(message.event);
-        if (!partialText) {
-            return [];
-        }
-        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}`,
-            },
-        ];
-    }
-    if (message.type === 'system') {
-        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,
-            },
-        ];
-    }
-    if (message.type === 'prompt_suggestion') {
-        return [
-            {
-                type: 'system',
-                sessionId,
-                text: message.suggestion,
-                rawType: message.type,
-            },
-        ];
-    }
-    if (message.type === 'user') {
-        return normalizeUserSdkMessage(message, sessionId);
-    }
-    if (message.type === 'tool_progress') {
-        const toolName = 'tool_name' in message && typeof message.tool_name === 'string'
-            ? message.tool_name
-            : 'tool';
-        const elapsed = 'elapsed_time_seconds' in message &&
-            typeof message.elapsed_time_seconds === 'number'
-            ? message.elapsed_time_seconds
-            : 0;
-        return [
-            {
-                type: 'tool_progress',
-                sessionId,
-                text: JSON.stringify({ name: toolName, elapsed }),
-                rawType: message.type,
-            },
-        ];
-    }
-    if (message.type === 'tool_use_summary') {
-        const summary = 'summary' in message && typeof message.summary === 'string'
-            ? message.summary
-            : '';
-        return [
-            {
-                type: 'tool_summary',
-                sessionId,
-                text: summary,
-                rawType: message.type,
-            },
-        ];
-    }
-    return [
-        {
-            type: 'system',
-            sessionId,
-            text: message.type,
-            rawType: message.type,
-        },
-    ];
-}
-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',
-                },
-            ]
-            : [];
-    }
-    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);
-}
-function extractPartialEventText(event) {
-    if (!isRecord(event)) {
-        return null;
-    }
-    const delta = event.delta;
-    if (isRecord(delta)) {
-        if (typeof delta.text === 'string' && delta.text.length > 0) {
-            return delta.text;
-        }
-        if (typeof delta.partial_json === 'string' &&
-            delta.partial_json.length > 0) {
-            return delta.partial_json;
-        }
-    }
-    return null;
-}
-function extractText(payload) {
-    if (typeof payload === 'string') {
-        return payload;
-    }
-    if (!isRecord(payload)) {
-        return '';
-    }
-    if (Array.isArray(payload.content)) {
-        const parts = payload.content
-            .map((contentPart) => {
-            if (!isRecord(contentPart)) {
-                return '';
-            }
-            if (typeof contentPart.text === 'string') {
-                return contentPart.text;
-            }
-            if (contentPart.type === 'tool_use' &&
-                typeof contentPart.name === 'string') {
-                return `[tool:${contentPart.name}]`;
-            }
-            return '';
-        })
-            .filter(Boolean);
-        if (parts.length > 0) {
-            return parts.join('\n');
-        }
-    }
-    return JSON.stringify(payload);
-}
-function mapSlashCommand(command) {
-    return {
-        name: command.name,
-        description: command.description,
-        argumentHint: command.argumentHint,
-        source: 'sdk',
-    };
-}
-function mapAgent(agent) {
-    return {
-        name: agent.name,
-        description: agent.description,
-        model: agent.model,
-        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/claude-session.service.d.ts

@@ -1,15 +0,0 @@
-import type { ClaudeCapabilitySnapshot, ClaudeMetadataSnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
-import type { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
-import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from './claude-agent-sdk-adapter.js';
-export declare class ClaudeSessionService {
-    private readonly sdkAdapter;
-    private readonly metadataService;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, metadataService: ClaudeMetadataService);
-    runTask(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    listSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
-    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    inspectRepository(cwd: string, options?: {
-        includeSdkProbe?: boolean;
-    }): Promise<ClaudeMetadataSnapshot>;
-    probeCapabilities(cwd: string): Promise<ClaudeCapabilitySnapshot>;
-}

package/dist/claude/claude-session.service.js

@@ -1,23 +0,0 @@
-export class ClaudeSessionService {
-    sdkAdapter;
-    metadataService;
-    constructor(sdkAdapter, metadataService) {
-        this.sdkAdapter = sdkAdapter;
-        this.metadataService = metadataService;
-    }
-    runTask(input, onEvent) {
-        return this.sdkAdapter.runSession(input, onEvent);
-    }
-    listSessions(cwd) {
-        return this.sdkAdapter.listSavedSessions(cwd);
-    }
-    getTranscript(sessionId, cwd) {
-        return this.sdkAdapter.getTranscript(sessionId, cwd);
-    }
-    inspectRepository(cwd, options) {
-        return this.metadataService.collect(cwd, options);
-    }
-    probeCapabilities(cwd) {
-        return this.sdkAdapter.probeCapabilities(cwd);
-    }
-}

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

@@ -1,7 +0,0 @@
-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;