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

package/dist/src/manager/git-operations.js

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export class GitOperations {
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    async diff() {
+        const [diffText, statOutput] = await Promise.all([
+            this.git(['diff', 'HEAD']),
+            this.git(['diff', 'HEAD', '--stat']),
+        ]);
+        const stats = parseStatLine(statOutput);
+        return {
+            hasDiff: diffText.trim().length > 0,
+            diffText,
+            stats,
+        };
+    }
+    async diffStat() {
+        return this.git(['diff', 'HEAD', '--stat']);
+    }
+    async commit(message) {
+        try {
+            await this.git(['add', '-A']);
+            const output = await this.git(['commit', '-m', message]);
+            return { success: true, output };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async resetHard() {
+        try {
+            const output = await this.git(['reset', '--hard', 'HEAD']);
+            // Also clean untracked files
+            const cleanOutput = await this.git(['clean', '-fd']);
+            return { success: true, output: `${output}\n${cleanOutput}`.trim() };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async currentBranch() {
+        const branch = await this.git(['rev-parse', '--abbrev-ref', 'HEAD']);
+        return branch.trim();
+    }
+    async recentCommits(count = 5) {
+        return this.git(['log', `--oneline`, `-${count}`]);
+    }
+    async git(args) {
+        const { stdout } = await execFileAsync('git', args, { cwd: this.cwd });
+        return stdout;
+    }
+}
+function parseStatLine(statOutput) {
+    // Parse the summary line like: "3 files changed, 10 insertions(+), 2 deletions(-)"
+    const summaryLine = statOutput.trim().split('\n').pop() ?? '';
+    const filesMatch = summaryLine.match(/(\d+)\s+files?\s+changed/);
+    const insertionsMatch = summaryLine.match(/(\d+)\s+insertions?\(\+\)/);
+    const deletionsMatch = summaryLine.match(/(\d+)\s+deletions?\(-\)/);
+    return {
+        filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+        insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+        deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0,
+    };
+}

package/dist/src/manager/persistent-manager.d.ts

@@ -0,0 +1,77 @@
+import type { ClaudeSessionEvent, ClaudeSessionRunResult, PersistentRunRecord, PersistentRunResult, SessionContextSnapshot, GitDiffResult, GitOperationResult } from '../types/contracts.js';
+import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { FileRunStateStore } from '../state/file-run-state-store.js';
+import type { TranscriptStore } from '../state/transcript-store.js';
+import type { SessionController } from './session-controller.js';
+import type { GitOperations } from './git-operations.js';
+import type { ContextTracker } from './context-tracker.js';
+type PersistentManagerProgressHandler = (run: PersistentRunRecord) => void | Promise<void>;
+export declare class PersistentManager {
+    private readonly sessionController;
+    private readonly gitOps;
+    private readonly stateStore;
+    private readonly contextTracker;
+    private readonly transcriptStore;
+    constructor(sessionController: SessionController, gitOps: GitOperations, stateStore: FileRunStateStore, contextTracker: ContextTracker, transcriptStore: TranscriptStore);
+    /**
+     * Send a message to the persistent Claude Code session.
+     * Creates a new session if none exists.
+     */
+    sendMessage(cwd: string, message: string, options?: {
+        model?: string;
+        effort?: 'low' | 'medium' | 'high' | 'max';
+        mode?: 'plan' | 'free';
+        abortSignal?: AbortSignal;
+    }, onEvent?: ClaudeSessionEventHandler): Promise<{
+        sessionId: string | undefined;
+        finalText: string;
+        turns?: number;
+        totalCostUsd?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+        contextWindowSize?: number;
+        context: SessionContextSnapshot;
+    }>;
+    /**
+     * Get the current git diff.
+     */
+    gitDiff(): Promise<GitDiffResult>;
+    /**
+     * Commit all current changes.
+     */
+    gitCommit(message: string): Promise<GitOperationResult>;
+    /**
+     * Hard reset to discard all uncommitted changes.
+     */
+    gitReset(): Promise<GitOperationResult>;
+    /**
+     * Get current session status and context health.
+     */
+    getStatus(): SessionContextSnapshot;
+    /**
+     * Clear the active session. Next send creates a fresh one.
+     */
+    clearSession(cwd: string): Promise<string | null>;
+    /**
+     * Compact the current session to free context.
+     */
+    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    /**
+     * Read persisted transcript events for a session.
+     */
+    getTranscriptEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
+    /**
+     * Execute a full task with run tracking.
+     * Creates a run record, sends the message, and persists the result.
+     */
+    executeTask(cwd: string, task: string, options?: {
+        model?: string;
+    }, onProgress?: PersistentManagerProgressHandler): Promise<PersistentRunResult>;
+    /**
+     * Try to restore session state from disk on startup.
+     */
+    tryRestore(cwd: string): Promise<boolean>;
+    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
+    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
+}
+export {};

package/dist/src/manager/persistent-manager.js

@@ -0,0 +1,170 @@
+import { randomUUID } from 'node:crypto';
+export class PersistentManager {
+    sessionController;
+    gitOps;
+    stateStore;
+    contextTracker;
+    transcriptStore;
+    constructor(sessionController, gitOps, stateStore, contextTracker, transcriptStore) {
+        this.sessionController = sessionController;
+        this.gitOps = gitOps;
+        this.stateStore = stateStore;
+        this.contextTracker = contextTracker;
+        this.transcriptStore = transcriptStore;
+    }
+    /**
+     * Send a message to the persistent Claude Code session.
+     * Creates a new session if none exists.
+     */
+    async sendMessage(cwd, message, options, onEvent) {
+        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        if (result.sessionId && result.events.length > 0) {
+            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
+        }
+        return {
+            sessionId: result.sessionId,
+            finalText: result.finalText,
+            turns: result.turns,
+            totalCostUsd: result.totalCostUsd,
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            contextWindowSize: result.contextWindowSize,
+            context: this.sessionController.getContextSnapshot(),
+        };
+    }
+    /**
+     * Get the current git diff.
+     */
+    async gitDiff() {
+        return this.gitOps.diff();
+    }
+    /**
+     * Commit all current changes.
+     */
+    async gitCommit(message) {
+        return this.gitOps.commit(message);
+    }
+    /**
+     * Hard reset to discard all uncommitted changes.
+     */
+    async gitReset() {
+        return this.gitOps.resetHard();
+    }
+    /**
+     * Get current session status and context health.
+     */
+    getStatus() {
+        return this.sessionController.getContextSnapshot();
+    }
+    /**
+     * Clear the active session. Next send creates a fresh one.
+     */
+    async clearSession(cwd) {
+        return this.sessionController.clearSession(cwd);
+    }
+    /**
+     * Compact the current session to free context.
+     */
+    async compactSession(cwd, onEvent) {
+        const result = await this.sessionController.compactSession(cwd, onEvent);
+        if (result.sessionId && result.events.length > 0) {
+            await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
+        }
+        return result;
+    }
+    /**
+     * Read persisted transcript events for a session.
+     */
+    getTranscriptEvents(cwd, sessionId) {
+        return this.transcriptStore.readEvents(cwd, sessionId);
+    }
+    /**
+     * Execute a full task with run tracking.
+     * Creates a run record, sends the message, and persists the result.
+     */
+    async executeTask(cwd, task, options, onProgress) {
+        const runId = randomUUID();
+        const createdAt = new Date().toISOString();
+        const runRecord = {
+            id: runId,
+            cwd,
+            task,
+            status: 'running',
+            createdAt,
+            updatedAt: createdAt,
+            sessionId: this.sessionController.sessionId,
+            sessionHistory: [],
+            messages: [
+                {
+                    timestamp: createdAt,
+                    direction: 'sent',
+                    text: task,
+                },
+            ],
+            actions: [],
+            commits: [],
+            context: this.sessionController.getContextSnapshot(),
+        };
+        await this.stateStore.saveRun(runRecord);
+        await onProgress?.(runRecord);
+        try {
+            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
+                // Update run record with progress events
+                const currentRun = await this.stateStore.getRun(cwd, runId);
+                if (currentRun) {
+                    const updated = {
+                        ...currentRun,
+                        updatedAt: new Date().toISOString(),
+                        sessionId: event.sessionId ?? currentRun.sessionId,
+                        context: this.sessionController.getContextSnapshot(),
+                    };
+                    await this.stateStore.saveRun(updated);
+                    await onProgress?.(updated);
+                }
+            });
+            const completedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
+                ...run,
+                status: 'completed',
+                updatedAt: new Date().toISOString(),
+                sessionId: result.sessionId ?? run.sessionId,
+                messages: [
+                    ...run.messages,
+                    {
+                        timestamp: new Date().toISOString(),
+                        direction: 'received',
+                        text: result.finalText,
+                        turns: result.turns,
+                        totalCostUsd: result.totalCostUsd,
+                        inputTokens: result.inputTokens,
+                        outputTokens: result.outputTokens,
+                    },
+                ],
+                context: this.sessionController.getContextSnapshot(),
+                finalSummary: result.finalText,
+            }));
+            return { run: completedRun };
+        }
+        catch (error) {
+            const failedRun = await this.stateStore.updateRun(cwd, runId, (run) => ({
+                ...run,
+                status: 'failed',
+                updatedAt: new Date().toISOString(),
+                context: this.sessionController.getContextSnapshot(),
+                finalSummary: error instanceof Error ? error.message : String(error),
+            }));
+            return { run: failedRun };
+        }
+    }
+    /**
+     * Try to restore session state from disk on startup.
+     */
+    async tryRestore(cwd) {
+        return this.sessionController.tryRestore(cwd);
+    }
+    listRuns(cwd) {
+        return this.stateStore.listRuns(cwd);
+    }
+    getRun(cwd, runId) {
+        return this.stateStore.getRun(cwd, runId);
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ClaudeSessionRunResult, SessionContextSnapshot, SessionMode } from '../types/contracts.js';
+import type { ContextTracker } from './context-tracker.js';
+export declare class SessionController {
+    private readonly sdkAdapter;
+    private readonly contextTracker;
+    private readonly sessionPrompt;
+    private readonly modePrefixes;
+    private activeSessionId;
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+        plan: string;
+        free: 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;
+        effort?: 'low' | 'medium' | 'high' | 'max';
+        mode?: SessionMode;
+        abortSignal?: AbortSignal;
+    }, 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/src/manager/session-controller.js

@@ -0,0 +1,147 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
+export class SessionController {
+    sdkAdapter;
+    contextTracker;
+    sessionPrompt;
+    modePrefixes;
+    activeSessionId = null;
+    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+        plan: '',
+        free: '',
+    }) {
+        this.sdkAdapter = sdkAdapter;
+        this.contextTracker = contextTracker;
+        this.sessionPrompt = sessionPrompt;
+        this.modePrefixes = modePrefixes;
+    }
+    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 mode = options?.mode ?? 'free';
+        const prefix = this.modePrefixes[mode];
+        const prompt = prefix ? `${prefix}\n\n${message}` : message;
+        const input = {
+            cwd,
+            prompt,
+            persistSession: true,
+            permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
+            includePartialMessages: true,
+            model: options?.model,
+            effort: options?.effort,
+            settingSources: ['user'],
+            abortSignal: options?.abortSignal,
+        };
+        if (this.activeSessionId) {
+            // Resume existing session
+            input.resumeSessionId = this.activeSessionId;
+        }
+        else {
+            // New session — use the base session prompt (project context is in the wrapper)
+            input.systemPrompt = this.sessionPrompt;
+            input.model ??= 'claude-opus-4-6';
+            input.effort ??= 'high';
+        }
+        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/src/plugin/agent-hierarchy.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
+ *
+ * CTO (cto)                      — pure orchestrator, spawns engineers, reviews diffs, commits
+ * Engineer Plan (engineer_plan)   — manages a Claude Code session for read-only investigation
+ * Engineer Build (engineer_build) — manages a Claude Code session for implementation
+ * Claude Code session             — the underlying AI session (prompt only, no OpenCode agent)
+ */
+import type { ManagerPromptRegistry } from '../types/contracts.js';
+export declare const AGENT_CTO = "cto";
+export declare const AGENT_ENGINEER_PLAN = "engineer_plan";
+export declare const AGENT_ENGINEER_BUILD = "engineer_build";
+/** All restricted tool IDs (union of all domain groups) */
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+type ToolPermission = 'allow' | 'ask' | 'deny';
+type AgentPermission = {
+    '*'?: ToolPermission;
+    read?: ToolPermission;
+    grep?: ToolPermission;
+    glob?: ToolPermission;
+    list?: ToolPermission;
+    codesearch?: ToolPermission;
+    webfetch?: ToolPermission;
+    websearch?: ToolPermission;
+    lsp?: ToolPermission;
+    /** OpenCode built-in: manage session todo list */
+    todowrite?: ToolPermission;
+    /** OpenCode built-in: read session todo list */
+    todoread?: ToolPermission;
+    /** OpenCode built-in: ask the user structured questions with options */
+    question?: ToolPermission;
+    /** OpenCode built-in: launch subagents (matches subagent type, last-match-wins) */
+    task?: ToolPermission | Record<string, ToolPermission>;
+    bash?: ToolPermission | Record<string, ToolPermission>;
+    [tool: string]: ToolPermission | Record<string, ToolPermission> | undefined;
+};
+export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "primary";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildEngineerPlanAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildEngineerBuildAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+/** Deny all restricted tools at the global level so only designated agents can use them. */
+export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;
+export {};