@doingdev/opencode-claude-manager-plugin 0.1.22 → 0.1.26

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

@@ -0,0 +1,154 @@
+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/agent-hierarchy.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Agent hierarchy configuration for the CTO → Manager → Engineer architecture.
+ *
+ * CTO (cto)       — direction-setting, orchestration, spawns managers
+ * Manager (manager) — operates Claude Code engineer via persistent session
+ * Engineer          — the Claude Code session itself (prompt only, no OpenCode agent)
+ */
+import type { ManagerPromptRegistry } from '../types/contracts.js';
+export declare const AGENT_CTO = "cto";
+export declare const AGENT_MANAGER = "manager";
+/** All restricted tool IDs (union of engineer + git + approval) */
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["engineer_send", "engineer_compact", "engineer_clear", "engineer_status", "engineer_metadata", "engineer_sessions", "engineer_runs", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+type ToolPermission = 'allow' | 'ask' | 'deny';
+type AgentPermission = {
+    '*'?: ToolPermission;
+    read?: ToolPermission;
+    grep?: ToolPermission;
+    glob?: ToolPermission;
+    codesearch?: ToolPermission;
+    webfetch?: ToolPermission;
+    websearch?: ToolPermission;
+    /** OpenCode built-in: manage session todo list */
+    todowrite?: ToolPermission;
+    /** OpenCode built-in: read session todo list */
+    todoread?: ToolPermission;
+    /** OpenCode built-in: ask the user structured questions with options */
+    question?: ToolPermission;
+    bash?: ToolPermission | Record<string, ToolPermission>;
+    [tool: string]: ToolPermission | Record<string, ToolPermission> | undefined;
+};
+export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "primary";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+export declare function buildManagerAgentConfig(prompts: ManagerPromptRegistry): {
+    description: string;
+    mode: "subagent";
+    color: string;
+    permission: AgentPermission;
+    prompt: string;
+};
+/** Deny all restricted tools at the global level so only designated agents can use them. */
+export declare function denyRestrictedToolsGlobally(permissions: Record<string, ToolPermission>): void;
+export {};

package/dist/plugin/agent-hierarchy.js

@@ -0,0 +1,110 @@
+/**
+ * Agent hierarchy configuration for the CTO → Manager → Engineer architecture.
+ *
+ * CTO (cto)       — direction-setting, orchestration, spawns managers
+ * Manager (manager) — operates Claude Code engineer via persistent session
+ * Engineer          — the Claude Code session itself (prompt only, no OpenCode agent)
+ */
+// ---------------------------------------------------------------------------
+// Agent names
+// ---------------------------------------------------------------------------
+export const AGENT_CTO = 'cto';
+export const AGENT_MANAGER = 'manager';
+// ---------------------------------------------------------------------------
+// Tool IDs — grouped by domain
+// ---------------------------------------------------------------------------
+/** Engineer-facing session tools */
+const ENGINEER_TOOL_IDS = [
+    'engineer_send',
+    'engineer_compact',
+    'engineer_clear',
+    'engineer_status',
+    'engineer_metadata',
+    'engineer_sessions',
+    'engineer_runs',
+];
+/** Git tools */
+const GIT_TOOL_IDS = ['git_diff', 'git_commit', 'git_reset'];
+/** Approval tools */
+const APPROVAL_TOOL_IDS = [
+    'approval_policy',
+    'approval_decisions',
+    'approval_update',
+];
+/** All restricted tool IDs (union of engineer + git + approval) */
+export const ALL_RESTRICTED_TOOL_IDS = [
+    ...ENGINEER_TOOL_IDS,
+    ...GIT_TOOL_IDS,
+    ...APPROVAL_TOOL_IDS,
+];
+// ---------------------------------------------------------------------------
+// Shared read-only tool permissions
+// ---------------------------------------------------------------------------
+const READONLY_TOOLS = {
+    read: 'allow',
+    grep: 'allow',
+    glob: 'allow',
+    codesearch: 'allow',
+    webfetch: 'allow',
+    websearch: 'allow',
+    todowrite: 'allow',
+    todoread: 'allow',
+    question: 'allow',
+};
+// ---------------------------------------------------------------------------
+// Permission builders
+// ---------------------------------------------------------------------------
+/** CTO: orchestration only — explicitly denies every restricted tool, no edit, no bash. */
+function buildCtoPermissions() {
+    const denied = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        denied[toolId] = 'deny';
+    }
+    return {
+        '*': 'deny',
+        ...READONLY_TOOLS,
+        ...denied,
+    };
+}
+/** Manager: full restricted tool surface + read-only codebase tools. No edit, no bash. */
+function buildManagerPermissions() {
+    const allowed = {};
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        allowed[toolId] = 'allow';
+    }
+    return {
+        '*': 'deny',
+        ...READONLY_TOOLS,
+        ...allowed,
+    };
+}
+// ---------------------------------------------------------------------------
+// Agent config builders
+// ---------------------------------------------------------------------------
+export function buildCtoAgentConfig(prompts) {
+    return {
+        description: 'CTO agent that sets direction and orchestrates work by spawning manager subagents. Does not operate Claude Code directly.',
+        mode: 'primary',
+        color: '#D97757',
+        permission: buildCtoPermissions(),
+        prompt: prompts.ctoSystemPrompt,
+    };
+}
+export function buildManagerAgentConfig(prompts) {
+    return {
+        description: 'Manager agent that operates Claude Code through a persistent session, reviews work via git diff, and commits/resets changes.',
+        mode: 'subagent',
+        color: '#D97757',
+        permission: buildManagerPermissions(),
+        prompt: prompts.managerSystemPrompt,
+    };
+}
+// ---------------------------------------------------------------------------
+// Global permission helper
+// ---------------------------------------------------------------------------
+/** Deny all restricted tools at the global level so only designated agents can use them. */
+export function denyRestrictedToolsGlobally(permissions) {
+    for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+        permissions[toolId] ??= 'deny';
+    }
+}

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

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