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

package/dist/manager/session-controller.d.ts

@@ -0,0 +1,38 @@
+import type { ClaudeSessionRunResult, SessionContextSnapshot } from '../types/contracts.js';
+import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ContextTracker } from './context-tracker.js';
+export declare class SessionController {
+    private readonly sdkAdapter;
+    private readonly contextTracker;
+    private readonly sessionPrompt;
+    private activeSessionId;
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string);
+    get isActive(): boolean;
+    get sessionId(): string | null;
+    /**
+     * Send a message to the persistent session. Creates one if none exists.
+     * Returns the session result including usage data.
+     */
+    sendMessage(cwd: string, message: string, options?: {
+        model?: string;
+        settingSources?: Array<'user' | 'project' | 'local'>;
+    }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    /**
+     * Send /compact to the current session to compress context.
+     */
+    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    /**
+     * Clear the current session. The next sendMessage will create a fresh one.
+     */
+    clearSession(cwd: string): Promise<string | null>;
+    /**
+     * Get current context tracking snapshot.
+     */
+    getContextSnapshot(): SessionContextSnapshot;
+    /**
+     * Try to restore active session from persisted state on startup.
+     */
+    tryRestore(cwd: string): Promise<boolean>;
+    private persistActiveSession;
+    private removeActiveSession;
+}

package/dist/manager/session-controller.js

@@ -0,0 +1,135 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
+export class SessionController {
+    sdkAdapter;
+    contextTracker;
+    sessionPrompt;
+    activeSessionId = null;
+    constructor(sdkAdapter, contextTracker, sessionPrompt) {
+        this.sdkAdapter = sdkAdapter;
+        this.contextTracker = contextTracker;
+        this.sessionPrompt = sessionPrompt;
+    }
+    get isActive() {
+        return this.activeSessionId !== null;
+    }
+    get sessionId() {
+        return this.activeSessionId;
+    }
+    /**
+     * Send a message to the persistent session. Creates one if none exists.
+     * Returns the session result including usage data.
+     */
+    async sendMessage(cwd, message, options, onEvent) {
+        const input = {
+            cwd,
+            prompt: message,
+            persistSession: true,
+            permissionMode: 'acceptEdits',
+            includePartialMessages: true,
+            model: options?.model,
+            settingSources: options?.settingSources ?? ['project', 'local'],
+        };
+        if (this.activeSessionId) {
+            // Resume existing session
+            input.resumeSessionId = this.activeSessionId;
+        }
+        else {
+            // New session — apply the expert operator system prompt
+            input.systemPrompt = this.sessionPrompt;
+        }
+        const result = await this.sdkAdapter.runSession(input, onEvent);
+        // Track the session ID
+        if (result.sessionId) {
+            this.activeSessionId = result.sessionId;
+        }
+        // Update context tracking
+        this.contextTracker.recordResult({
+            sessionId: result.sessionId,
+            turns: result.turns,
+            totalCostUsd: result.totalCostUsd,
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            contextWindowSize: result.contextWindowSize,
+        });
+        // Persist active session state
+        await this.persistActiveSession(cwd);
+        return result;
+    }
+    /**
+     * Send /compact to the current session to compress context.
+     */
+    async compactSession(cwd, onEvent) {
+        if (!this.activeSessionId) {
+            throw new Error('No active session to compact');
+        }
+        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
+        this.contextTracker.recordCompaction();
+        return result;
+    }
+    /**
+     * Clear the current session. The next sendMessage will create a fresh one.
+     */
+    async clearSession(cwd) {
+        const clearedId = this.activeSessionId;
+        this.activeSessionId = null;
+        this.contextTracker.reset();
+        await this.removeActiveSession(cwd);
+        return clearedId;
+    }
+    /**
+     * Get current context tracking snapshot.
+     */
+    getContextSnapshot() {
+        return this.contextTracker.snapshot();
+    }
+    /**
+     * Try to restore active session from persisted state on startup.
+     */
+    async tryRestore(cwd) {
+        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+        try {
+            const raw = await readFile(filePath, 'utf-8');
+            const state = JSON.parse(raw);
+            if (state.sessionId && state.cwd === cwd) {
+                this.activeSessionId = state.sessionId;
+                this.contextTracker.restore(state);
+                return true;
+            }
+        }
+        catch {
+            // File doesn't exist or is corrupt — start fresh
+        }
+        return false;
+    }
+    async persistActiveSession(cwd) {
+        if (!this.activeSessionId) {
+            return;
+        }
+        const snap = this.contextTracker.snapshot();
+        const state = {
+            sessionId: this.activeSessionId,
+            cwd,
+            startedAt: new Date().toISOString(),
+            totalTurns: snap.totalTurns,
+            totalCostUsd: snap.totalCostUsd,
+            estimatedContextPercent: snap.estimatedContextPercent,
+            contextWindowSize: snap.contextWindowSize,
+            latestInputTokens: snap.latestInputTokens,
+        };
+        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(state, null, 2));
+    }
+    async removeActiveSession(cwd) {
+        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+        try {
+            const { unlink } = await import('node:fs/promises');
+            await unlink(filePath);
+        }
+        catch {
+            // File doesn't exist — that's fine
+        }
+    }
+}

package/dist/manager/task-planner.d.ts

@@ -1,5 +1,5 @@
-import type { ManagedSubtaskPlan, ManagerRunMode } from '../types/contracts.js';
+import type { ManagedSubtaskPlan } from '../types/contracts.js';
 export declare class TaskPlanner {
-    plan(task: string, mode: ManagerRunMode, maxSubagents: number): ManagedSubtaskPlan[];
+    plan(tasks: string[], maxSubagents: number): ManagedSubtaskPlan[];
     private createPlan;
 }

package/dist/manager/task-planner.js

@@ -1,20 +1,9 @@
 import { randomUUID } from 'node:crypto';
 export class TaskPlanner {
-    plan(task, mode, maxSubagents) {
-        if (mode === 'single') {
-            return [this.createPlan('Primary task', task)];
-        }
-        const splitCandidates = extractTaskCandidates(task).slice(0, maxSubagents);
-        if (mode === 'split' && splitCandidates.length === 0) {
-            return [this.createPlan('Primary task', task)];
-        }
-        if (mode === 'auto' && splitCandidates.length < 2) {
-            return [this.createPlan('Primary task', task)];
-        }
-        if (splitCandidates.length === 0) {
-            return [this.createPlan('Primary task', task)];
-        }
-        return splitCandidates.map((candidate, index) => this.createPlan(`Subtask ${index + 1}`, candidate));
+    plan(tasks, maxSubagents) {
+        return tasks
+            .slice(0, maxSubagents)
+            .map((task, index) => this.createPlan(tasks.length === 1 ? 'Primary task' : `Subtask ${index + 1}`, task));
     }
     createPlan(title, prompt) {
         return {
@@ -24,19 +13,3 @@ export class TaskPlanner {
         };
     }
 }
-function extractTaskCandidates(task) {
-    const listMatches = task
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => /^(-|\*|\d+\.)\s+/.test(line))
-        .map((line) => line.replace(/^(-|\*|\d+\.)\s+/, '').trim())
-        .filter(Boolean);
-    if (listMatches.length > 0) {
-        return listMatches;
-    }
-    const sentenceMatches = task
-        .split(/;|\n{2,}/)
-        .map((part) => part.trim())
-        .filter((part) => part.length > 20);
-    return sentenceMatches.length > 1 ? sentenceMatches : [];
-}

package/dist/plugin/claude-code-permission-bridge.d.ts

@@ -0,0 +1,15 @@
+import type { ToolContext } from '@opencode-ai/plugin';
+import type { ManagerSessionCanUseToolFactory } from '../types/contracts.js';
+export interface ClaudeCodePermissionBridge {
+    createCanUseTool: ManagerSessionCanUseToolFactory;
+}
+/**
+ * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
+ * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
+ *
+ * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
+ * allow with answers set to each question's first option label so the session can proceed;
+ * the UI should still show full choices — users needing a different option should answer via
+ * the primary agent and re-run.
+ */
+export declare function createClaudeCodePermissionBridge(context: ToolContext): ClaudeCodePermissionBridge;

package/dist/plugin/claude-code-permission-bridge.js

@@ -0,0 +1,184 @@
+/**
+ * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
+ * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
+ *
+ * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
+ * allow with answers set to each question's first option label so the session can proceed;
+ * the UI should still show full choices — users needing a different option should answer via
+ * the primary agent and re-run.
+ */
+export function createClaudeCodePermissionBridge(context) {
+    const queue = createPermissionAskQueue();
+    return {
+        createCanUseTool(scope) {
+            return (toolName, input, options) => queue.enqueue(() => bridgeCanUseTool(context, scope, toolName, input, options));
+        },
+    };
+}
+function createPermissionAskQueue() {
+    let chain = Promise.resolve();
+    return {
+        enqueue(operation) {
+            const resultPromise = chain
+                .catch(() => undefined)
+                .then(operation);
+            chain = resultPromise.then(() => undefined, () => undefined);
+            return resultPromise;
+        },
+    };
+}
+async function bridgeCanUseTool(context, scope, toolName, input, options) {
+    if (options.signal.aborted) {
+        return {
+            behavior: 'deny',
+            message: 'Permission request aborted.',
+            toolUseID: options.toolUseID,
+        };
+    }
+    if (toolName === 'AskUserQuestion') {
+        return handleAskUserQuestion(context, scope, input, options);
+    }
+    const permission = mapClaudeToolToOpenCodePermission(toolName);
+    const patterns = derivePatterns(toolName, input);
+    const metadata = buildMetadata(scope, toolName, input, options);
+    try {
+        await context.ask({
+            permission,
+            patterns,
+            always: [],
+            metadata,
+        });
+        return {
+            behavior: 'allow',
+            updatedInput: input,
+            toolUseID: options.toolUseID,
+        };
+    }
+    catch (error) {
+        return {
+            behavior: 'deny',
+            message: error instanceof Error
+                ? error.message
+                : 'OpenCode permission request was rejected or failed.',
+            toolUseID: options.toolUseID,
+        };
+    }
+}
+async function handleAskUserQuestion(context, scope, input, options) {
+    const questions = input.questions;
+    if (!Array.isArray(questions) || questions.length === 0) {
+        return {
+            behavior: 'deny',
+            message: 'AskUserQuestion invoked without a valid questions array.',
+            toolUseID: options.toolUseID,
+        };
+    }
+    const metadata = {
+        ...buildMetadata(scope, 'AskUserQuestion', input, options),
+        questions,
+        note: 'Claude Code AskUserQuestion: approving proceeds with the first listed option per question unless the host supplies structured replies.',
+    };
+    try {
+        await context.ask({
+            permission: 'question',
+            patterns: [],
+            always: [],
+            metadata,
+        });
+        const answers = buildDefaultAskUserQuestionAnswers(questions);
+        return {
+            behavior: 'allow',
+            updatedInput: {
+                ...input,
+                questions,
+                answers,
+            },
+            toolUseID: options.toolUseID,
+        };
+    }
+    catch (error) {
+        return {
+            behavior: 'deny',
+            message: error instanceof Error
+                ? error.message
+                : 'OpenCode declined or failed the clarifying-question prompt.',
+            toolUseID: options.toolUseID,
+        };
+    }
+}
+function buildDefaultAskUserQuestionAnswers(questions) {
+    const answers = {};
+    for (const raw of questions) {
+        if (!raw || typeof raw !== 'object') {
+            continue;
+        }
+        const entry = raw;
+        const questionText = typeof entry.question === 'string' ? entry.question : '';
+        if (!questionText) {
+            continue;
+        }
+        const options = Array.isArray(entry.options) ? entry.options : [];
+        const first = options[0];
+        const label = first &&
+            typeof first === 'object' &&
+            first !== null &&
+            typeof first.label === 'string'
+            ? first.label
+            : 'Default';
+        answers[questionText] = label;
+    }
+    return answers;
+}
+function mapClaudeToolToOpenCodePermission(toolName) {
+    switch (toolName) {
+        case 'Read':
+            return 'read';
+        case 'Write':
+        case 'Edit':
+        case 'NotebookEdit':
+            return 'edit';
+        case 'Bash':
+            return 'bash';
+        case 'Glob':
+            return 'glob';
+        case 'Grep':
+            return 'grep';
+        case 'Task':
+        case 'Agent':
+            return 'task';
+        case 'WebFetch':
+            return 'webfetch';
+        case 'WebSearch':
+            return 'websearch';
+        default:
+            return 'bash';
+    }
+}
+function derivePatterns(toolName, input) {
+    const filePath = input.file_path ?? input.path;
+    if (typeof filePath === 'string' && filePath.length > 0) {
+        return [filePath];
+    }
+    if (toolName === 'Bash' && typeof input.command === 'string') {
+        return [input.command];
+    }
+    return [];
+}
+function buildMetadata(scope, toolName, input, options) {
+    return {
+        source: 'claude_code',
+        managerRunId: scope.runId,
+        managerPlanId: scope.planId,
+        managerPlanTitle: scope.planTitle,
+        claudeTool: toolName,
+        toolInput: input,
+        toolUseID: options.toolUseID,
+        agentID: options.agentID,
+        title: options.title,
+        displayName: options.displayName,
+        description: options.description,
+        blockedPath: options.blockedPath,
+        decisionReason: options.decisionReason,
+        sdkSuggestions: options.suggestions,
+    };
+}

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

@@ -1,4 +1,4 @@
 import { type Plugin } from '@opencode-ai/plugin';
-import type { ManagerRunRecord } from '../types/contracts.js';
+import type { PersistentRunRecord } from '../types/contracts.js';
 export declare const ClaudeManagerPlugin: Plugin;
-export declare function formatManagerRunToolResult(run: ManagerRunRecord): string;
+export declare function formatRunToolResult(run: PersistentRunRecord): string;