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

package/dist/src/claude/session-live-tailer.js

@@ -0,0 +1,269 @@
+import { createReadStream, existsSync, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import path from 'node:path';
+import os from 'node:os';
+/**
+ * Tails Claude Code session JSONL files for live tool output.
+ *
+ * The SDK streams high-level events (assistant text, tool_call summaries, results)
+ * but does not expose the raw tool output that Claude Code writes to the JSONL
+ * transcript on disk.  This service fills that gap by polling the file for new
+ * lines, parsing each one, and forwarding parsed events to a caller-supplied
+ * callback.
+ */
+export class SessionLiveTailer {
+    activeTails = new Map();
+    // ── Path discovery ──────────────────────────────────────────────────
+    /**
+     * Locate the JSONL file for a session.
+     *
+     * Claude Code stores transcripts at:
+     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
+     *
+     * The `<sanitized-cwd>` folder name is an internal implementation detail that
+     * can change across Claude Code versions, so we search all project directories
+     * for the session file rather than attempting to replicate the sanitisation.
+     */
+    findSessionFile(sessionId, cwd) {
+        const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+        if (!existsSync(projectsDir)) {
+            return null;
+        }
+        // If cwd is provided, try the sanitised form first (best-effort fast path).
+        if (cwd) {
+            const sanitised = cwd.replace(/\//g, '-');
+            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Fall back to scanning all project directories.
+        try {
+            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
+                if (existsSync(candidate)) {
+                    return candidate;
+                }
+            }
+        }
+        catch {
+            // Permission denied or similar — nothing we can do.
+        }
+        return null;
+    }
+    /**
+     * Check whether we can locate a JSONL file for the given session.
+     */
+    sessionFileExists(sessionId, cwd) {
+        return this.findSessionFile(sessionId, cwd) !== null;
+    }
+    // ── Live tailing ────────────────────────────────────────────────────
+    /**
+     * Poll a session's JSONL file for new lines and emit parsed events.
+     *
+     * Returns a stop function.  The caller **must** invoke it when tailing is no
+     * longer needed (e.g. when the session completes or the tool is interrupted).
+     */
+    startTailing(sessionId, cwd, onEvent, pollIntervalMs = 150) {
+        const filePath = this.findSessionFile(sessionId, cwd);
+        if (!filePath) {
+            onEvent({
+                type: 'error',
+                sessionId,
+                error: `Session JSONL not found for ${sessionId}`,
+            });
+            return () => { };
+        }
+        let offset = statSync(filePath).size;
+        let buffer = '';
+        let reading = false; // guard against overlapping reads
+        const interval = setInterval(() => {
+            if (reading)
+                return;
+            try {
+                const currentSize = statSync(filePath).size;
+                if (currentSize < offset) {
+                    // File was truncated (rotation / compaction) — reset.
+                    offset = 0;
+                    buffer = '';
+                }
+                if (currentSize <= offset)
+                    return;
+                reading = true;
+                const stream = createReadStream(filePath, {
+                    start: offset,
+                    end: currentSize - 1,
+                    encoding: 'utf8',
+                });
+                let chunk = '';
+                stream.on('data', (data) => {
+                    chunk += data;
+                });
+                stream.on('end', () => {
+                    reading = false;
+                    offset = currentSize;
+                    buffer += chunk;
+                    const lines = buffer.split('\n');
+                    // Keep the last (possibly incomplete) segment in the buffer.
+                    buffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            onEvent({
+                                type: 'line',
+                                sessionId,
+                                data: parsed,
+                                rawLine: trimmed,
+                            });
+                        }
+                        catch {
+                            onEvent({
+                                type: 'line',
+                                sessionId,
+                                data: null,
+                                rawLine: trimmed,
+                            });
+                        }
+                    }
+                });
+                stream.on('error', (err) => {
+                    reading = false;
+                    onEvent({
+                        type: 'error',
+                        sessionId,
+                        error: err.message,
+                    });
+                });
+            }
+            catch (err) {
+                reading = false;
+                onEvent({
+                    type: 'error',
+                    sessionId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }, pollIntervalMs);
+        this.activeTails.set(sessionId, interval);
+        return () => this.stopTailing(sessionId);
+    }
+    /**
+     * Stop tailing a specific session.
+     */
+    stopTailing(sessionId) {
+        const interval = this.activeTails.get(sessionId);
+        if (interval) {
+            clearInterval(interval);
+            this.activeTails.delete(sessionId);
+        }
+    }
+    /**
+     * Stop all active tails (cleanup on shutdown).
+     */
+    stopAll() {
+        for (const [, interval] of this.activeTails) {
+            clearInterval(interval);
+        }
+        this.activeTails.clear();
+    }
+    // ── Snapshot helpers ────────────────────────────────────────────────
+    /**
+     * Read the last N lines from a session JSONL file.
+     */
+    async getLastLines(sessionId, cwd, lineCount = 20) {
+        const filePath = this.findSessionFile(sessionId, cwd);
+        if (!filePath)
+            return [];
+        const lines = [];
+        const rl = createInterface({
+            input: createReadStream(filePath, { encoding: 'utf8' }),
+        });
+        for await (const line of rl) {
+            lines.push(line);
+            if (lines.length > lineCount) {
+                lines.shift();
+            }
+        }
+        return lines;
+    }
+    /**
+     * Extract a preview of recent tool output from the tail of a session file.
+     */
+    async getToolOutputPreview(sessionId, cwd, maxEntries = 5) {
+        const lastLines = await this.getLastLines(sessionId, cwd, 100);
+        const previews = [];
+        for (const line of lastLines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                const preview = extractToolOutput(parsed);
+                if (preview) {
+                    previews.push(preview);
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return previews.slice(-maxEntries);
+    }
+}
+// ── Internal helpers ────────────────────────────────────────────────────
+/**
+ * Attempt to extract tool output information from a JSONL record.
+ *
+ * Claude Code JSONL records with tool results can appear as:
+ *   1. A top-level `{ type: "user", message: { content: [{ type: "tool_result", ... }] } }`
+ *   2. Direct `tool_result` entries (less common).
+ */
+function extractToolOutput(record) {
+    // Pattern 1: user message wrapping tool_result content blocks
+    if (record.type === 'user') {
+        const message = record.message;
+        if (!message)
+            return null;
+        const content = message.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const block of content) {
+            if (block &&
+                typeof block === 'object' &&
+                block.type === 'tool_result') {
+                const b = block;
+                return {
+                    toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
+                    content: stringifyContent(b.content),
+                    isError: b.is_error === true,
+                };
+            }
+        }
+    }
+    // Pattern 2: direct tool_result record (varies by Claude Code version)
+    if (record.type === 'tool_result') {
+        return {
+            toolUseId: typeof record.tool_use_id === 'string' ? record.tool_use_id : '',
+            content: stringifyContent(record.content),
+            isError: record.is_error === true,
+        };
+    }
+    return null;
+}
+function stringifyContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/src/claude/tool-approval-manager.d.ts

@@ -0,0 +1,27 @@
+import type { ToolApprovalDecision, ToolApprovalPolicy, ToolApprovalRule } from '../types/contracts.js';
+export declare class ToolApprovalManager {
+    private policy;
+    private decisions;
+    private readonly maxDecisions;
+    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number);
+    evaluate(toolName: string, input: Record<string, unknown>, options?: {
+        title?: string;
+        agentID?: string;
+    }): {
+        behavior: 'allow';
+    } | {
+        behavior: 'deny';
+        message: string;
+    };
+    getDecisions(limit?: number): ToolApprovalDecision[];
+    getDeniedDecisions(limit?: number): ToolApprovalDecision[];
+    clearDecisions(): void;
+    getPolicy(): ToolApprovalPolicy;
+    setPolicy(policy: ToolApprovalPolicy): void;
+    addRule(rule: ToolApprovalRule, position?: number): void;
+    removeRule(ruleId: string): boolean;
+    setDefaultAction(action: 'allow' | 'deny'): void;
+    setEnabled(enabled: boolean): void;
+    private findMatchingRule;
+    private recordDecision;
+}

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

@@ -0,0 +1,232 @@
+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/src/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@opencode-ai/plugin';
+import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export { SessionLiveTailer } from './claude/session-live-tailer.js';
+export { ClaudeManagerPlugin };
+export declare const plugin: Plugin;

package/dist/src/index.js

@@ -0,0 +1,4 @@
+import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
+export { SessionLiveTailer } from './claude/session-live-tailer.js';
+export { ClaudeManagerPlugin };
+export const plugin = ClaudeManagerPlugin;

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

@@ -0,0 +1,33 @@
+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/src/manager/context-tracker.js

@@ -0,0 +1,106 @@
+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/src/manager/git-operations.d.ts

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