@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/opencode-skill-loader/discover-worker.ts

@@ -1,56 +0,0 @@
-import { workerData, parentPort } from "worker_threads"
-import type { MessagePort } from "worker_threads"
-import { discoverSkillsInDirAsync } from "./async-loader"
-import type { LoadedSkill, SkillScope } from "./types"
-
-interface WorkerInput {
-  dirs: string[]
-  scopes: SkillScope[]
-}
-
-interface WorkerOutputSuccess {
-  ok: true
-  skills: LoadedSkill[]
-}
-
-interface WorkerOutputError {
-  ok: false
-  error: { message: string; stack?: string }
-}
-
-const { signalBuffer } = workerData as { signalBuffer: SharedArrayBuffer }
-const signal = new Int32Array(signalBuffer)
-
-if (!parentPort) {
-  throw new Error("Worker must be run with parentPort")
-}
-
-parentPort.once("message", (data: { port: MessagePort; input: WorkerInput }) => {
-  const { port, input } = data
-
-  void (async () => {
-    try {
-      const results = await Promise.all(input.dirs.map((dir) => discoverSkillsInDirAsync(dir)))
-
-      const skills = results.flat()
-
-      const output: WorkerOutputSuccess = { ok: true, skills }
-
-      port.postMessage(output)
-      Atomics.store(signal, 0, 1)
-      Atomics.notify(signal, 0)
-    } catch (error: unknown) {
-      const output: WorkerOutputError = {
-        ok: false,
-        error: {
-          message: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : undefined,
-        },
-      }
-
-      port.postMessage(output)
-      Atomics.store(signal, 0, 1)
-      Atomics.notify(signal, 0)
-    }
-  })()
-})

package/src/features/opencode-skill-loader/git-master-template-injection.ts

@@ -1,150 +0,0 @@
-import { assertValidGitEnvPrefix, type GitMasterConfig } from "../../config/schema"
-
-const BASH_CODE_BLOCK_PATTERN = /```bash\r?\n([\s\S]*?)```/g
-const LEADING_GIT_COMMAND_PATTERN = /^([ \t]*(?:[A-Za-z_][A-Za-z0-9_]*=[^ \t]+\s+)*)git(?=[ \t]|$)/gm
-const INLINE_GIT_COMMAND_PATTERN = /([;&|()][ \t]*)git(?=[ \t]|$)/g
-
-export function injectGitMasterConfig(template: string, config?: GitMasterConfig): string {
-	const commitFooter = config?.commit_footer ?? true
-	const includeCoAuthoredBy = config?.include_co_authored_by ?? true
-	const gitEnvPrefix = assertValidGitEnvPrefix(config?.git_env_prefix ?? "GIT_MASTER=1")
-
-	let result = gitEnvPrefix ? injectGitEnvPrefix(template, gitEnvPrefix) : template
-
-	if (commitFooter || includeCoAuthoredBy) {
-		const injection = buildCommitFooterInjection(commitFooter, includeCoAuthoredBy, gitEnvPrefix)
-		const insertionPoint = result.indexOf("```\n</execution>")
-
-		result =
-			insertionPoint !== -1
-				? result.slice(0, insertionPoint) +
-					"```\n\n" +
-					injection +
-					"\n</execution>" +
-					result.slice(insertionPoint + "```\n</execution>".length)
-				: result + "\n\n" + injection
-	}
-
-	return gitEnvPrefix ? prefixGitCommandsInBashCodeBlocks(result, gitEnvPrefix) : result
-}
-
-function injectGitEnvPrefix(template: string, prefix: string): string {
-	const envPrefixSection = [
-		"## GIT COMMAND PREFIX (MANDATORY)",
-		"",
-		`<git_env_prefix>`,
-		`**EVERY git command MUST be prefixed with \`${prefix}\`.**`,
-		"",
-		"This allows custom git hooks to detect when git-master skill is active.",
-		"",
-		"```bash",
-		`${prefix} git status`,
-		`${prefix} git add <files>`,
-		`${prefix} git commit -m "message"`,
-		`${prefix} git push`,
-		`${prefix} git rebase ...`,
-		`${prefix} git log ...`,
-		"```",
-		"",
-		"**NO EXCEPTIONS. Every `git` invocation must include this prefix.**",
-		`</git_env_prefix>`,
-	].join("\n")
-
-	const modeDetectionMarker = "## MODE DETECTION (FIRST STEP)"
-	const markerIndex = template.indexOf(modeDetectionMarker)
-	if (markerIndex !== -1) {
-		return (
-			template.slice(0, markerIndex) +
-			envPrefixSection +
-			"\n\n---\n\n" +
-			template.slice(markerIndex)
-		)
-	}
-
-	return envPrefixSection + "\n\n---\n\n" + template
-}
-
-function prefixGitCommandsInBashCodeBlocks(template: string, prefix: string): string {
-	return template.replace(BASH_CODE_BLOCK_PATTERN, (block, codeBlock: string) => {
-		return block.replace(codeBlock, prefixGitCommandsInCodeBlock(codeBlock, prefix))
-	})
-}
-
-function prefixGitCommandsInCodeBlock(codeBlock: string, prefix: string): string {
-	return codeBlock
-		.split("\n")
-		.map((line) => {
-			if (line.includes(prefix)) {
-				return line
-			}
-			return line
-				.replace(LEADING_GIT_COMMAND_PATTERN, `$1${prefix} git`)
-				.replace(INLINE_GIT_COMMAND_PATTERN, `$1${prefix} git`)
-		})
-		.join("\n")
-}
-
-function buildCommitFooterInjection(
-	commitFooter: boolean | string,
-	includeCoAuthoredBy: boolean,
-	gitEnvPrefix: string,
-): string {
-	const sections: string[] = []
-	const cmdPrefix = gitEnvPrefix ? `${gitEnvPrefix} ` : ""
-
-	sections.push("### 5.5 Commit Footer & Co-Author")
-	sections.push("")
-	sections.push("Add Bob attribution to EVERY commit:")
-	sections.push("")
-
-	if (commitFooter) {
-		const footerText =
-			typeof commitFooter === "string"
-				? commitFooter
-				: "Ultraworked with [Bob](https://github.com/code-yeongyu/hiai-opencode)"
-		sections.push("1. **Footer in commit body:**")
-		sections.push("```")
-		sections.push(footerText)
-		sections.push("```")
-		sections.push("")
-	}
-
-	if (includeCoAuthoredBy) {
-		sections.push(`${commitFooter ? "2" : "1"}. **Co-authored-by trailer:**`)
-		sections.push("```")
-		sections.push("Co-authored-by: Bob <clio-agent@boblabs.ai>")
-		sections.push("```")
-		sections.push("")
-	}
-
-	if (commitFooter && includeCoAuthoredBy) {
-		const footerText =
-			typeof commitFooter === "string"
-				? commitFooter
-				: "Ultraworked with [Bob](https://github.com/code-yeongyu/hiai-opencode)"
-		sections.push("**Example (both enabled):**")
-		sections.push("```bash")
-		sections.push(
-			`${cmdPrefix}git commit -m "{Commit Message}" -m "${footerText}" -m "Co-authored-by: Bob <clio-agent@boblabs.ai>"`
-		)
-		sections.push("```")
-	} else if (commitFooter) {
-		const footerText =
-			typeof commitFooter === "string"
-				? commitFooter
-				: "Ultraworked with [Bob](https://github.com/code-yeongyu/hiai-opencode)"
-		sections.push("**Example:**")
-		sections.push("```bash")
-		sections.push(`${cmdPrefix}git commit -m "{Commit Message}" -m "${footerText}"`)
-		sections.push("```")
-	} else if (includeCoAuthoredBy) {
-		sections.push("**Example:**")
-		sections.push("```bash")
-		sections.push(
-			`${cmdPrefix}git commit -m "{Commit Message}" -m "Co-authored-by: Bob <clio-agent@boblabs.ai>"`
-		)
-		sections.push("```")
-	}
-
-	return sections.join("\n")
-}

package/src/features/opencode-skill-loader/index.ts

@@ -1,17 +0,0 @@
-export * from "./types"
-export * from "./loader"
-export * from "./merger"
-export * from "./skill-content"
-
-export * from "./skill-directory-loader"
-export * from "./loaded-skill-from-path"
-export * from "./skill-mcp-config"
-export * from "./skill-deduplication"
-export * from "./skill-definition-record"
-
-export * from "./git-master-template-injection"
-export * from "./skill-discovery"
-export * from "./skill-resolution-options"
-export * from "./loaded-skill-template-extractor"
-export * from "./skill-template-resolver"
-export * from "./config-source-discovery"

package/src/features/opencode-skill-loader/loaded-skill-from-path.ts

@@ -1,73 +0,0 @@
-import { promises as fs } from "fs"
-import { basename } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { sanitizeModelField } from "../../shared/model-sanitizer"
-import { resolveSkillPathReferences } from "../../shared/skill-path-resolver"
-import type { CommandDefinition } from "../claude-code-command-loader/types"
-import { parseAllowedTools } from "./allowed-tools-parser"
-import { loadMcpJsonFromDir, parseSkillMcpConfigFromFrontmatter } from "./skill-mcp-config"
-import type { SkillScope, SkillMetadata, LoadedSkill, LazyContentLoader } from "./types"
-
-export async function loadSkillFromPath(options: {
-  skillPath: string
-  resolvedPath: string
-  defaultName: string
-  scope: SkillScope
-  namePrefix?: string
-}): Promise<LoadedSkill | null> {
-  const namePrefix = options.namePrefix ?? ""
-
-  try {
-    const content = await fs.readFile(options.skillPath, "utf-8")
-    const { data, body } = parseFrontmatter<SkillMetadata>(content)
-
-    const frontmatterMcp = parseSkillMcpConfigFromFrontmatter(content)
-    const mcpJsonMcp = await loadMcpJsonFromDir(options.resolvedPath)
-    const mcpConfig = mcpJsonMcp || frontmatterMcp
-
-    const baseName = String(data.name || options.defaultName)
-    const skillName = namePrefix ? `${namePrefix}/${baseName}` : baseName
-    const originalDescription = data.description || ""
-    const isOpencodeSource = options.scope === "opencode" || options.scope === "opencode-project"
-    const formattedDescription = `(${options.scope} - Skill) ${originalDescription}`
-
-    const resolvedBody = resolveSkillPathReferences(body.trim(), options.resolvedPath)
-    const templateContent = `<skill-instruction>\nBase directory for this skill: ${options.resolvedPath}/\nFile references (@path) in this skill are relative to this directory.\n\n${resolvedBody}\n</skill-instruction>\n\n<user-request>\n$ARGUMENTS\n</user-request>`
-
-    const eagerLoader: LazyContentLoader = {
-      loaded: true,
-      content: templateContent,
-      load: async () => templateContent,
-    }
-
-    const definition: CommandDefinition = {
-      name: skillName,
-      description: formattedDescription,
-      template: templateContent,
-      model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-      agent: data.agent,
-      subtask: data.subtask,
-      argumentHint: data["argument-hint"],
-    }
-
-    return {
-      name: skillName,
-      path: options.skillPath,
-      resolvedPath: options.resolvedPath,
-      definition,
-      scope: options.scope,
-      license: data.license,
-      compatibility: data.compatibility,
-      metadata: data.metadata,
-      allowedTools: parseAllowedTools(data["allowed-tools"]),
-      mcpConfig,
-      lazyContent: eagerLoader,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function inferSkillNameFromFileName(filePath: string): string {
-  return basename(filePath, ".md")
-}

package/src/features/opencode-skill-loader/loaded-skill-template-extractor.ts

@@ -1,16 +0,0 @@
-import { readFileSync } from "node:fs"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import type { LoadedSkill } from "./types"
-
-export function extractSkillTemplate(skill: LoadedSkill): string {
-  if (skill.scope === "config" && skill.definition.template) {
-    return skill.definition.template
-  }
-
-  if (skill.path) {
-    const content = readFileSync(skill.path, "utf-8")
-    const { body } = parseFrontmatter(content)
-		return body.trim()
-	}
-	return skill.definition.template || ""
-}

package/src/features/opencode-skill-loader/loader.ts

@@ -1,183 +0,0 @@
-import { join } from "path"
-import { getClaudeConfigDir } from "../../shared/claude-config-dir"
-import { getAgentsConfigDir } from "../../shared/agents-config-dir"
-import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
-import { getOpenCodeSkillDirs } from "../../shared/opencode-command-dirs"
-import {
-  findProjectAgentsSkillDirs,
-  findProjectClaudeSkillDirs,
-  findProjectOpencodeSkillDirs,
-} from "../../shared/project-discovery-dirs"
-import type { CommandDefinition } from "../claude-code-command-loader/types"
-import type { LoadedSkill } from "./types"
-import { skillsToCommandDefinitionRecord } from "./skill-definition-record"
-import { deduplicateSkillsByName } from "./skill-deduplication"
-import { loadSkillsFromDir } from "./skill-directory-loader"
-
-export async function loadUserSkills(): Promise<Record<string, CommandDefinition>> {
-  const userSkillsDir = join(getClaudeConfigDir(), "skills")
-  const skills = await loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" })
-  return skillsToCommandDefinitionRecord(skills)
-}
-
-export async function loadProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const projectSkillDirs = findProjectClaudeSkillDirs(directory ?? process.cwd())
-  const allSkills = await Promise.all(
-    projectSkillDirs.map((skillsDir) => loadSkillsFromDir({ skillsDir, scope: "project" })),
-  )
-  return skillsToCommandDefinitionRecord(deduplicateSkillsByName(allSkills.flat()))
-}
-
-export async function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>> {
-  const skillDirs = getOpenCodeSkillDirs({ binary: "opencode" })
-  const allSkills = await Promise.all(
-    skillDirs.map(skillsDir => loadSkillsFromDir({ skillsDir, scope: "opencode" }))
-  )
-  return skillsToCommandDefinitionRecord(deduplicateSkillsByName(allSkills.flat()))
-}
-
-export async function loadOpencodeProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const opencodeProjectSkillDirs = findProjectOpencodeSkillDirs(
-    directory ?? process.cwd(),
-  )
-  const allSkills = await Promise.all(
-    opencodeProjectSkillDirs.map((skillsDir) =>
-      loadSkillsFromDir({ skillsDir, scope: "opencode-project" }),
-    ),
-  )
-  return skillsToCommandDefinitionRecord(deduplicateSkillsByName(allSkills.flat()))
-}
-
-export async function loadProjectAgentsSkills(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const agentsProjectSkillDirs = findProjectAgentsSkillDirs(directory ?? process.cwd())
-  const allSkills = await Promise.all(
-    agentsProjectSkillDirs.map((skillsDir) => loadSkillsFromDir({ skillsDir, scope: "project" })),
-  )
-  return skillsToCommandDefinitionRecord(deduplicateSkillsByName(allSkills.flat()))
-}
-
-export async function loadGlobalAgentsSkills(): Promise<Record<string, CommandDefinition>> {
-  const agentsGlobalDir = join(getAgentsConfigDir(), "skills")
-  const skills = await loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
-  return skillsToCommandDefinitionRecord(skills)
-}
-
-export async function loadManagedPluginSkills(): Promise<Record<string, CommandDefinition>> {
-  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
-  const skills = await loadSkillsFromDir({ skillsDir, scope: "builtin" })
-  return skillsToCommandDefinitionRecord(skills)
-}
-
-export interface DiscoverSkillsOptions {
-  includeClaudeCodePaths?: boolean
-  directory?: string
-}
-
-export async function discoverAllSkills(directory?: string): Promise<LoadedSkill[]> {
-  const [opencodeProjectSkills, opencodeGlobalSkills, projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] =
-    await Promise.all([
-      discoverOpencodeProjectSkills(directory),
-      discoverOpencodeGlobalSkills(),
-      discoverProjectClaudeSkills(directory),
-      discoverUserClaudeSkills(),
-      discoverProjectAgentsSkills(directory),
-      discoverGlobalAgentsSkills(),
-    ])
-
-  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
-  return deduplicateSkillsByName([
-    ...opencodeProjectSkills,
-    ...opencodeGlobalSkills,
-    ...projectSkills,
-    ...agentsProjectSkills,
-    ...userSkills,
-    ...agentsGlobalSkills,
-  ])
-}
-
-export async function discoverSkills(options: DiscoverSkillsOptions = {}): Promise<LoadedSkill[]> {
-  const { includeClaudeCodePaths = true, directory } = options
-
-  const [opencodeProjectSkills, opencodeGlobalSkills] = await Promise.all([
-    discoverOpencodeProjectSkills(directory),
-    discoverOpencodeGlobalSkills(),
-  ])
-
-  if (!includeClaudeCodePaths) {
-    // Priority: opencode-project > opencode
-    return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills])
-  }
-
-  const [projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] = await Promise.all([
-    discoverProjectClaudeSkills(directory),
-    discoverUserClaudeSkills(),
-    discoverProjectAgentsSkills(directory),
-    discoverGlobalAgentsSkills(),
-  ])
-
-  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
-  return deduplicateSkillsByName([
-    ...opencodeProjectSkills,
-    ...opencodeGlobalSkills,
-    ...projectSkills,
-    ...agentsProjectSkills,
-    ...userSkills,
-    ...agentsGlobalSkills,
-  ])
-}
-
-export async function getSkillByName(name: string, options: DiscoverSkillsOptions = {}): Promise<LoadedSkill | undefined> {
-  const skills = await discoverSkills(options)
-  return skills.find(s => s.name === name)
-}
-
-export async function discoverUserClaudeSkills(): Promise<LoadedSkill[]> {
-  const userSkillsDir = join(getClaudeConfigDir(), "skills")
-  return loadSkillsFromDir({ skillsDir: userSkillsDir, scope: "user" })
-}
-
-export async function discoverProjectClaudeSkills(directory?: string): Promise<LoadedSkill[]> {
-  const projectSkillDirs = findProjectClaudeSkillDirs(directory ?? process.cwd())
-  const allSkills = await Promise.all(
-    projectSkillDirs.map((skillsDir) => loadSkillsFromDir({ skillsDir, scope: "project" })),
-  )
-  return deduplicateSkillsByName(allSkills.flat())
-}
-
-export async function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]> {
-  const skillDirs = getOpenCodeSkillDirs({ binary: "opencode" })
-  const allSkills = await Promise.all(
-    skillDirs.map(skillsDir => loadSkillsFromDir({ skillsDir, scope: "opencode" }))
-  )
-  return deduplicateSkillsByName(allSkills.flat())
-}
-
-export async function discoverOpencodeProjectSkills(directory?: string): Promise<LoadedSkill[]> {
-  const opencodeProjectSkillDirs = findProjectOpencodeSkillDirs(
-    directory ?? process.cwd(),
-  )
-  const allSkills = await Promise.all(
-    opencodeProjectSkillDirs.map((skillsDir) =>
-      loadSkillsFromDir({ skillsDir, scope: "opencode-project" }),
-    ),
-  )
-  return deduplicateSkillsByName(allSkills.flat())
-}
-
-export async function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]> {
-  const agentsProjectSkillDirs = findProjectAgentsSkillDirs(directory ?? process.cwd())
-  const allSkills = await Promise.all(
-    agentsProjectSkillDirs.map((skillsDir) => loadSkillsFromDir({ skillsDir, scope: "project" })),
-  )
-  return deduplicateSkillsByName(allSkills.flat())
-}
-
-export async function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]> {
-  const agentsGlobalDir = join(getAgentsConfigDir(), "skills")
-  return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
-}
-
-export async function discoverManagedPluginSkills(): Promise<LoadedSkill[]> {
-  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
-  return loadSkillsFromDir({ skillsDir, scope: "builtin" })
-}

package/src/features/opencode-skill-loader/merger/builtin-skill-converter.ts

@@ -1,26 +0,0 @@
-import type { BuiltinSkill } from "../../builtin-skills/types"
-import type { CommandDefinition } from "../../claude-code-command-loader/types"
-import type { LoadedSkill } from "../types"
-
-export function builtinToLoadedSkill(builtin: BuiltinSkill): LoadedSkill {
-  const definition: CommandDefinition = {
-    name: builtin.name,
-    description: `(opencode - Skill) ${builtin.description}`,
-    template: builtin.template,
-    model: builtin.model,
-    agent: builtin.agent,
-    subtask: builtin.subtask,
-    argumentHint: builtin.argumentHint,
-  }
-
-  return {
-    name: builtin.name,
-    definition,
-    scope: "builtin",
-    license: builtin.license,
-    compatibility: builtin.compatibility,
-    metadata: builtin.metadata as Record<string, string> | undefined,
-    allowedTools: builtin.allowedTools,
-    mcpConfig: builtin.mcpConfig,
-  }
-}

package/src/features/opencode-skill-loader/merger/config-skill-entry-loader.ts

@@ -1,117 +0,0 @@
-import type { LoadedSkill, SkillMetadata } from "../types"
-import type { SkillDefinition } from "../../../config/schema"
-import type { CommandDefinition } from "../../claude-code-command-loader/types"
-import { existsSync, readFileSync } from "fs"
-import { dirname, isAbsolute, resolve } from "path"
-import { homedir } from "os"
-import { parseFrontmatter } from "../../../shared/frontmatter"
-import { isWithinProject } from "../../../shared/contains-path"
-import { log } from "../../../shared/logger"
-import { sanitizeModelField } from "../../../shared/model-sanitizer"
-import { resolveSkillPathReferences } from "../../../shared/skill-path-resolver"
-import { parseAllowedTools } from "../allowed-tools-parser"
-
-function resolveFilePath(from: string, configDir?: string): string {
-  let filePath = from
-
-  if (filePath.startsWith("{file:") && filePath.endsWith("}")) {
-    filePath = filePath.slice(6, -1)
-  }
-
-  if (filePath.startsWith("~/")) {
-    return resolve(homedir(), filePath.slice(2))
-  }
-
-  if (isAbsolute(filePath)) {
-    return filePath
-  }
-
-  const baseDir = configDir || process.cwd()
-  return resolve(baseDir, filePath)
-}
-
-function loadSkillFromFile(filePath: string): { template: string; metadata: SkillMetadata } | null {
-  try {
-    if (!existsSync(filePath)) return null
-    const content = readFileSync(filePath, "utf-8")
-    const { data, body } = parseFrontmatter<SkillMetadata>(content)
-    return { template: body, metadata: data }
-  } catch {
-    return null
-  }
-}
-
-export function configEntryToLoadedSkill(
-  name: string,
-  entry: SkillDefinition,
-  configDir?: string
-): LoadedSkill | null {
-  let template = entry.template || ""
-  let fileMetadata: SkillMetadata = {}
-  let sourcePath: string | undefined
-
-  if (entry.from) {
-    sourcePath = resolveFilePath(entry.from, configDir)
-    const projectRoot = configDir || process.cwd()
-
-    if (!isWithinProject(sourcePath, projectRoot)) {
-      log("[config-skill-entry-loader] Rejected skill entry file outside project root", {
-        from: entry.from,
-        filePath: sourcePath,
-        projectRoot,
-      })
-      return null
-    }
-
-    const loaded = loadSkillFromFile(sourcePath)
-    if (loaded) {
-      template = loaded.template
-      fileMetadata = loaded.metadata
-    } else {
-      return null
-    }
-  }
-
-  if (!template && !entry.from) {
-    return null
-  }
-
-  const description = entry.description || fileMetadata.description || ""
-  const resolvedPath = sourcePath ? dirname(sourcePath) : configDir || process.cwd()
-
-  const resolvedTemplate = resolveSkillPathReferences(template.trim(), resolvedPath)
-  const wrappedTemplate = `<skill-instruction>
-Base directory for this skill: ${resolvedPath}/
-File references (@path) in this skill are relative to this directory.
-
-${resolvedTemplate}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`
-
-  const definition: CommandDefinition = {
-    name,
-    description: `(config - Skill) ${description}`,
-    template: wrappedTemplate,
-    model: sanitizeModelField(entry.model || fileMetadata.model, "opencode"),
-    agent: entry.agent || fileMetadata.agent,
-    subtask: entry.subtask ?? fileMetadata.subtask,
-    argumentHint: entry["argument-hint"] || fileMetadata["argument-hint"],
-  }
-
-  const allowedTools = entry["allowed-tools"] || parseAllowedTools(fileMetadata["allowed-tools"])
-
-  return {
-    name,
-    path: sourcePath,
-    resolvedPath,
-    definition,
-    scope: "config",
-    license: entry.license || fileMetadata.license,
-    compatibility: entry.compatibility || fileMetadata.compatibility,
-    metadata: (entry.metadata as Record<string, string> | undefined) || fileMetadata.metadata,
-    allowedTools,
-  }
-}

package/src/features/opencode-skill-loader/merger/scope-priority.ts

@@ -1,10 +0,0 @@
-import type { SkillScope } from "../types"
-
-export const SCOPE_PRIORITY: Record<SkillScope, number> = {
-  builtin: 1,
-  config: 2,
-  user: 3,
-  opencode: 4,
-  project: 5,
-  "opencode-project": 6,
-}

package/src/features/opencode-skill-loader/merger/skill-definition-merger.ts

@@ -1,31 +0,0 @@
-import type { LoadedSkill } from "../types"
-import type { SkillDefinition } from "../../../config/schema"
-import { deepMerge } from "../../../shared/deep-merge"
-
-export function mergeSkillDefinitions(base: LoadedSkill, patch: SkillDefinition): LoadedSkill {
-  const mergedMetadata = base.metadata || patch.metadata
-    ? deepMerge(base.metadata || {}, (patch.metadata as Record<string, string>) || {})
-    : undefined
-
-  const mergedTools = base.allowedTools || patch["allowed-tools"]
-    ? [...(base.allowedTools || []), ...(patch["allowed-tools"] || [])]
-    : undefined
-
-  const description = patch.description || base.definition.description?.replace(/^\([^)]+\) /, "")
-
-  return {
-    ...base,
-    definition: {
-      ...base.definition,
-      description: `(${base.scope} - Skill) ${description}`,
-      model: patch.model || base.definition.model,
-      agent: patch.agent || base.definition.agent,
-      subtask: patch.subtask ?? base.definition.subtask,
-      argumentHint: patch["argument-hint"] || base.definition.argumentHint,
-    },
-    license: patch.license || base.license,
-    compatibility: patch.compatibility || base.compatibility,
-    metadata: mergedMetadata as Record<string, string> | undefined,
-    allowedTools: mergedTools ? [...new Set(mergedTools)] : undefined,
-  }
-}