agentpacks 0.2.0

package/dist/targets/opencode.d.ts

@@ -0,0 +1,13 @@
+import type { FeatureId } from '../core/config.js';
+import { BaseTarget, type GenerateOptions, type GenerateResult } from './base-target.js';
+/**
+ * OpenCode target generator.
+ * Generates: opencode.json, .opencode/agent/, .opencode/skill/, .opencode/command/,
+ * .opencode/plugins/agentpacks-<pack>.ts, AGENTS.md rules
+ */
+export declare class OpenCodeTarget extends BaseTarget {
+    readonly id = "opencode";
+    readonly name = "OpenCode";
+    readonly supportedFeatures: FeatureId[];
+    generate(options: GenerateOptions): GenerateResult;
+}

package/dist/targets/opencode.js

@@ -0,0 +1,556 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/utils/filesystem.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync
+} from "fs";
+import { dirname, relative, join } from "path";
+import { removeSync } from "fs-extra";
+var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
+var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
+var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
+function writeGeneratedFile(filepath, content, options = {}) {
+  const { header = true, type } = options;
+  const ext = type ?? inferFileType(filepath);
+  ensureDir(dirname(filepath));
+  let output = content;
+  if (header) {
+    const headerComment = getHeader(ext);
+    if (headerComment) {
+      output = `${headerComment}
+${content}`;
+    }
+  }
+  writeFileSync(filepath, output, "utf-8");
+}
+function writeGeneratedJson(filepath, data, options = {}) {
+  const json = JSON.stringify(data, null, 2);
+  writeGeneratedFile(filepath, json + `
+`, { ...options, type: "json" });
+}
+function readFileOrNull(filepath) {
+  if (!existsSync(filepath))
+    return null;
+  return readFileSync(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync(targetPath)) {
+    removeSync(targetPath);
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync(dirPath))
+    return [];
+  const results = [];
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && recursive) {
+      results.push(...listFiles(fullPath, options));
+    } else if (stat.isFile()) {
+      if (!extension || entry.endsWith(extension)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+function listDirs(dirPath) {
+  if (!existsSync(dirPath))
+    return [];
+  return readdirSync(dirPath).map((entry) => join(dirPath, entry)).filter((fullPath) => statSync(fullPath).isDirectory());
+}
+function relPath(projectRoot, filepath) {
+  return relative(projectRoot, filepath);
+}
+function isGeneratedFile(filepath) {
+  const content = readFileOrNull(filepath);
+  if (!content)
+    return false;
+  return content.startsWith(GENERATED_HEADER_MD) || content.startsWith(GENERATED_HEADER_JSON) || content.startsWith(GENERATED_HEADER_JS);
+}
+function inferFileType(filepath) {
+  if (filepath.endsWith(".json") || filepath.endsWith(".jsonc"))
+    return "json";
+  if (filepath.endsWith(".ts") || filepath.endsWith(".mts"))
+    return "ts";
+  if (filepath.endsWith(".js") || filepath.endsWith(".mjs"))
+    return "js";
+  return "md";
+}
+function getHeader(type) {
+  switch (type) {
+    case "md":
+      return GENERATED_HEADER_MD;
+    case "json":
+      return GENERATED_HEADER_JSON;
+    case "js":
+    case "ts":
+      return GENERATED_HEADER_JS;
+    default:
+      return null;
+  }
+}
+
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(source) {
+  const { data, content } = matter(source);
+  return {
+    data,
+    content: content.trim(),
+    raw: source
+  };
+}
+function serializeFrontmatter(data, content) {
+  const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+  if (Object.keys(filtered).length === 0) {
+    return content;
+  }
+  return matter.stringify(content, filtered);
+}
+
+// src/features/rules.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+function parseRules(rulesDir, packName) {
+  const files = listFiles(rulesDir, { extension: ".md" });
+  return files.map((filepath) => parseRuleFile(filepath, packName));
+}
+function parseRuleFile(filepath, packName) {
+  const raw = readFileSync2(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function ruleMatchesTarget(rule, targetId) {
+  const { targets } = rule.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+function getRootRules(rules) {
+  return rules.filter((r) => r.meta.root === true);
+}
+function getDetailRules(rules) {
+  return rules.filter((r) => r.meta.root !== true);
+}
+
+// src/features/commands.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename as basename2 } from "path";
+function parseCommands(commandsDir, packName) {
+  const files = listFiles(commandsDir, { extension: ".md" });
+  return files.map((filepath) => parseCommandFile(filepath, packName));
+}
+function parseCommandFile(filepath, packName) {
+  const raw = readFileSync3(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename2(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function commandMatchesTarget(cmd, targetId) {
+  const { targets } = cmd.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
+// src/features/agents.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename3 } from "path";
+function parseAgents(agentsDir, packName) {
+  const files = listFiles(agentsDir, { extension: ".md" });
+  return files.map((filepath) => parseAgentFile(filepath, packName));
+}
+function parseAgentFile(filepath, packName) {
+  const raw = readFileSync4(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: data.name ?? basename3(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function agentMatchesTarget(agent, targetId) {
+  const { targets } = agent.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
+// src/features/skills.ts
+import { readFileSync as readFileSync5, existsSync as existsSync2 } from "fs";
+import { basename as basename4, join as join2 } from "path";
+function parseSkills(skillsDir, packName) {
+  const dirs = listDirs(skillsDir);
+  const skills = [];
+  for (const dir of dirs) {
+    const skillMd = join2(dir, "SKILL.md");
+    if (existsSync2(skillMd)) {
+      skills.push(parseSkillFile(skillMd, dir, packName));
+    }
+  }
+  return skills;
+}
+function parseSkillFile(filepath, skillDir, packName) {
+  const raw = readFileSync5(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: data.name ?? basename4(skillDir),
+    sourcePath: filepath,
+    sourceDir: skillDir,
+    packName,
+    meta: data,
+    content
+  };
+}
+function skillMatchesTarget(skill, targetId) {
+  const { targets } = skill.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
+// src/features/hooks.ts
+import { join as join3 } from "path";
+var TARGET_OVERRIDE_KEYS = ["cursor", "claudecode", "opencode"];
+function parseHooks(packDir, packName) {
+  const hooksPath = join3(packDir, "hooks", "hooks.json");
+  const raw = readJsonOrNull(hooksPath);
+  if (!raw)
+    return null;
+  const shared = raw.hooks ?? {};
+  const targetOverrides = {};
+  for (const key of TARGET_OVERRIDE_KEYS) {
+    const override = raw[key];
+    if (override && typeof override === "object" && "hooks" in override && override.hooks) {
+      targetOverrides[key] = override.hooks;
+    }
+  }
+  return {
+    packName,
+    sourcePath: hooksPath,
+    version: raw.version,
+    shared,
+    targetOverrides
+  };
+}
+function resolveHooksForTarget(hooks, targetId) {
+  const merged = {};
+  for (const [event, entries] of Object.entries(hooks.shared)) {
+    merged[event] = [...entries];
+  }
+  const overrides = hooks.targetOverrides[targetId];
+  if (overrides) {
+    for (const [event, entries] of Object.entries(overrides)) {
+      merged[event] = [...merged[event] ?? [], ...entries];
+    }
+  }
+  return merged;
+}
+
+// src/targets/base-target.ts
+class BaseTarget {
+  supportsFeature(feature) {
+    return this.supportedFeatures.includes(feature);
+  }
+  getEffectiveFeatures(enabledFeatures) {
+    return enabledFeatures.filter((f) => this.supportsFeature(f));
+  }
+  createResult(filesWritten = [], filesDeleted = [], warnings = []) {
+    return {
+      targetId: this.id,
+      filesWritten,
+      filesDeleted,
+      warnings
+    };
+  }
+}
+
+// src/utils/markdown.ts
+function stripGeneratedHeader(content) {
+  return content.replace(/^<!-- Generated by agentpacks.*-->\n/, "").replace(/^\/\/ Generated by agentpacks.*\n/, "");
+}
+function packNameToIdentifier(packName) {
+  return packName.split(/[-_.]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function extractFirstHeading(content) {
+  const match = content.match(/^#{1,6}\s+(.+)$/m);
+  return match?.[1]?.trim() ?? null;
+}
+function combineMarkdown(sections, separator = `
+
+---
+
+`) {
+  return sections.filter(Boolean).join(separator);
+}
+function wrapSection(heading, content, level = 2) {
+  const prefix = "#".repeat(level);
+  return `${prefix} ${heading}
+
+${content}`;
+}
+
+// src/targets/opencode.ts
+import { resolve as resolve2, join as join4 } from "path";
+var TARGET_ID = "opencode";
+
+class OpenCodeTarget extends BaseTarget {
+  id = TARGET_ID;
+  name = "OpenCode";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "plugins",
+    "mcp",
+    "ignore"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve2(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const opencodeDir = resolve2(root, ".opencode");
+    if (effective.includes("agents")) {
+      const agentDir = resolve2(opencodeDir, "agent");
+      if (deleteExisting) {
+        removeIfExists(agentDir);
+        filesDeleted.push(agentDir);
+      }
+      ensureDir(agentDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID));
+      for (const agent of agents) {
+        const filepath = join4(agentDir, `${agent.name}.md`);
+        writeGeneratedFile(filepath, agent.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillDir = resolve2(opencodeDir, "skill");
+      if (deleteExisting) {
+        removeIfExists(skillDir);
+        filesDeleted.push(skillDir);
+      }
+      ensureDir(skillDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID));
+      for (const skill of skills) {
+        const skillSubDir = join4(skillDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join4(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, skill.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const cmdDir = resolve2(opencodeDir, "command");
+      if (deleteExisting) {
+        removeIfExists(cmdDir);
+        filesDeleted.push(cmdDir);
+      }
+      ensureDir(cmdDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID));
+      for (const cmd of commands) {
+        const filepath = join4(cmdDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("hooks") || effective.includes("plugins")) {
+      const pluginsDir = resolve2(opencodeDir, "plugins");
+      ensureDir(pluginsDir);
+      if (effective.includes("hooks")) {
+        for (const hookSet of features.hooks) {
+          const events = resolveHooksForTarget(hookSet, TARGET_ID);
+          if (Object.keys(events).length > 0) {
+            const filepath = join4(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
+            const content = generateOpenCodeHookPlugin(hookSet.packName, events);
+            writeGeneratedFile(filepath, content, { type: "ts" });
+            filesWritten.push(filepath);
+          }
+        }
+      }
+      if (effective.includes("plugins")) {
+        for (const plugin of features.plugins) {
+          const filepath = join4(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
+          writeGeneratedFile(filepath, plugin.content, {
+            type: plugin.extension
+          });
+          filesWritten.push(filepath);
+        }
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const opencodeConfig = buildOpenCodeMcp(features.mcpServers);
+        const filepath = resolve2(root, "opencode.json");
+        writeGeneratedJson(filepath, opencodeConfig, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("rules")) {
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID));
+      const rootRules = getRootRules(rules);
+      const detailRules = getDetailRules(rules);
+      if (detailRules.length > 0) {
+        const memoriesDir = resolve2(opencodeDir, "memories");
+        if (deleteExisting) {
+          removeIfExists(memoriesDir);
+          filesDeleted.push(memoriesDir);
+        }
+        ensureDir(memoriesDir);
+        for (const rule of detailRules) {
+          const filepath = join4(memoriesDir, `${rule.name}.md`);
+          writeGeneratedFile(filepath, rule.content);
+          filesWritten.push(filepath);
+        }
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildOpenCodeMcp(servers) {
+  const mcp = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.url) {
+      mcp[name] = {
+        type: "remote",
+        url: entry.url,
+        enabled: true,
+        ...entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}
+      };
+    } else if (entry.command) {
+      const cmd = entry.args ? [entry.command, ...entry.args] : [entry.command];
+      mcp[name] = {
+        type: "local",
+        command: cmd,
+        enabled: true,
+        ...entry.env && Object.keys(entry.env).length > 0 ? { environment: entry.env } : {}
+      };
+    }
+  }
+  return {
+    $schema: "https://opencode.ai/config.json",
+    mcp
+  };
+}
+function generateOpenCodeHookPlugin(packName, events) {
+  const identifier = packNameToIdentifier(packName);
+  const hookMap = mapHookEvents(events);
+  const hookEntries = Object.entries(hookMap).map(([event, handlers]) => {
+    const body = handlers.map((h) => {
+      const matcherGuard = h.matcher ? `if (!/(?:${h.matcher})/.test(String(input?.tool ?? ""))) return;
+      ` : "";
+      return `      ${matcherGuard}await $\`${h.command}\`;`;
+    }).join(`
+`);
+    return `    "${event}": async (input, output) => {
+${body}
+    },`;
+  }).join(`
+`);
+  return `import type { Plugin } from "@opencode-ai/plugin";
+
+export const ${identifier}Plugin: Plugin = async ({ project, client, $, directory, worktree }) => {
+  return {
+${hookEntries}
+  };
+};
+`;
+}
+function mapHookEvents(events) {
+  const mapped = {};
+  const eventMapping = {
+    sessionStart: "session.created",
+    postToolUse: "tool.execute.after",
+    preToolUse: "tool.execute.before",
+    stop: "session.idle",
+    afterFileEdit: "file.edited",
+    afterShellExecution: "command.executed"
+  };
+  for (const [event, handlers] of Object.entries(events)) {
+    const opencodeEvent = eventMapping[event] ?? event;
+    if (!mapped[opencodeEvent]) {
+      mapped[opencodeEvent] = [];
+    }
+    mapped[opencodeEvent].push(...handlers.filter((h) => h.command));
+  }
+  return mapped;
+}
+export {
+  OpenCodeTarget
+};

package/dist/targets/registry.d.ts

@@ -0,0 +1,17 @@
+import type { BaseTarget } from './base-target.js';
+/**
+ * Get a target by its identifier.
+ */
+export declare function getTarget(id: string): BaseTarget | undefined;
+/**
+ * Get all registered targets.
+ */
+export declare function getAllTargets(): BaseTarget[];
+/**
+ * Get targets by their identifiers. Returns targets in the given order.
+ */
+export declare function getTargets(ids: string[]): BaseTarget[];
+/**
+ * List all available target identifiers.
+ */
+export declare function listTargetIds(): string[];