opencode-froggy 0.1.0

package/dist/loaders.d.ts

@@ -0,0 +1,80 @@
+export interface AgentFrontmatter {
+    description: string;
+    mode?: "subagent" | "agent";
+    temperature?: number;
+    tools?: Record<string, boolean>;
+    permission?: Record<string, unknown>;
+    permissions?: Record<string, unknown>;
+}
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+}
+export interface CommandFrontmatter {
+    description: string;
+    agent?: string;
+    model?: string;
+}
+export interface CommandConfig {
+    template: string;
+    description?: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+}
+export interface LoadedSkill {
+    name: string;
+    description: string;
+    path: string;
+    body: string;
+}
+export type HookEvent = "session.idle" | "session.created" | "session.deleted" | `tool.before.${string}` | `tool.after.${string}`;
+export type HookCondition = "isMainSession" | "hasCodeChange";
+export interface HookActionCommand {
+    command: string | {
+        name: string;
+        args: string;
+    };
+}
+export interface HookActionSkill {
+    skill: string;
+}
+export interface HookActionTool {
+    tool: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+}
+export interface HookActionBash {
+    bash: string | {
+        command: string;
+        timeout?: number;
+    };
+}
+export type HookAction = HookActionCommand | HookActionSkill | HookActionTool | HookActionBash;
+export interface HookConfig {
+    event: HookEvent;
+    conditions?: HookCondition[];
+    actions: HookAction[];
+}
+export interface AgentConfigOutput {
+    description: string;
+    mode: "subagent" | "primary" | "all";
+    temperature?: number;
+    tools?: Record<string, boolean>;
+    permissions?: Record<string, unknown>;
+    prompt: string;
+    [key: string]: unknown;
+}
+export declare function parseFrontmatter<T>(content: unknown): {
+    data: T;
+    body: string;
+};
+export declare function loadAgents(agentDir: string): Record<string, AgentConfigOutput>;
+export declare function loadSkills(skillDir: string): LoadedSkill[];
+export declare function loadCommands(commandDir: string): Record<string, CommandConfig>;
+export declare function loadHooks(hookDir: string): Map<HookEvent, HookConfig[]>;
+export declare function mergeHooks(...hookMaps: Map<HookEvent, HookConfig[]>[]): Map<HookEvent, HookConfig[]>;

package/dist/loaders.js

@@ -0,0 +1,135 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import yaml from "js-yaml";
+const SESSION_HOOK_EVENTS = ["session.idle", "session.created", "session.deleted"];
+const TOOL_HOOK_PATTERN = /^tool\.(before|after)\..+$/;
+// ============================================================================
+// UTILITIES
+// ============================================================================
+export function parseFrontmatter(content) {
+    if (typeof content !== "string") {
+        return { data: {}, body: "" };
+    }
+    const match = content.match(/^---\r?\n([\s\S]*?)(?:\r?\n)?---(?:\r?\n)?([\s\S]*)$/);
+    if (!match) {
+        return { data: {}, body: content };
+    }
+    try {
+        const yamlContent = match[1].trim();
+        const parsed = yamlContent ? yaml.load(yamlContent) : null;
+        return { data: parsed ?? {}, body: match[2] };
+    }
+    catch {
+        return { data: {}, body: content };
+    }
+}
+// ============================================================================
+// LOADERS
+// ============================================================================
+export function loadAgents(agentDir) {
+    if (!existsSync(agentDir))
+        return {};
+    const agents = {};
+    for (const file of readdirSync(agentDir)) {
+        if (!file.endsWith(".md"))
+            continue;
+        const filePath = join(agentDir, file);
+        const content = readFileSync(filePath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        const agentName = basename(file, ".md");
+        const mode = data.mode === "agent" ? "primary" : "subagent";
+        const permissions = data.permissions ?? data.permission;
+        agents[agentName] = {
+            description: data.description || "",
+            mode,
+            prompt: body.trim(),
+            ...(data.temperature !== undefined && { temperature: data.temperature }),
+            ...(data.tools !== undefined && { tools: data.tools }),
+            ...(permissions !== undefined && { permissions }),
+        };
+    }
+    return agents;
+}
+export function loadSkills(skillDir) {
+    if (!existsSync(skillDir))
+        return [];
+    const skills = [];
+    for (const entry of readdirSync(skillDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const skillPath = join(skillDir, entry.name, "SKILL.md");
+        if (!existsSync(skillPath))
+            continue;
+        const content = readFileSync(skillPath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        skills.push({
+            name: data.name || entry.name,
+            description: data.description || "",
+            path: skillPath,
+            body: body.trim(),
+        });
+    }
+    return skills;
+}
+export function loadCommands(commandDir) {
+    if (!existsSync(commandDir))
+        return {};
+    const commands = {};
+    for (const file of readdirSync(commandDir)) {
+        if (!file.endsWith(".md"))
+            continue;
+        const filePath = join(commandDir, file);
+        const content = readFileSync(filePath, "utf-8");
+        const { data, body } = parseFrontmatter(content);
+        const commandName = basename(file, ".md");
+        commands[commandName] = {
+            description: data.description || "",
+            agent: data.agent,
+            model: data.model,
+            template: body.trim(),
+        };
+    }
+    return commands;
+}
+function isValidHookEvent(event) {
+    return SESSION_HOOK_EVENTS.includes(event) || TOOL_HOOK_PATTERN.test(event);
+}
+export function loadHooks(hookDir) {
+    const hooks = new Map();
+    const hooksFilePath = join(hookDir, "hooks.md");
+    if (!existsSync(hooksFilePath))
+        return hooks;
+    const content = readFileSync(hooksFilePath, "utf-8");
+    const { data } = parseFrontmatter(content);
+    if (!data.hooks || !Array.isArray(data.hooks))
+        return hooks;
+    for (const hookDef of data.hooks) {
+        if (!hookDef.event || !isValidHookEvent(hookDef.event))
+            continue;
+        if (!hookDef.actions || !Array.isArray(hookDef.actions))
+            continue;
+        const hookConfig = {
+            event: hookDef.event,
+            conditions: Array.isArray(hookDef.conditions) ? hookDef.conditions : undefined,
+            actions: hookDef.actions,
+        };
+        const existing = hooks.get(hookDef.event);
+        if (existing) {
+            existing.push(hookConfig);
+        }
+        else {
+            hooks.set(hookDef.event, [hookConfig]);
+        }
+    }
+    return hooks;
+}
+export function mergeHooks(...hookMaps) {
+    const merged = new Map();
+    for (const hookMap of hookMaps) {
+        for (const [event, configs] of hookMap) {
+            const existing = merged.get(event) ?? [];
+            merged.set(event, [...existing, ...configs]);
+        }
+    }
+    return merged;
+}

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function getLogFilePath(): string;

package/dist/logger.js

@@ -0,0 +1,15 @@
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+const LOG_FILE = join(tmpdir(), "opencode-froggy.log");
+export function log(message, data) {
+    try {
+        const timestamp = new Date().toISOString();
+        const entry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}\n`;
+        appendFileSync(LOG_FILE, entry);
+    }
+    catch { }
+}
+export function getLogFilePath() {
+    return LOG_FILE;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "opencode-froggy",
+  "version": "0.1.0",
+  "description": "OpenCode plugin with a hook layer (tool.before.*, session.idle...), agents (code-reviewer, doc-writer), and commands (/review-pr, /commit)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "agent",
+    "command",
+    "skill"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "plugin",
+    "hooks",
+    "code-review",
+    "code-simplification",
+    "ai-agent",
+    "llm",
+    "automation",
+    "developer-tools",
+    "cli"
+  ],
+  "author": "Fred",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/smartfrog/opencode-froggy"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.16"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  }
+}