@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

package/dist/manager/session-controller.js

@@ -1,97 +0,0 @@
-export class SessionController {
-    sdkAdapter;
-    contextTracker;
-    sessionPrompt;
-    wrapperType;
-    worktree;
-    modePrefixes;
-    activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
-        plan: '',
-        free: '',
-    }) {
-        this.sdkAdapter = sdkAdapter;
-        this.contextTracker = contextTracker;
-        this.sessionPrompt = sessionPrompt;
-        this.wrapperType = wrapperType;
-        this.worktree = worktree;
-        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(message, options, onEvent) {
-        const mode = options?.mode ?? 'free';
-        const prefix = this.modePrefixes[mode];
-        const prompt = prefix ? `${prefix}\n\n${message}` : message;
-        const input = {
-            cwd: this.worktree,
-            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 — prefer dynamically constructed prompt from wrapper, fall back to static default
-            input.systemPrompt = options?.sessionSystemPrompt ?? 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,
-        });
-        return result;
-    }
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    async compactSession(onEvent) {
-        if (!this.activeSessionId) {
-            throw new Error('No active session to compact');
-        }
-        const result = await this.sendMessage('/compact', undefined, onEvent);
-        this.contextTracker.recordCompaction();
-        return result;
-    }
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    async clearSession() {
-        const clearedId = this.activeSessionId;
-        this.activeSessionId = null;
-        this.contextTracker.reset();
-        return clearedId;
-    }
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot() {
-        return this.contextTracker.snapshot();
-    }
-}

package/dist/metadata/claude-metadata.service.d.ts

@@ -1,12 +0,0 @@
-import type { ClaudeMetadataSnapshot, ClaudeSettingSource } from '../types/contracts.js';
-import type { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
-import type { RepoClaudeConfigReader } from './repo-claude-config-reader.js';
-export declare class ClaudeMetadataService {
-    private readonly configReader;
-    private readonly sdkAdapter;
-    constructor(configReader: RepoClaudeConfigReader, sdkAdapter: ClaudeAgentSdkAdapter);
-    collect(cwd: string, options?: {
-        includeSdkProbe?: boolean;
-        settingSources?: ClaudeSettingSource[];
-    }): Promise<ClaudeMetadataSnapshot>;
-}

package/dist/metadata/claude-metadata.service.js

@@ -1,38 +0,0 @@
-export class ClaudeMetadataService {
-    configReader;
-    sdkAdapter;
-    constructor(configReader, sdkAdapter) {
-        this.configReader = configReader;
-        this.sdkAdapter = sdkAdapter;
-    }
-    async collect(cwd, options = {}) {
-        const baseSnapshot = await this.configReader.read(cwd);
-        if (!options.includeSdkProbe) {
-            return dedupeSnapshot(baseSnapshot);
-        }
-        const capabilities = await this.sdkAdapter.probeCapabilities(cwd, options.settingSources);
-        return dedupeSnapshot({
-            ...baseSnapshot,
-            commands: [...baseSnapshot.commands, ...capabilities.commands],
-            agents: capabilities.agents,
-        });
-    }
-}
-function dedupeSnapshot(snapshot) {
-    return {
-        ...snapshot,
-        commands: dedupeByName(snapshot.commands),
-        skills: dedupeByName(snapshot.skills),
-        hooks: dedupeByName(snapshot.hooks),
-        agents: dedupeByName(snapshot.agents),
-    };
-}
-function dedupeByName(items) {
-    const seen = new Map();
-    for (const item of items) {
-        if (!seen.has(item.name)) {
-            seen.set(item.name, item);
-        }
-    }
-    return [...seen.values()].sort((left, right) => left.name.localeCompare(right.name));
-}

package/dist/metadata/repo-claude-config-reader.d.ts

@@ -1,7 +0,0 @@
-import type { ClaudeMetadataSnapshot } from '../types/contracts.js';
-export declare class RepoClaudeConfigReader {
-    read(cwd: string): Promise<ClaudeMetadataSnapshot>;
-    private readSkills;
-    private readCommands;
-    private readSettings;
-}

package/dist/metadata/repo-claude-config-reader.js

@@ -1,154 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import JSON5 from 'json5';
-export class RepoClaudeConfigReader {
-    async read(cwd) {
-        const claudeDirectory = path.join(cwd, '.claude');
-        const skillsDirectory = path.join(claudeDirectory, 'skills');
-        const commandsDirectory = path.join(claudeDirectory, 'commands');
-        const claudeMdCandidates = [
-            path.join(cwd, 'CLAUDE.md'),
-            path.join(claudeDirectory, 'CLAUDE.md'),
-        ];
-        const collectedAt = new Date().toISOString();
-        const [skills, commands, settingsResult, claudeMdPath] = await Promise.all([
-            this.readSkills(skillsDirectory),
-            this.readCommands(commandsDirectory),
-            this.readSettings(claudeDirectory),
-            findFirstExistingPath(claudeMdCandidates),
-        ]);
-        return {
-            collectedAt,
-            cwd,
-            commands: [...skillsToCommands(skills), ...commands],
-            skills,
-            hooks: settingsResult.hooks,
-            agents: [],
-            claudeMdPath: claudeMdPath ?? undefined,
-            settingsPaths: settingsResult.settingsPaths,
-        };
-    }
-    async readSkills(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const entries = await fs.readdir(directory, { withFileTypes: true });
-        const skills = await Promise.all(entries
-            .filter((entry) => entry.isDirectory())
-            .map(async (entry) => {
-            const skillPath = path.join(directory, entry.name, 'SKILL.md');
-            if (!(await pathExists(skillPath))) {
-                return null;
-            }
-            const content = await fs.readFile(skillPath, 'utf8');
-            return {
-                name: entry.name,
-                description: extractMarkdownDescription(content),
-                path: skillPath,
-                source: 'skill',
-            };
-        }));
-        return skills.filter((skill) => skill !== null);
-    }
-    async readCommands(directory) {
-        if (!(await pathExists(directory))) {
-            return [];
-        }
-        const commandFiles = await collectMarkdownFiles(directory);
-        const commands = await Promise.all(commandFiles.map(async (commandPath) => {
-            const content = await fs.readFile(commandPath, 'utf8');
-            return {
-                name: path.basename(commandPath, path.extname(commandPath)),
-                description: extractMarkdownDescription(content),
-                source: 'command',
-                path: commandPath,
-            };
-        }));
-        return commands.sort((left, right) => left.name.localeCompare(right.name));
-    }
-    async readSettings(claudeDirectory) {
-        const candidatePaths = [
-            path.join(claudeDirectory, 'settings.json'),
-            path.join(claudeDirectory, 'settings.local.json'),
-        ];
-        const settingsPaths = [];
-        const hooks = [];
-        for (const candidatePath of candidatePaths) {
-            if (!(await pathExists(candidatePath))) {
-                continue;
-            }
-            settingsPaths.push(candidatePath);
-            const content = await fs.readFile(candidatePath, 'utf8');
-            const parsed = JSON5.parse(content);
-            const hookEntries = Object.entries(parsed.hooks ?? {});
-            for (const [hookName, hookValue] of hookEntries) {
-                const hookMatchers = Array.isArray(hookValue) ? hookValue : [hookValue];
-                for (const hookMatcher of hookMatchers) {
-                    if (!hookMatcher || typeof hookMatcher !== 'object') {
-                        continue;
-                    }
-                    const matcher = typeof hookMatcher.matcher === 'string'
-                        ? hookMatcher.matcher
-                        : undefined;
-                    const commandCount = Array.isArray(hookMatcher.hooks)
-                        ? (hookMatcher.hooks?.length ?? 0)
-                        : 0;
-                    hooks.push({
-                        name: hookName,
-                        matcher,
-                        sourcePath: candidatePath,
-                        commandCount,
-                    });
-                }
-            }
-        }
-        return {
-            settingsPaths,
-            hooks,
-        };
-    }
-}
-function extractMarkdownDescription(markdown) {
-    const lines = markdown
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const descriptionLine = lines.find((line) => !line.startsWith('#') && !line.startsWith('---'));
-    return descriptionLine ?? 'No description provided.';
-}
-async function collectMarkdownFiles(directory) {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const files = await Promise.all(entries.map(async (entry) => {
-        const resolvedPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-            return collectMarkdownFiles(resolvedPath);
-        }
-        return entry.name.endsWith('.md') ? [resolvedPath] : [];
-    }));
-    return files.flat();
-}
-async function pathExists(candidatePath) {
-    try {
-        await fs.access(candidatePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function findFirstExistingPath(candidatePaths) {
-    for (const candidatePath of candidatePaths) {
-        if (await pathExists(candidatePath)) {
-            return candidatePath;
-        }
-    }
-    return null;
-}
-function skillsToCommands(skills) {
-    return skills.map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-        source: 'skill',
-        path: skill.path,
-    }));
-}

package/dist/plugin/orchestrator.plugin.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-export declare const OrchestratorPlugin: Plugin;

package/dist/plugin/orchestrator.plugin.js

@@ -1,116 +0,0 @@
-import { prompts } from '../prompts/registry.js';
-import { evaluateBashCommand, extractBashCommand, } from '../safety/bash-safety.js';
-/**
- * Thin OpenCode orchestrator plugin with Claude Code specialist subagents.
- *
- * - Registers `claude-code` provider via a local shim over ai-sdk-provider-claude-code.
- * - Creates one orchestrator agent (uses the user's default OpenCode model).
- * - Creates 4 Claude Code subagents: planning + build × opus + sonnet.
- * - Enforces bash safety via the permission.ask hook.
- *
- * NOTE: Claude Code `effort` is not configurable through OpenCode provider/model
- * options at this time. The subagent prompts compensate by setting high-quality
- * expectations directly.
- */
-// Resolve the shim path at module load time so it is stable for the lifetime
-// of the process. The compiled output for this file sits at dist/plugin/ and
-// the shim at dist/providers/, so we walk up one level.
-const claudeCodeShimUrl = new URL('../providers/claude-code-wrapper.js', import.meta.url).href;
-export const OrchestratorPlugin = async () => {
-    return {
-        config: async (config) => {
-            config.provider ??= {};
-            config.agent ??= {};
-            // ── Provider ──────────────────────────────────────────────────────
-            // Uses a file:// shim so OpenCode's factory-finder heuristic sees only
-            // createClaudeCode and not createAPICallError from the upstream package.
-            config.provider['claude-code'] ??= {
-                npm: claudeCodeShimUrl,
-                models: {
-                    opus: {
-                        id: 'opus',
-                        name: 'Claude Code Opus 4.6',
-                    },
-                    sonnet: {
-                        id: 'sonnet',
-                        name: 'Claude Code Sonnet 4.6',
-                    },
-                },
-            };
-            // ── Orchestrator (uses user's default model — no model set) ───────
-            config.agent['opencode-orchestrator'] ??= {
-                description: 'CTO-level orchestrator that gathers context and delegates coding to Claude Code specialists.',
-                mode: 'primary',
-                color: '#D97757',
-                prompt: prompts.orchestrator,
-                permission: {
-                    '*': 'deny',
-                    read: 'allow',
-                    grep: 'allow',
-                    glob: 'allow',
-                    list: 'allow',
-                    webfetch: 'allow',
-                    question: 'allow',
-                    todowrite: 'allow',
-                    todoread: 'allow',
-                    task: 'allow',
-                    bash: 'deny',
-                    edit: 'deny',
-                    skill: 'deny',
-                },
-            };
-            // ── Planning subagents ────────────────────────────────────────────
-            // Claude Code tools (Bash, Read, Write, Edit, …) are executed internally
-            // by the claude CLI subprocess and streamed back with providerExecuted:true.
-            // OpenCode's own tools must not be advertised to these agents.
-            const claudeCodePermissions = {
-                '*': 'deny',
-            };
-            config.agent['claude-code-planning-opus'] ??= {
-                description: 'Claude Code Opus specialist for investigation, architecture, and planning.',
-                model: 'claude-code/opus',
-                mode: 'subagent',
-                color: 'info',
-                prompt: prompts.planningAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            config.agent['claude-code-planning-sonnet'] ??= {
-                description: 'Claude Code Sonnet specialist for lighter investigation and planning.',
-                model: 'claude-code/sonnet',
-                mode: 'subagent',
-                color: 'info',
-                prompt: prompts.planningAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            // ── Build subagents ───────────────────────────────────────────────
-            config.agent['claude-code-build-opus'] ??= {
-                description: 'Claude Code Opus specialist for implementation and validation.',
-                model: 'claude-code/opus',
-                mode: 'subagent',
-                color: 'success',
-                prompt: prompts.buildAgent,
-                permission: { ...claudeCodePermissions },
-            };
-            config.agent['claude-code-build-sonnet'] ??= {
-                description: 'Claude Code Sonnet specialist for lighter implementation tasks.',
-                model: 'claude-code/sonnet',
-                mode: 'subagent',
-                color: 'success',
-                prompt: prompts.buildAgent,
-                permission: { ...claudeCodePermissions },
-            };
-        },
-        // ── Bash safety via permission.ask hook ────────────────────────────
-        // Handles both v1 Permission ({ type, pattern }) and v2 PermissionRequest
-        // ({ permission, patterns }) via runtime narrowing in extractBashCommand.
-        'permission.ask': async (input, output) => {
-            const command = extractBashCommand(input);
-            if (command === null)
-                return;
-            const result = evaluateBashCommand(command);
-            if (!result.allowed) {
-                output.status = 'deny';
-            }
-        },
-    };
-};

package/dist/providers/claude-code-wrapper.d.ts

@@ -1,13 +0,0 @@
-/**
- * Thin re-export shim for ai-sdk-provider-claude-code.
- *
- * OpenCode's provider loader finds the provider factory by scanning
- * `Object.keys(module).find(key => key.startsWith("create"))`. The upstream
- * package exports `createAPICallError` before `createClaudeCode`, so OpenCode
- * picks the wrong function and `.languageModel` ends up undefined.
- *
- * This shim re-exports only `createClaudeCode`, making it the sole "create*"
- * export. The plugin references this file via a `file://` URL so the upstream
- * package is still the actual implementation.
- */
-export { createClaudeCode } from 'ai-sdk-provider-claude-code';

package/dist/providers/claude-code-wrapper.js

@@ -1,13 +0,0 @@
-/**
- * Thin re-export shim for ai-sdk-provider-claude-code.
- *
- * OpenCode's provider loader finds the provider factory by scanning
- * `Object.keys(module).find(key => key.startsWith("create"))`. The upstream
- * package exports `createAPICallError` before `createClaudeCode`, so OpenCode
- * picks the wrong function and `.languageModel` ends up undefined.
- *
- * This shim re-exports only `createClaudeCode`, making it the sole "create*"
- * export. The plugin references this file via a `file://` URL so the upstream
- * package is still the actual implementation.
- */
-export { createClaudeCode } from 'ai-sdk-provider-claude-code';

package/dist/safety/bash-safety.d.ts

@@ -1,21 +0,0 @@
-/**
- * Minimal bash command safety layer.
- * Denies known-dangerous patterns; allows everything else.
- */
-export type BashSafetyResult = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-export declare function evaluateBashCommand(command: string): BashSafetyResult;
-/**
- * Extract the bash command string from a permission hook input,
- * handling both SDK payload shapes:
- *
- *   v1 Permission:       { type: string, pattern?: string | string[], metadata }
- *   v2 PermissionRequest: { permission: string, patterns: string[], metadata }
- *
- * Returns `null` when the input is not a bash permission request.
- */
-export declare function extractBashCommand(input: Record<string, unknown>): string | null;

package/dist/safety/bash-safety.js

@@ -1,62 +0,0 @@
-/**
- * Minimal bash command safety layer.
- * Denies known-dangerous patterns; allows everything else.
- */
-const DENY_PATTERNS = [
-    { pattern: 'rm -rf /', reason: 'Destructive: rm -rf / is not allowed.' },
-    {
-        pattern: 'git push --force',
-        reason: 'Force push is not allowed.',
-    },
-    {
-        pattern: 'git reset --hard',
-        reason: 'git reset --hard is not allowed. Use a safer alternative.',
-    },
-];
-export function evaluateBashCommand(command) {
-    for (const { pattern, reason } of DENY_PATTERNS) {
-        if (command.includes(pattern)) {
-            return { allowed: false, reason };
-        }
-    }
-    return { allowed: true };
-}
-/**
- * Extract the bash command string from a permission hook input,
- * handling both SDK payload shapes:
- *
- *   v1 Permission:       { type: string, pattern?: string | string[], metadata }
- *   v2 PermissionRequest: { permission: string, patterns: string[], metadata }
- *
- * Returns `null` when the input is not a bash permission request.
- */
-export function extractBashCommand(input) {
-    // Determine the permission kind from whichever field is present.
-    const kind = typeof input['permission'] === 'string'
-        ? input['permission']
-        : typeof input['type'] === 'string'
-            ? input['type']
-            : null;
-    if (kind !== 'bash')
-        return null;
-    // Prefer an explicit command in metadata regardless of shape.
-    const meta = input['metadata'];
-    if (meta !== null && typeof meta === 'object' && !Array.isArray(meta)) {
-        const cmd = meta['command'];
-        if (typeof cmd === 'string' && cmd.length > 0)
-            return cmd;
-    }
-    // v2: patterns is always string[]
-    const patterns = input['patterns'];
-    if (Array.isArray(patterns) && patterns.length > 0) {
-        return patterns.join(' ');
-    }
-    // v1: pattern may be string or string[]
-    const pattern = input['pattern'];
-    if (typeof pattern === 'string' && pattern.length > 0)
-        return pattern;
-    if (Array.isArray(pattern) && pattern.length > 0) {
-        return pattern.join(' ');
-    }
-    return null;
-}

package/dist/src/claude/claude-agent-sdk-adapter.d.ts

@@ -1,28 +0,0 @@
-import { type Options, type Query, type SDKSessionInfo, type SessionMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { ClaudeSessionEvent, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
-import type { ToolApprovalManager } from './tool-approval-manager.js';
-export type ClaudeSessionEventHandler = (event: ClaudeSessionEvent) => void | Promise<void>;
-interface ClaudeAgentSdkFacade {
-    query(params: {
-        prompt: string;
-        options?: Options;
-    }): Query;
-    listSessions(options?: {
-        dir?: string;
-    }): Promise<SDKSessionInfo[]>;
-    getSessionMessages(sessionId: string, options?: {
-        dir?: string;
-    }): Promise<SessionMessage[]>;
-}
-export declare class ClaudeAgentSdkAdapter {
-    private readonly sdkFacade;
-    private readonly approvalManager?;
-    private readonly debugLogPath?;
-    constructor(sdkFacade?: ClaudeAgentSdkFacade, approvalManager?: ToolApprovalManager | undefined, debugLogPath?: string | undefined);
-    runSession(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    listSavedSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
-    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
-    private buildOptions;
-    private logDeniedTool;
-}
-export {};