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

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/claude-manager.plugin.d.ts

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