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

package/dist/claude/tool-approval-manager.js

@@ -1,238 +0,0 @@
-const DEFAULT_MAX_DECISIONS = 500;
-const INPUT_PREVIEW_MAX = 300;
-function getDefaultRules() {
-    return [
-        // Safe read-only tools
-        {
-            id: 'allow-read',
-            toolPattern: 'Read',
-            action: 'allow',
-            description: 'Allow reading files',
-        },
-        {
-            id: 'allow-grep',
-            toolPattern: 'Grep',
-            action: 'allow',
-            description: 'Allow grep searches',
-        },
-        {
-            id: 'allow-glob',
-            toolPattern: 'Glob',
-            action: 'allow',
-            description: 'Allow glob file searches',
-        },
-        {
-            id: 'allow-ls',
-            toolPattern: 'LS',
-            action: 'allow',
-            description: 'Allow directory listing',
-        },
-        {
-            id: 'allow-list',
-            toolPattern: 'ListDirectory',
-            action: 'allow',
-            description: 'Allow listing directories',
-        },
-        // Edit tools
-        {
-            id: 'allow-edit',
-            toolPattern: 'Edit',
-            action: 'allow',
-            description: 'Allow file edits',
-        },
-        {
-            id: 'allow-multiedit',
-            toolPattern: 'MultiEdit',
-            action: 'allow',
-            description: 'Allow multi-edits',
-        },
-        {
-            id: 'allow-write',
-            toolPattern: 'Write',
-            action: 'allow',
-            description: 'Allow file writes',
-        },
-        {
-            id: 'allow-notebook',
-            toolPattern: 'NotebookEdit',
-            action: 'allow',
-            description: 'Allow notebook edits',
-        },
-        // Bash - deny dangerous patterns first, then allow the rest
-        {
-            id: 'deny-bash-rm-rf-root',
-            toolPattern: 'Bash',
-            inputPattern: 'rm -rf /',
-            action: 'deny',
-            denyMessage: 'Destructive rm -rf on root path is not allowed.',
-            description: 'Block rm -rf on root',
-        },
-        {
-            id: 'deny-bash-force-push',
-            toolPattern: 'Bash',
-            inputPattern: 'git push --force',
-            action: 'deny',
-            denyMessage: 'Force push is not allowed.',
-            description: 'Block git force push',
-        },
-        {
-            id: 'deny-bash-reset-hard',
-            toolPattern: 'Bash',
-            inputPattern: 'git reset --hard',
-            action: 'deny',
-            denyMessage: 'git reset --hard is not allowed from Claude Code. Use the manager git_reset tool instead.',
-            description: 'Block git reset --hard',
-        },
-        {
-            id: 'allow-bash',
-            toolPattern: 'Bash',
-            action: 'allow',
-            description: 'Allow bash commands (after dangerous patterns filtered)',
-        },
-        // Agent / misc
-        {
-            id: 'allow-skill',
-            toolPattern: 'Skill',
-            action: 'allow',
-            description: 'Allow Agent Skills (filesystem SKILL.md)',
-        },
-        {
-            id: 'allow-agent',
-            toolPattern: 'Agent',
-            action: 'allow',
-            description: 'Allow agent delegation',
-        },
-        {
-            id: 'allow-todowrite',
-            toolPattern: 'TodoWrite',
-            action: 'allow',
-            description: 'Allow todo tracking',
-        },
-        {
-            id: 'allow-todoread',
-            toolPattern: 'TodoRead',
-            action: 'allow',
-            description: 'Allow todo reading',
-        },
-    ];
-}
-export class ToolApprovalManager {
-    policy;
-    decisions = [];
-    maxDecisions;
-    constructor(policy, maxDecisions) {
-        this.policy = {
-            rules: policy?.rules ?? getDefaultRules(),
-            defaultAction: policy?.defaultAction ?? 'allow',
-            defaultDenyMessage: policy?.defaultDenyMessage ?? 'Tool call denied by approval policy.',
-            enabled: policy?.enabled ?? true,
-        };
-        this.maxDecisions = maxDecisions ?? DEFAULT_MAX_DECISIONS;
-    }
-    evaluate(toolName, input, options) {
-        if (!this.policy.enabled) {
-            return { behavior: 'allow' };
-        }
-        const inputJson = safeJsonStringify(input);
-        const matchedRule = this.findMatchingRule(toolName, inputJson);
-        const action = matchedRule?.action ?? this.policy.defaultAction;
-        const denyMessage = action === 'deny'
-            ? (matchedRule?.denyMessage ??
-                this.policy.defaultDenyMessage ??
-                'Denied by policy.')
-            : undefined;
-        this.recordDecision({
-            timestamp: new Date().toISOString(),
-            toolName,
-            inputPreview: inputJson.slice(0, INPUT_PREVIEW_MAX),
-            title: options?.title,
-            matchedRuleId: matchedRule?.id ?? 'default',
-            action,
-            denyMessage,
-            agentId: options?.agentID,
-        });
-        if (action === 'deny') {
-            return { behavior: 'deny', message: denyMessage };
-        }
-        return { behavior: 'allow' };
-    }
-    getDecisions(limit) {
-        const all = [...this.decisions].reverse();
-        return limit ? all.slice(0, limit) : all;
-    }
-    getDeniedDecisions(limit) {
-        const denied = this.decisions.filter((d) => d.action === 'deny').reverse();
-        return limit ? denied.slice(0, limit) : denied;
-    }
-    clearDecisions() {
-        this.decisions = [];
-    }
-    getPolicy() {
-        return { ...this.policy, rules: [...this.policy.rules] };
-    }
-    setPolicy(policy) {
-        this.policy = { ...policy, rules: [...policy.rules] };
-    }
-    addRule(rule, position) {
-        if (position !== undefined &&
-            position >= 0 &&
-            position < this.policy.rules.length) {
-            this.policy.rules.splice(position, 0, rule);
-        }
-        else {
-            this.policy.rules.push(rule);
-        }
-    }
-    removeRule(ruleId) {
-        const index = this.policy.rules.findIndex((r) => r.id === ruleId);
-        if (index === -1) {
-            return false;
-        }
-        this.policy.rules.splice(index, 1);
-        return true;
-    }
-    setDefaultAction(action) {
-        this.policy.defaultAction = action;
-    }
-    setEnabled(enabled) {
-        this.policy.enabled = enabled;
-    }
-    findMatchingRule(toolName, inputJson) {
-        for (const rule of this.policy.rules) {
-            if (!matchesToolPattern(rule.toolPattern, toolName)) {
-                continue;
-            }
-            if (rule.inputPattern && !inputJson.includes(rule.inputPattern)) {
-                continue;
-            }
-            return rule;
-        }
-        return null;
-    }
-    recordDecision(decision) {
-        this.decisions.push(decision);
-        if (this.decisions.length > this.maxDecisions) {
-            this.decisions = this.decisions.slice(-this.maxDecisions);
-        }
-    }
-}
-function matchesToolPattern(pattern, toolName) {
-    if (pattern === '*') {
-        return true;
-    }
-    if (!pattern.includes('*')) {
-        return pattern === toolName;
-    }
-    const regex = new RegExp('^' +
-        pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') +
-        '$');
-    return regex.test(toolName);
-}
-function safeJsonStringify(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}

package/dist/manager/context-tracker.d.ts

@@ -1,33 +0,0 @@
-import type { ContextWarningLevel, SessionContextSnapshot } from '../types/contracts.js';
-export declare class ContextTracker {
-    private totalTurns;
-    private totalCostUsd;
-    private latestInputTokens;
-    private latestOutputTokens;
-    private contextWindowSize;
-    private compactionCount;
-    private sessionId;
-    recordResult(result: {
-        sessionId?: string;
-        turns?: number;
-        totalCostUsd?: number;
-        inputTokens?: number;
-        outputTokens?: number;
-        contextWindowSize?: number;
-    }): void;
-    recordCompaction(): void;
-    snapshot(): SessionContextSnapshot;
-    warningLevel(): ContextWarningLevel;
-    estimateContextPercent(): number | null;
-    isAboveTokenThreshold(thresholdTokens?: number): boolean;
-    reset(): void;
-    /** Restore from persisted active session state. */
-    restore(state: {
-        sessionId: string;
-        totalTurns: number;
-        totalCostUsd: number;
-        estimatedContextPercent: number | null;
-        contextWindowSize: number | null;
-        latestInputTokens: number | null;
-    }): void;
-}

package/dist/manager/context-tracker.js

@@ -1,108 +0,0 @@
-const DEFAULT_CONTEXT_WINDOW = 200_000;
-export class ContextTracker {
-    totalTurns = 0;
-    totalCostUsd = 0;
-    latestInputTokens = null;
-    latestOutputTokens = null;
-    contextWindowSize = null;
-    compactionCount = 0;
-    sessionId = null;
-    recordResult(result) {
-        if (result.sessionId) {
-            this.sessionId = result.sessionId;
-        }
-        if (result.turns !== undefined) {
-            this.totalTurns = result.turns;
-        }
-        if (result.totalCostUsd !== undefined) {
-            this.totalCostUsd = result.totalCostUsd;
-        }
-        if (result.inputTokens !== undefined) {
-            // If input tokens dropped significantly, compaction likely occurred
-            if (this.latestInputTokens !== null &&
-                result.inputTokens < this.latestInputTokens * 0.5) {
-                this.compactionCount++;
-            }
-            this.latestInputTokens = result.inputTokens;
-        }
-        if (result.outputTokens !== undefined) {
-            this.latestOutputTokens = result.outputTokens;
-        }
-        if (result.contextWindowSize !== undefined) {
-            this.contextWindowSize = result.contextWindowSize;
-        }
-    }
-    recordCompaction() {
-        this.compactionCount++;
-    }
-    snapshot() {
-        return {
-            sessionId: this.sessionId,
-            totalTurns: this.totalTurns,
-            totalCostUsd: this.totalCostUsd,
-            latestInputTokens: this.latestInputTokens,
-            latestOutputTokens: this.latestOutputTokens,
-            contextWindowSize: this.contextWindowSize,
-            estimatedContextPercent: this.estimateContextPercent(),
-            warningLevel: this.warningLevel(),
-            compactionCount: this.compactionCount,
-        };
-    }
-    warningLevel() {
-        const percent = this.estimateContextPercent();
-        if (percent === null) {
-            return 'ok';
-        }
-        if (percent >= 85) {
-            return 'critical';
-        }
-        if (percent >= 70) {
-            return 'high';
-        }
-        if (percent >= 50) {
-            return 'moderate';
-        }
-        return 'ok';
-    }
-    estimateContextPercent() {
-        // Tier 1: Token-based (most accurate)
-        if (this.latestInputTokens !== null) {
-            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
-            return Math.min(100, Math.round((this.latestInputTokens / window) * 100));
-        }
-        // Tier 2: Cost-based heuristic
-        if (this.totalCostUsd > 0) {
-            const estimatedTokens = this.totalCostUsd * 130_000;
-            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
-            return Math.min(100, Math.round((estimatedTokens / window) * 100));
-        }
-        // Tier 3: Turns-based fallback
-        if (this.totalTurns > 0) {
-            const estimatedTokens = this.totalTurns * 6_000;
-            const window = this.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
-            return Math.min(100, Math.round((estimatedTokens / window) * 100));
-        }
-        return null;
-    }
-    isAboveTokenThreshold(thresholdTokens = 200_000) {
-        return (this.latestInputTokens !== null &&
-            this.latestInputTokens >= thresholdTokens);
-    }
-    reset() {
-        this.totalTurns = 0;
-        this.totalCostUsd = 0;
-        this.latestInputTokens = null;
-        this.latestOutputTokens = null;
-        this.contextWindowSize = null;
-        this.compactionCount = 0;
-        this.sessionId = null;
-    }
-    /** Restore from persisted active session state. */
-    restore(state) {
-        this.sessionId = state.sessionId;
-        this.totalTurns = state.totalTurns;
-        this.totalCostUsd = state.totalCostUsd;
-        this.contextWindowSize = state.contextWindowSize;
-        this.latestInputTokens = state.latestInputTokens;
-    }
-}

package/dist/manager/git-operations.d.ts

@@ -1,12 +0,0 @@
-import type { GitDiffResult, GitOperationResult } from '../types/contracts.js';
-export declare class GitOperations {
-    private readonly cwd;
-    constructor(cwd: string);
-    diff(): Promise<GitDiffResult>;
-    diffStat(): Promise<string>;
-    commit(message: string): Promise<GitOperationResult>;
-    resetHard(): Promise<GitOperationResult>;
-    currentBranch(): Promise<string>;
-    recentCommits(count?: number): Promise<string>;
-    private git;
-}

package/dist/manager/git-operations.js

@@ -1,76 +0,0 @@
-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/manager/manager-orchestrator.d.ts

@@ -1,17 +0,0 @@
-import type { ClaudeSessionService } from '../claude/claude-session.service.js';
-import type { FileRunStateStore } from '../state/file-run-state-store.js';
-import type { ManagerRunRecord, ManagerRunResult, ManagerTaskRequest } from '../types/contracts.js';
-import type { TaskPlanner } from './task-planner.js';
-export type ManagerRunProgressHandler = (run: ManagerRunRecord) => void | Promise<void>;
-export declare class ManagerOrchestrator {
-    private readonly sessionService;
-    private readonly stateStore;
-    private readonly taskPlanner;
-    constructor(sessionService: ClaudeSessionService, stateStore: FileRunStateStore, taskPlanner: TaskPlanner);
-    run(request: ManagerTaskRequest, onProgress?: ManagerRunProgressHandler): Promise<ManagerRunResult>;
-    listRuns(cwd: string): Promise<ManagerRunRecord[]>;
-    getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
-    private executePlan;
-    private patchSession;
-    private updateRunAndNotify;
-}

package/dist/manager/manager-orchestrator.js

@@ -1,178 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { managerPromptRegistry } from '../prompts/registry.js';
-import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
-export class ManagerOrchestrator {
-    sessionService;
-    stateStore;
-    taskPlanner;
-    constructor(sessionService, stateStore, taskPlanner) {
-        this.sessionService = sessionService;
-        this.stateStore = stateStore;
-        this.taskPlanner = taskPlanner;
-    }
-    async run(request, onProgress) {
-        const maxSubagents = Math.max(1, request.maxSubagents ?? 3);
-        const includeProjectSettings = request.includeProjectSettings ?? true;
-        const metadata = await this.sessionService.inspectRepository(request.cwd);
-        const plans = this.taskPlanner.plan(request.task, maxSubagents);
-        const runId = randomUUID();
-        const createdAt = new Date().toISOString();
-        const plannedAssignments = plans.map((plan) => ({
-            plan,
-            cwd: request.cwd,
-        }));
-        const runRecord = {
-            id: runId,
-            cwd: request.cwd,
-            task: request.task,
-            includeProjectSettings,
-            status: 'running',
-            createdAt,
-            updatedAt: createdAt,
-            metadata,
-            sessions: plannedAssignments.map(({ plan, cwd }) => createManagedSessionRecord(plan, cwd)),
-        };
-        await this.stateStore.saveRun(runRecord);
-        await onProgress?.(runRecord);
-        const settledResults = plannedAssignments.length <= 1
-            ? await Promise.allSettled(plannedAssignments.map(({ plan, cwd }) => this.executePlan({
-                request,
-                runId,
-                plan,
-                cwd,
-                includeProjectSettings,
-                onProgress,
-            })))
-            : await runSequentially(plannedAssignments.map(({ plan, cwd }) => () => this.executePlan({
-                request,
-                runId,
-                plan,
-                cwd,
-                includeProjectSettings,
-                onProgress,
-            })));
-        const failedResult = settledResults.find((result) => result.status === 'rejected');
-        const finalRun = await this.updateRunAndNotify(request.cwd, runId, (currentRun) => ({
-            ...currentRun,
-            status: failedResult ? 'failed' : 'completed',
-            updatedAt: new Date().toISOString(),
-            finalSummary: summarizeRun(currentRun.sessions),
-        }), onProgress);
-        return { run: finalRun };
-    }
-    listRuns(cwd) {
-        return this.stateStore.listRuns(cwd);
-    }
-    getRun(cwd, runId) {
-        return this.stateStore.getRun(cwd, runId);
-    }
-    async executePlan(input) {
-        const { request, runId, plan, cwd, includeProjectSettings, onProgress } = input;
-        await this.patchSession(request.cwd, runId, plan.id, (session) => ({
-            ...session,
-            status: 'running',
-        }), onProgress);
-        try {
-            const sessionInput = {
-                cwd,
-                prompt: buildWorkerPrompt(plan.prompt, request.task),
-                systemPrompt: managerPromptRegistry.subagentSystemPrompt,
-                model: request.model,
-                includePartialMessages: true,
-                settingSources: includeProjectSettings ? ['project', 'local'] : [],
-            };
-            const sessionResult = await this.sessionService.runTask(sessionInput, async (event) => {
-                await this.patchSession(request.cwd, runId, plan.id, (session) => ({
-                    ...session,
-                    claudeSessionId: event.sessionId ?? session.claudeSessionId,
-                    events: appendTranscriptEvents(session.events, [
-                        compactEvent(event),
-                    ]),
-                }), onProgress);
-            });
-            await this.patchSession(request.cwd, runId, plan.id, (session) => ({
-                ...session,
-                status: 'completed',
-                claudeSessionId: sessionResult.sessionId,
-                finalText: sessionResult.finalText,
-                turns: sessionResult.turns,
-                totalCostUsd: sessionResult.totalCostUsd,
-                events: stripTrailingPartials(session.events),
-            }), onProgress);
-        }
-        catch (error) {
-            await this.patchSession(request.cwd, runId, plan.id, (session) => ({
-                ...session,
-                status: 'failed',
-                error: error instanceof Error ? error.message : String(error),
-                events: stripTrailingPartials(session.events),
-            }), onProgress);
-            throw error;
-        }
-    }
-    async patchSession(cwd, runId, sessionId, update, onProgress) {
-        await this.updateRunAndNotify(cwd, runId, (run) => ({
-            ...run,
-            updatedAt: new Date().toISOString(),
-            sessions: run.sessions.map((session) => session.id === sessionId ? update(session) : session),
-        }), onProgress);
-    }
-    async updateRunAndNotify(cwd, runId, update, onProgress) {
-        const updatedRun = await this.stateStore.updateRun(cwd, runId, update);
-        await onProgress?.(updatedRun);
-        return updatedRun;
-    }
-}
-function createManagedSessionRecord(plan, cwd) {
-    return {
-        id: plan.id,
-        title: plan.title,
-        prompt: plan.prompt,
-        status: 'pending',
-        cwd,
-        events: [],
-    };
-}
-function buildWorkerPrompt(subtaskPrompt, parentTasks) {
-    const parentContext = parentTasks.length === 1
-        ? `Parent task: ${parentTasks[0]}`
-        : `Parent tasks:\n${parentTasks.map((t, i) => `${i + 1}. ${t}`).join('\n')}`;
-    return [
-        'You are executing a delegated Claude Code subtask.',
-        parentContext,
-        `Assigned subtask: ${subtaskPrompt}`,
-        'Stay within scope, finish the requested work, and end with a concise verification summary.',
-    ].join('\n\n');
-}
-function summarizeRun(sessions) {
-    return sessions
-        .map((session) => `${session.title}: ${session.finalText ?? session.error ?? session.status}`)
-        .join('\n');
-}
-function compactEvent(event) {
-    const compact = {
-        type: event.type,
-        sessionId: event.sessionId,
-        text: event.text.slice(0, 4000),
-    };
-    if (event.turns !== undefined) {
-        compact.turns = event.turns;
-    }
-    if (event.totalCostUsd !== undefined) {
-        compact.totalCostUsd = event.totalCostUsd;
-    }
-    return compact;
-}
-async function runSequentially(tasks) {
-    const results = [];
-    for (const task of tasks) {
-        try {
-            await task();
-            results.push({ status: 'fulfilled', value: undefined });
-        }
-        catch (error) {
-            results.push({ status: 'rejected', reason: error });
-        }
-    }
-    return results;
-}