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

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/claude-code-permission-bridge.d.ts

@@ -1,15 +0,0 @@
-import type { ToolContext } from '@opencode-ai/plugin';
-import type { ManagerSessionCanUseToolFactory } from '../types/contracts.js';
-export interface ClaudeCodePermissionBridge {
-    createCanUseTool: ManagerSessionCanUseToolFactory;
-}
-/**
- * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
- * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
- *
- * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
- * allow with answers set to each question's first option label so the session can proceed;
- * the UI should still show full choices — users needing a different option should answer via
- * the primary agent and re-run.
- */
-export declare function createClaudeCodePermissionBridge(context: ToolContext): ClaudeCodePermissionBridge;

package/dist/plugin/claude-code-permission-bridge.js

@@ -1,184 +0,0 @@
-/**
- * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
- * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
- *
- * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
- * allow with answers set to each question's first option label so the session can proceed;
- * the UI should still show full choices — users needing a different option should answer via
- * the primary agent and re-run.
- */
-export function createClaudeCodePermissionBridge(context) {
-    const queue = createPermissionAskQueue();
-    return {
-        createCanUseTool(scope) {
-            return (toolName, input, options) => queue.enqueue(() => bridgeCanUseTool(context, scope, toolName, input, options));
-        },
-    };
-}
-function createPermissionAskQueue() {
-    let chain = Promise.resolve();
-    return {
-        enqueue(operation) {
-            const resultPromise = chain
-                .catch(() => undefined)
-                .then(operation);
-            chain = resultPromise.then(() => undefined, () => undefined);
-            return resultPromise;
-        },
-    };
-}
-async function bridgeCanUseTool(context, scope, toolName, input, options) {
-    if (options.signal.aborted) {
-        return {
-            behavior: 'deny',
-            message: 'Permission request aborted.',
-            toolUseID: options.toolUseID,
-        };
-    }
-    if (toolName === 'AskUserQuestion') {
-        return handleAskUserQuestion(context, scope, input, options);
-    }
-    const permission = mapClaudeToolToOpenCodePermission(toolName);
-    const patterns = derivePatterns(toolName, input);
-    const metadata = buildMetadata(scope, toolName, input, options);
-    try {
-        await context.ask({
-            permission,
-            patterns,
-            always: [],
-            metadata,
-        });
-        return {
-            behavior: 'allow',
-            updatedInput: input,
-            toolUseID: options.toolUseID,
-        };
-    }
-    catch (error) {
-        return {
-            behavior: 'deny',
-            message: error instanceof Error
-                ? error.message
-                : 'OpenCode permission request was rejected or failed.',
-            toolUseID: options.toolUseID,
-        };
-    }
-}
-async function handleAskUserQuestion(context, scope, input, options) {
-    const questions = input.questions;
-    if (!Array.isArray(questions) || questions.length === 0) {
-        return {
-            behavior: 'deny',
-            message: 'AskUserQuestion invoked without a valid questions array.',
-            toolUseID: options.toolUseID,
-        };
-    }
-    const metadata = {
-        ...buildMetadata(scope, 'AskUserQuestion', input, options),
-        questions,
-        note: 'Claude Code AskUserQuestion: approving proceeds with the first listed option per question unless the host supplies structured replies.',
-    };
-    try {
-        await context.ask({
-            permission: 'question',
-            patterns: [],
-            always: [],
-            metadata,
-        });
-        const answers = buildDefaultAskUserQuestionAnswers(questions);
-        return {
-            behavior: 'allow',
-            updatedInput: {
-                ...input,
-                questions,
-                answers,
-            },
-            toolUseID: options.toolUseID,
-        };
-    }
-    catch (error) {
-        return {
-            behavior: 'deny',
-            message: error instanceof Error
-                ? error.message
-                : 'OpenCode declined or failed the clarifying-question prompt.',
-            toolUseID: options.toolUseID,
-        };
-    }
-}
-function buildDefaultAskUserQuestionAnswers(questions) {
-    const answers = {};
-    for (const raw of questions) {
-        if (!raw || typeof raw !== 'object') {
-            continue;
-        }
-        const entry = raw;
-        const questionText = typeof entry.question === 'string' ? entry.question : '';
-        if (!questionText) {
-            continue;
-        }
-        const options = Array.isArray(entry.options) ? entry.options : [];
-        const first = options[0];
-        const label = first &&
-            typeof first === 'object' &&
-            first !== null &&
-            typeof first.label === 'string'
-            ? first.label
-            : 'Default';
-        answers[questionText] = label;
-    }
-    return answers;
-}
-function mapClaudeToolToOpenCodePermission(toolName) {
-    switch (toolName) {
-        case 'Read':
-            return 'read';
-        case 'Write':
-        case 'Edit':
-        case 'NotebookEdit':
-            return 'edit';
-        case 'Bash':
-            return 'bash';
-        case 'Glob':
-            return 'glob';
-        case 'Grep':
-            return 'grep';
-        case 'Task':
-        case 'Agent':
-            return 'task';
-        case 'WebFetch':
-            return 'webfetch';
-        case 'WebSearch':
-            return 'websearch';
-        default:
-            return 'bash';
-    }
-}
-function derivePatterns(toolName, input) {
-    const filePath = input.file_path ?? input.path;
-    if (typeof filePath === 'string' && filePath.length > 0) {
-        return [filePath];
-    }
-    if (toolName === 'Bash' && typeof input.command === 'string') {
-        return [input.command];
-    }
-    return [];
-}
-function buildMetadata(scope, toolName, input, options) {
-    return {
-        source: 'claude_code',
-        managerRunId: scope.runId,
-        managerPlanId: scope.planId,
-        managerPlanTitle: scope.planTitle,
-        claudeTool: toolName,
-        toolInput: input,
-        toolUseID: options.toolUseID,
-        agentID: options.agentID,
-        title: options.title,
-        displayName: options.displayName,
-        description: options.description,
-        blockedPath: options.blockedPath,
-        decisionReason: options.decisionReason,
-        sdkSuggestions: options.suggestions,
-    };
-}

package/dist/plugin/claude-manager.plugin.d.ts

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