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

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

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest';
+import { ToolApprovalManager } from '../src/claude/tool-approval-manager.js';
+describe('ToolApprovalManager', () => {
+    describe('evaluate()', () => {
+        it('allows Skill tool by default policy', () => {
+            const manager = new ToolApprovalManager();
+            const result = manager.evaluate('Skill', { command: 'my-skill' });
+            expect(result).toEqual({ behavior: 'allow' });
+        });
+        it('allows read-only tools by default policy', () => {
+            const manager = new ToolApprovalManager();
+            expect(manager.evaluate('Read', { file_path: '/tmp/foo.ts' })).toEqual({
+                behavior: 'allow',
+            });
+            expect(manager.evaluate('Grep', { pattern: 'foo' })).toEqual({
+                behavior: 'allow',
+            });
+            expect(manager.evaluate('Glob', { pattern: '*.ts' })).toEqual({
+                behavior: 'allow',
+            });
+        });
+        it('allows edit tools by default policy', () => {
+            const manager = new ToolApprovalManager();
+            expect(manager.evaluate('Edit', {
+                file_path: '/tmp/foo.ts',
+                old_string: 'a',
+                new_string: 'b',
+            })).toEqual({ behavior: 'allow' });
+            expect(manager.evaluate('Write', {
+                file_path: '/tmp/foo.ts',
+                content: 'hello',
+            })).toEqual({ behavior: 'allow' });
+        });
+        it('denies bash rm -rf on root', () => {
+            const manager = new ToolApprovalManager();
+            const result = manager.evaluate('Bash', { command: 'rm -rf /' });
+            expect(result.behavior).toBe('deny');
+            if (result.behavior === 'deny') {
+                expect(result.message).toContain('rm -rf');
+            }
+        });
+        it('denies git push --force', () => {
+            const manager = new ToolApprovalManager();
+            const result = manager.evaluate('Bash', {
+                command: 'git push --force origin main',
+            });
+            expect(result.behavior).toBe('deny');
+            if (result.behavior === 'deny') {
+                expect(result.message).toContain('Force push');
+            }
+        });
+        it('denies git reset --hard', () => {
+            const manager = new ToolApprovalManager();
+            const result = manager.evaluate('Bash', {
+                command: 'git reset --hard HEAD',
+            });
+            expect(result.behavior).toBe('deny');
+            if (result.behavior === 'deny') {
+                expect(result.message).toContain('git reset --hard');
+            }
+        });
+        it('allows normal bash commands', () => {
+            const manager = new ToolApprovalManager();
+            expect(manager.evaluate('Bash', { command: 'ls -la' })).toEqual({
+                behavior: 'allow',
+            });
+            expect(manager.evaluate('Bash', { command: 'pnpm test' })).toEqual({
+                behavior: 'allow',
+            });
+        });
+        it('returns allow when disabled', () => {
+            const manager = new ToolApprovalManager({ enabled: false });
+            const result = manager.evaluate('Bash', { command: 'rm -rf /' });
+            expect(result).toEqual({ behavior: 'allow' });
+        });
+        it('uses default action when no rule matches', () => {
+            const manager = new ToolApprovalManager({
+                rules: [],
+                defaultAction: 'deny',
+            });
+            const result = manager.evaluate('SomeUnknownTool', {});
+            expect(result.behavior).toBe('deny');
+        });
+        it('first matching rule wins', () => {
+            const manager = new ToolApprovalManager({
+                rules: [
+                    {
+                        id: 'deny-all-bash',
+                        toolPattern: 'Bash',
+                        action: 'deny',
+                        denyMessage: 'No bash',
+                    },
+                    { id: 'allow-bash', toolPattern: 'Bash', action: 'allow' },
+                ],
+                defaultAction: 'allow',
+                enabled: true,
+            });
+            const result = manager.evaluate('Bash', { command: 'echo hi' });
+            expect(result.behavior).toBe('deny');
+        });
+        it('matches glob patterns in tool names', () => {
+            const manager = new ToolApprovalManager({
+                rules: [
+                    {
+                        id: 'deny-notebook',
+                        toolPattern: 'Notebook*',
+                        action: 'deny',
+                        denyMessage: 'No notebooks',
+                    },
+                ],
+                defaultAction: 'allow',
+                enabled: true,
+            });
+            expect(manager.evaluate('NotebookEdit', {}).behavior).toBe('deny');
+            expect(manager.evaluate('NotebookRead', {}).behavior).toBe('deny');
+            expect(manager.evaluate('Read', {}).behavior).toBe('allow');
+        });
+        it('matches inputPattern as substring of serialized input', () => {
+            const manager = new ToolApprovalManager({
+                rules: [
+                    {
+                        id: 'deny-secret-files',
+                        toolPattern: '*',
+                        inputPattern: '.env',
+                        action: 'deny',
+                        denyMessage: 'No .env access',
+                    },
+                ],
+                defaultAction: 'allow',
+                enabled: true,
+            });
+            expect(manager.evaluate('Read', { file_path: '/project/.env' }).behavior).toBe('deny');
+            expect(manager.evaluate('Read', { file_path: '/project/src/index.ts' }).behavior).toBe('allow');
+        });
+        it('records decisions in the log', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', { file_path: '/tmp/foo.ts' });
+            const decisions = manager.getDecisions();
+            expect(decisions).toHaveLength(1);
+            expect(decisions[0].toolName).toBe('Read');
+            expect(decisions[0].action).toBe('allow');
+            expect(decisions[0].matchedRuleId).toBe('allow-read');
+        });
+    });
+    describe('policy management', () => {
+        it('addRule inserts at specified position', () => {
+            const manager = new ToolApprovalManager({
+                rules: [],
+                enabled: true,
+                defaultAction: 'allow',
+            });
+            manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
+            manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
+            manager.addRule({ id: 'c', toolPattern: 'C', action: 'deny' }, 1);
+            const rules = manager.getPolicy().rules;
+            expect(rules.map((r) => r.id)).toEqual(['a', 'c', 'b']);
+        });
+        it('addRule appends to end by default', () => {
+            const manager = new ToolApprovalManager({
+                rules: [],
+                enabled: true,
+                defaultAction: 'allow',
+            });
+            manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
+            manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
+            expect(manager.getPolicy().rules.map((r) => r.id)).toEqual(['a', 'b']);
+        });
+        it('removeRule removes by ID and returns true', () => {
+            const manager = new ToolApprovalManager();
+            const removed = manager.removeRule('allow-read');
+            expect(removed).toBe(true);
+            expect(manager.getPolicy().rules.find((r) => r.id === 'allow-read')).toBeUndefined();
+        });
+        it('removeRule returns false for non-existent ID', () => {
+            const manager = new ToolApprovalManager();
+            expect(manager.removeRule('nonexistent')).toBe(false);
+        });
+        it('setPolicy replaces entire policy', () => {
+            const manager = new ToolApprovalManager();
+            manager.setPolicy({
+                rules: [{ id: 'only', toolPattern: '*', action: 'deny' }],
+                defaultAction: 'deny',
+                enabled: true,
+            });
+            expect(manager.getPolicy().rules).toHaveLength(1);
+            expect(manager.getPolicy().defaultAction).toBe('deny');
+        });
+        it('setDefaultAction changes the fallback', () => {
+            const manager = new ToolApprovalManager({
+                rules: [],
+                enabled: true,
+                defaultAction: 'allow',
+            });
+            manager.setDefaultAction('deny');
+            expect(manager.evaluate('Unknown', {}).behavior).toBe('deny');
+        });
+        it('setEnabled toggles the manager', () => {
+            const manager = new ToolApprovalManager({
+                rules: [
+                    {
+                        id: 'deny-all',
+                        toolPattern: '*',
+                        action: 'deny',
+                        denyMessage: 'blocked',
+                    },
+                ],
+                enabled: true,
+                defaultAction: 'deny',
+            });
+            expect(manager.evaluate('Read', {}).behavior).toBe('deny');
+            manager.setEnabled(false);
+            expect(manager.evaluate('Read', {}).behavior).toBe('allow');
+        });
+    });
+    describe('decision log', () => {
+        it('getDecisions returns most recent first', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', {});
+            manager.evaluate('Grep', {});
+            manager.evaluate('Glob', {});
+            const decisions = manager.getDecisions();
+            expect(decisions[0].toolName).toBe('Glob');
+            expect(decisions[2].toolName).toBe('Read');
+        });
+        it('getDeniedDecisions filters to denials only', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', {});
+            manager.evaluate('Bash', { command: 'rm -rf /' });
+            manager.evaluate('Grep', {});
+            const denied = manager.getDeniedDecisions();
+            expect(denied).toHaveLength(1);
+            expect(denied[0].toolName).toBe('Bash');
+        });
+        it('clearDecisions empties the log', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', {});
+            manager.evaluate('Grep', {});
+            manager.clearDecisions();
+            expect(manager.getDecisions()).toHaveLength(0);
+        });
+        it('respects maxDecisions ring buffer limit', () => {
+            const manager = new ToolApprovalManager({}, 3);
+            manager.evaluate('Read', {});
+            manager.evaluate('Grep', {});
+            manager.evaluate('Glob', {});
+            manager.evaluate('Edit', {});
+            const decisions = manager.getDecisions();
+            expect(decisions).toHaveLength(3);
+            // Oldest (Read) should be evicted
+            expect(decisions.map((d) => d.toolName)).toEqual(['Edit', 'Glob', 'Grep']);
+        });
+        it('includes agentId when provided', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', {}, { agentID: 'agent_123' });
+            expect(manager.getDecisions()[0].agentId).toBe('agent_123');
+        });
+        it('truncates inputPreview for large inputs', () => {
+            const manager = new ToolApprovalManager();
+            manager.evaluate('Read', { data: 'x'.repeat(1000) });
+            const decision = manager.getDecisions()[0];
+            expect(decision.inputPreview.length).toBeLessThanOrEqual(300);
+        });
+    });
+});

package/dist/test/transcript-append.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/transcript-append.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { appendTranscriptEvents, stripTrailingPartials } from '../src/util/transcript-append.js';
+function ev(type, text) {
+    return { type, text };
+}
+describe('transcript-append', () => {
+    it('replaces the last partial when another partial arrives', () => {
+        const next = appendTranscriptEvents([], [ev('partial', 'a')]);
+        expect(next).toEqual([ev('partial', 'a')]);
+        const next2 = appendTranscriptEvents(next, [ev('partial', 'ab')]);
+        expect(next2).toEqual([ev('partial', 'ab')]);
+    });
+    it('strips trailing partials before a non-partial event', () => {
+        const base = appendTranscriptEvents([], [ev('partial', 'streaming')]);
+        const next = appendTranscriptEvents(base, [ev('assistant', 'Final answer.')]);
+        expect(next.map((e) => e.type)).toEqual(['assistant']);
+        expect(next[0]?.text).toBe('Final answer.');
+    });
+    it('stripTrailingPartials removes only trailing partials', () => {
+        const events = [
+            ev('init', 'init'),
+            ev('partial', 'x'),
+            ev('assistant', 'done'),
+            ev('partial', 'orphan'),
+        ];
+        expect(stripTrailingPartials(events).map((e) => e.type)).toEqual([
+            'init',
+            'partial',
+            'assistant',
+        ]);
+    });
+    it('appends multiple incoming events in order with partial rules', () => {
+        const batch = appendTranscriptEvents([ev('init', 'init')], [ev('partial', 'p1'), ev('partial', 'p2'), ev('user', 'tool output')]);
+        expect(batch.map((e) => e.type)).toEqual(['init', 'user']);
+        expect(batch[1]?.text).toBe('tool output');
+    });
+});

package/dist/test/transcript-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/transcript-store.test.js

@@ -0,0 +1,50 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import { TranscriptStore } from '../src/state/transcript-store.js';
+function ev(type, text) {
+    return { type, text };
+}
+describe('TranscriptStore', () => {
+    const testDir = path.join(process.cwd(), '.test-transcript-store-' + process.pid);
+    let store;
+    beforeEach(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        store = new TranscriptStore('.claude-manager');
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    it('returns empty array for nonexistent session', async () => {
+        const events = await store.readEvents(testDir, 'nonexistent');
+        expect(events).toEqual([]);
+    });
+    it('appends and reads events', async () => {
+        await store.appendEvents(testDir, 'ses_1', [ev('init', 'init'), ev('assistant', 'Hello.')]);
+        const events = await store.readEvents(testDir, 'ses_1');
+        expect(events).toEqual([ev('init', 'init'), ev('assistant', 'Hello.')]);
+    });
+    it('accumulates events across multiple appends', async () => {
+        await store.appendEvents(testDir, 'ses_2', [
+            ev('init', 'init'),
+            ev('assistant', 'First response.'),
+        ]);
+        await store.appendEvents(testDir, 'ses_2', [
+            ev('user', 'Follow-up question'),
+            ev('assistant', 'Second response.'),
+        ]);
+        const events = await store.readEvents(testDir, 'ses_2');
+        expect(events.map((e) => e.type)).toEqual(['init', 'assistant', 'user', 'assistant']);
+        expect(events[3].text).toBe('Second response.');
+    });
+    it('strips trailing partials before persisting', async () => {
+        await store.appendEvents(testDir, 'ses_3', [ev('init', 'init'), ev('partial', 'streaming...')]);
+        const events = await store.readEvents(testDir, 'ses_3');
+        expect(events).toEqual([ev('init', 'init')]);
+    });
+    it('skips write when newEvents is empty', async () => {
+        await store.appendEvents(testDir, 'ses_4', []);
+        const events = await store.readEvents(testDir, 'ses_4');
+        expect(events).toEqual([]);
+    });
+});

package/dist/types/contracts.d.ts

@@ -1,7 +1,7 @@
 export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
-    engineerPlanPrompt: string;
-    engineerBuildPrompt: string;
+    engineerExplorePrompt: string;
+    engineerImplementPrompt: string;
     engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
@@ -113,7 +113,6 @@ export interface GitOperationResult {
 }
 export interface ActiveSessionState {
     sessionId: string;
-    cwd: string;
     startedAt: string;
     totalTurns: number;
     totalCostUsd: number;
@@ -133,7 +132,7 @@ export interface PersistentRunMessageRecord {
 }
 export interface PersistentRunActionRecord {
     timestamp: string;
-    type: 'git_diff' | 'git_commit' | 'git_reset' | 'compact' | 'clear';
+    type: 'git_diff' | 'git_commit' | 'git_reset' | 'git_status' | 'git_log' | 'compact' | 'clear';
     result: string;
 }
 export interface PersistentRunRecord {

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        environment: 'node',
+        include: ['test/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'lcov'],
+        },
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.35",
+  "version": "0.1.43",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -52,6 +52,6 @@
     "format": "prettier --write .",
     "test": "vitest run",
     "knip": "knip",
-    "release": "pnpm run build && pnpm version patch && pnpm publish"
+    "release": "pnpm run build && pnpm version patch && git push --follow-tags"
   }
 }