opencastle 0.6.0 → 0.7.0

package/src/cli/adapters/opencode.ts

@@ -0,0 +1,320 @@
+import { resolve, basename } from 'node:path'
+import { mkdir, writeFile, readdir, readFile, unlink, rm } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { copyDir, getOrchestratorRoot, getPluginsRoot, getPluginSkillEntries } from '../copy.js'
+import { scaffoldMcpConfig } from '../mcp.js'
+import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform, getIncludedPluginIds } from '../stack-config.js'
+import type { CopyResults, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
+
+/**
+ * OpenCode adapter.
+ *
+ * Generates AGENTS.md (root instructions) and .opencode/ structure.
+ *
+ *   copilot-instructions.md    → AGENTS.md  (combined with instructions/)
+ *   skills/*\/SKILL.md          → .opencode/skills/<name>.md
+ *   agents/*.agent.md          → .opencode/agents/<name>.md
+ *   agent-workflows/*.md       → .opencode/workflows/<name>.md
+ *   prompts/*.prompt.md        → .opencode/prompts/<name>.md
+ *   customizations/            → .opencode/customizations/  (scaffolded once)
+ *   mcp.json                   → opencode.json  (OpenCode format: type local/remote)
+ */
+
+export const IDE_ID = 'opencode'
+export const IDE_LABEL = 'OpenCode'
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function stripFrontmatter(content: string): string {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  return m ? m[2].trim() : content.trim()
+}
+
+function parseFrontmatterMeta(content: string): Record<string, string> {
+  const m = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!m) return {}
+  const meta: Record<string, string> = {}
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^(\w[\w-]*):\s*['"]?(.+?)['"]?\s*$/)
+    if (kv) meta[kv[1]] = kv[2]
+  }
+  return meta
+}
+
+// ─── Install ──────────────────────────────────────────────────────
+
+export async function install(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig,
+  repoInfo?: RepoInfo
+): Promise<CopyResults> {
+  const srcRoot = getOrchestratorRoot(pkgRoot)
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+
+  const excludedSkills = stack ? getExcludedSkills(stack) : new Set<string>()
+  const excludedAgents = stack ? getExcludedAgents(stack) : new Set<string>()
+
+  // 1. Build AGENTS.md ← instructions/* + agent index + skill index
+  const agentsMd = resolve(projectRoot, 'AGENTS.md')
+  if (!existsSync(agentsMd)) {
+    const sections: string[] = []
+
+    sections.push(
+      '# Project Instructions\n\n' +
+      'All conventions, architecture, and project context are embedded below. ' +
+      'Skills are in `.opencode/skills/` — read them when a task matches. ' +
+      'Agent definitions are in `.opencode/agents/` — read the relevant file when adopting a persona.'
+    )
+
+    // Always-loaded instruction files
+    const instDir = resolve(srcRoot, 'instructions')
+    if (existsSync(instDir)) {
+      for (const file of (await readdir(instDir)).sort()) {
+        if (!file.endsWith('.md')) continue
+        const content = await readFile(resolve(instDir, file), 'utf8')
+        sections.push(
+          `\n---\n\n<!-- Source: instructions/${file} -->\n\n${stripFrontmatter(content)}`
+        )
+      }
+    }
+
+    // Agent reference
+    const agentsDir = resolve(srcRoot, 'agents')
+    if (existsSync(agentsDir)) {
+      const agentLines: string[] = ['\n---\n\n## Agent Definitions\n']
+      agentLines.push(
+        'The following agent personas are available. Adopt the appropriate persona when asked.\n'
+      )
+      for (const file of (await readdir(agentsDir)).sort()) {
+        if (!file.endsWith('.md')) continue
+        if (excludedAgents.has(file)) continue
+        const meta = parseFrontmatterMeta(
+          await readFile(resolve(agentsDir, file), 'utf8')
+        )
+        const name = meta['name'] ?? basename(file, '.agent.md')
+        const desc = meta['description'] ?? ''
+        agentLines.push(`- **${name}**: ${desc}`)
+      }
+      agentLines.push(
+        '\nFull agent definitions are in `.opencode/agents/`. Read the relevant file when adopting a persona.'
+      )
+      sections.push(agentLines.join('\n'))
+    }
+
+    // Skill index
+    const skillsDir = resolve(srcRoot, 'skills')
+    if (existsSync(skillsDir)) {
+      const skillLines: string[] = ['\n---\n\n## Available Skills\n']
+      skillLines.push(
+        'Skills are on-demand knowledge files. Read the file when the task matches.\n'
+      )
+      const subdirs = (
+        await readdir(skillsDir, { withFileTypes: true })
+      ).filter((e) => e.isDirectory())
+      for (const entry of subdirs.sort((a, b) =>
+        a.name.localeCompare(b.name)
+      )) {
+        if (excludedSkills.has(entry.name)) continue
+        const skillFile = resolve(skillsDir, entry.name, 'SKILL.md')
+        if (!existsSync(skillFile)) continue
+        const meta = parseFrontmatterMeta(await readFile(skillFile, 'utf8'))
+        const desc = meta['description'] ?? ''
+        skillLines.push(
+          `- **${entry.name}** (\`.opencode/skills/${entry.name}.md\`): ${desc}`
+        )
+      }
+
+      // Plugin skills
+      const pluginsRoot = getPluginsRoot(pkgRoot)
+      const includedPlugins = stack ? getIncludedPluginIds(stack) : undefined
+      const pluginEntries = await getPluginSkillEntries(pluginsRoot, includedPlugins)
+      for (const { id, skillPath } of pluginEntries.sort((a, b) => a.id.localeCompare(b.id))) {
+        const pluginMeta = parseFrontmatterMeta(await readFile(skillPath, 'utf8'))
+        const pluginDesc = pluginMeta['description'] ?? ''
+        skillLines.push(
+          `- **${id}** (\`.opencode/skills/${id}.md\`): ${pluginDesc}`
+        )
+      }
+
+      sections.push(skillLines.join('\n'))
+    }
+
+    await writeFile(agentsMd, sections.join('\n') + '\n')
+    results.created.push(agentsMd)
+  } else {
+    results.skipped.push(agentsMd)
+  }
+
+  const openDir = resolve(projectRoot, '.opencode')
+
+  // 2. Agent definitions → .opencode/agents/
+  const agentsDir = resolve(srcRoot, 'agents')
+  if (existsSync(agentsDir)) {
+    const destAgents = resolve(openDir, 'agents')
+    await mkdir(destAgents, { recursive: true })
+    for (const file of await readdir(agentsDir)) {
+      if (!file.endsWith('.md')) continue
+      if (excludedAgents.has(file)) continue
+      const destPath = resolve(destAgents, file)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(agentsDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 3. Skills → .opencode/skills/<name>.md
+  const skillsDir = resolve(srcRoot, 'skills')
+  if (existsSync(skillsDir)) {
+    const destSkills = resolve(openDir, 'skills')
+    await mkdir(destSkills, { recursive: true })
+    const subdirs = (
+      await readdir(skillsDir, { withFileTypes: true })
+    ).filter((e) => e.isDirectory())
+    for (const entry of subdirs) {
+      if (excludedSkills.has(entry.name)) continue
+      const skillFile = resolve(skillsDir, entry.name, 'SKILL.md')
+      if (!existsSync(skillFile)) continue
+      const destPath = resolve(destSkills, `${entry.name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(skillFile, 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 3b. Plugin skills → .opencode/skills/<plugin-id>.md
+  {
+    const pluginsRoot = getPluginsRoot(pkgRoot)
+    const includedPlugins = stack ? getIncludedPluginIds(stack) : undefined
+    const pluginEntries = await getPluginSkillEntries(pluginsRoot, includedPlugins)
+    const destSkills = resolve(openDir, 'skills')
+    await mkdir(destSkills, { recursive: true })
+    for (const { id, skillPath } of pluginEntries) {
+      const destPath = resolve(destSkills, `${id}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(skillPath, 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 4. Prompts → .opencode/prompts/<name>.md
+  const promptDir = resolve(srcRoot, 'prompts')
+  if (existsSync(promptDir)) {
+    const destPrompts = resolve(openDir, 'prompts')
+    await mkdir(destPrompts, { recursive: true })
+    for (const file of await readdir(promptDir)) {
+      if (!file.endsWith('.md')) continue
+      const name = basename(file, '.prompt.md') || basename(file, '.md')
+      const destPath = resolve(destPrompts, `${name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(promptDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 5. Agent Workflows → .opencode/workflows/<name>.md
+  const wfDir = resolve(srcRoot, 'agent-workflows')
+  if (existsSync(wfDir)) {
+    const destWf = resolve(openDir, 'workflows')
+    await mkdir(destWf, { recursive: true })
+    for (const file of await readdir(wfDir)) {
+      if (!file.endsWith('.md')) continue
+      if (file === 'README.md') continue
+      const name = basename(file, '.md')
+      const destPath = resolve(destWf, `${name}.md`)
+      if (existsSync(destPath)) {
+        results.skipped.push(destPath)
+        continue
+      }
+      const content = await readFile(resolve(wfDir, file), 'utf8')
+      await writeFile(destPath, stripFrontmatter(content) + '\n')
+      results.created.push(destPath)
+    }
+  }
+
+  // 6. Customizations (scaffold once, pre-populated with stack choices)
+  const custDir = resolve(srcRoot, 'customizations')
+  if (existsSync(custDir)) {
+    const destCust = resolve(openDir, 'customizations')
+    const custTransform = stack ? getCustomizationsTransform(stack) : undefined
+    const sub = await copyDir(custDir, destCust, { transform: custTransform })
+    results.created.push(...sub.created)
+    results.skipped.push(...sub.skipped)
+  }
+
+  // 7. MCP server config → opencode.json (OpenCode format)
+  const mcpResult = await scaffoldMcpConfig(
+    projectRoot,
+    'opencode.json',
+    stack,
+    repoInfo,
+    'opencode'
+  )
+  results[mcpResult.action].push(mcpResult.path)
+
+  return results
+}
+
+// ─── Update ───────────────────────────────────────────────────────
+
+export async function update(
+  pkgRoot: string,
+  projectRoot: string,
+  stack?: StackConfig
+): Promise<CopyResults> {
+  const results: CopyResults = { copied: [], skipped: [], created: [] }
+  const openDir = resolve(projectRoot, '.opencode')
+
+  // 1. Regenerate AGENTS.md (overwrite)
+  const agentsMd = resolve(projectRoot, 'AGENTS.md')
+  if (existsSync(agentsMd)) {
+    await unlink(agentsMd)
+  }
+
+  // 2. Remove existing framework files so install() recreates them
+  const frameworkDirs = ['agents', 'skills', 'prompts', 'workflows']
+  for (const dir of frameworkDirs) {
+    const dirPath = resolve(openDir, dir)
+    if (existsSync(dirPath)) {
+      await rm(dirPath, { recursive: true })
+    }
+  }
+
+  // 3. Re-run full install
+  const installResult = await install(pkgRoot, projectRoot, stack)
+  results.copied.push(...installResult.created)
+  results.skipped.push(...installResult.skipped)
+
+  return results
+}
+
+// ─── Managed paths ────────────────────────────────────────────────
+
+export function getManagedPaths(): ManagedPaths {
+  return {
+    framework: [
+      'AGENTS.md',
+      '.opencode/agents/',
+      '.opencode/skills/',
+      '.opencode/prompts/',
+      '.opencode/workflows/',
+    ],
+    customizable: ['.opencode/customizations/', 'opencode.json'],
+  }
+}

package/src/cli/adapters/vscode.ts

@@ -1,10 +1,10 @@
 import { resolve } from 'node:path'
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, writeFile, copyFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { copyDir, getOrchestratorRoot, removeDirIfExists } from '../copy.js'
+import { copyDir, getOrchestratorRoot, removeDirIfExists, getPluginsRoot, getPluginSkillEntries } from '../copy.js'
 import { scaffoldMcpConfig } from '../mcp.js'
-import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform } from '../stack-config.js'
-import type { CopyResults, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
+import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform, getIncludedPluginIds, getAgentTransform } from '../stack-config.js'
+import type { CopyResults, CopyDirOptions, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
 
 /**
  * VS Code / GitHub Copilot adapter.
@@ -69,18 +69,36 @@ export async function install(
 
     // Build filter based on directory type
     let filter: ((_name: string, _srcPath: string) => boolean) | undefined
+    let transform: CopyDirOptions['transform'] | undefined
     if (dir === 'skills') {
       filter = (name) => !excludedSkills.has(name)
     } else if (dir === 'agents') {
       filter = (name) => !excludedAgents.has(name)
+      transform = stack ? getAgentTransform(stack) : undefined
     }
 
-    const sub = await copyDir(srcDir, destDir, { filter })
+    const sub = await copyDir(srcDir, destDir, { filter, transform })
     results.copied.push(...sub.copied)
     results.skipped.push(...sub.skipped)
     results.created.push(...sub.created)
   }
 
+  // Plugin skills → .github/skills/<plugin-id>/
+  const pluginsRoot = getPluginsRoot(pkgRoot)
+  const includedPlugins = stack ? getIncludedPluginIds(stack) : undefined
+  const pluginSkills = await getPluginSkillEntries(pluginsRoot, includedPlugins)
+  for (const { id, skillPath } of pluginSkills) {
+    const pluginDestDir = resolve(destRoot, 'skills', id)
+    await mkdir(pluginDestDir, { recursive: true })
+    const destPath = resolve(pluginDestDir, 'SKILL.md')
+    if (existsSync(destPath)) {
+      results.skipped.push(destPath)
+    } else {
+      await copyFile(skillPath, destPath)
+      results.created.push(destPath)
+    }
+  }
+
   // Customization templates (scaffold once)
   const custTransform = stack ? getCustomizationsTransform(stack) : undefined
   for (const dir of CUSTOMIZABLE_DIRS) {
@@ -95,11 +113,11 @@ export async function install(
 
   // MCP server config → .vscode/mcp.json (scaffold once)
   const mcpResult = await scaffoldMcpConfig(
-    pkgRoot,
     projectRoot,
     '.vscode/mcp.json',
     stack,
-    repoInfo
+    repoInfo,
+    'vscode'
   )
   results[mcpResult.action].push(mcpResult.path)
 
@@ -139,18 +157,32 @@ export async function update(
     const destDir = resolve(destRoot, dir)
 
     let filter: ((_name: string, _srcPath: string) => boolean) | undefined
+    let transform: CopyDirOptions['transform'] | undefined
     if (dir === 'skills') {
       filter = (name) => !excludedSkills.has(name)
     } else if (dir === 'agents') {
       filter = (name) => !excludedAgents.has(name)
+      transform = stack ? getAgentTransform(stack) : undefined
     }
 
-    const sub = await copyDir(srcDir, destDir, { overwrite: true, filter })
+    const sub = await copyDir(srcDir, destDir, { overwrite: true, filter, transform })
     // All re-installed framework files count as "updated" (copied), not "created"
     results.copied.push(...sub.copied, ...sub.created)
     results.skipped.push(...sub.skipped)
   }
 
+  // Plugin skills → .github/skills/<plugin-id>/ (overwrite)
+  const pluginsRoot = getPluginsRoot(pkgRoot)
+  const includedPlugins = stack ? getIncludedPluginIds(stack) : undefined
+  const pluginSkills = await getPluginSkillEntries(pluginsRoot, includedPlugins)
+  for (const { id, skillPath } of pluginSkills) {
+    const pluginDestDir = resolve(destRoot, 'skills', id)
+    await mkdir(pluginDestDir, { recursive: true })
+    const destPath = resolve(pluginDestDir, 'SKILL.md')
+    await copyFile(skillPath, destPath)
+    results.copied.push(destPath)
+  }
+
   // Customizations are NEVER overwritten during update.
 
   return results

package/src/cli/copy.ts

@@ -77,3 +77,35 @@ export async function removeDirIfExists(dirPath: string): Promise<void> {
     await rm(dirPath, { recursive: true });
   }
 }
+
+/**
+ * Resolve the plugins source directory from the CLI package root.
+ */
+export function getPluginsRoot(pkgRoot: string): string {
+  return resolve(pkgRoot, 'src', 'orchestrator', 'plugins');
+}
+
+/**
+ * Scan plugin directories for SKILL.md files.
+ * Returns entries with plugin ID and skill file path.
+ */
+export async function getPluginSkillEntries(
+  pluginsRoot: string,
+  includedPluginIds?: Set<string>
+): Promise<Array<{ id: string; skillPath: string }>> {
+  if (!existsSync(pluginsRoot)) return [];
+
+  const entries = await readdir(pluginsRoot, { withFileTypes: true });
+  const results: Array<{ id: string; skillPath: string }> = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (includedPluginIds && !includedPluginIds.has(entry.name)) continue;
+    const skillPath = resolve(pluginsRoot, entry.name, 'SKILL.md');
+    if (existsSync(skillPath)) {
+      results.push({ id: entry.name, skillPath });
+    }
+  }
+
+  return results;
+}

package/src/cli/detect.ts

@@ -423,30 +423,30 @@ function cleanEmpty(info: RepoInfoInternal): RepoInfo {
 
 /**
  * Merge user-declared stack choices into the auto-detected repoInfo.
- * Adds CMS, DB, PM, and notifications from the questionnaire so
+ * Adds tech tools and team tools from the questionnaire so
  * repoInfo becomes the single combined source of truth.
  */
 export function mergeStackIntoRepoInfo(info: RepoInfo, stack: StackConfig): RepoInfo {
   const merged = { ...info };
 
-  // CMS
-  if (stack.cms !== 'none') {
-    merged.cms = addUniqueToArray(merged.cms, stack.cms);
-  }
-
-  // Database
-  if (stack.db !== 'none') {
-    merged.databases = addUniqueToArray(merged.databases, stack.db);
-  }
-
-  // Project management
-  if (stack.pm !== 'none') {
-    merged.pm = addUniqueToArray(merged.pm, stack.pm);
+  for (const tool of stack.techTools) {
+    if (['sanity', 'contentful', 'strapi'].includes(tool)) {
+      merged.cms = addUniqueToArray(merged.cms, tool);
+    } else if (['supabase', 'convex'].includes(tool)) {
+      merged.databases = addUniqueToArray(merged.databases, tool);
+    } else if (tool === 'vercel') {
+      merged.deployment = addUniqueToArray(merged.deployment, tool);
+    } else if (tool === 'nx') {
+      merged.monorepo = merged.monorepo ?? 'nx';
+    }
   }
 
-  // Notifications
-  if (stack.notifications !== 'none') {
-    merged.notifications = addUniqueToArray(merged.notifications, stack.notifications);
+  for (const tool of stack.teamTools) {
+    if (['linear', 'jira'].includes(tool)) {
+      merged.pm = addUniqueToArray(merged.pm, tool);
+    } else if (['slack', 'teams'].includes(tool)) {
+      merged.notifications = addUniqueToArray(merged.notifications, tool);
+    }
   }
 
   return merged;