opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/auto-slash-command/constants.ts

@@ -1,12 +0,0 @@
-export const HOOK_NAME = "auto-slash-command" as const
-
-export const AUTO_SLASH_COMMAND_TAG_OPEN = "<auto-slash-command>"
-export const AUTO_SLASH_COMMAND_TAG_CLOSE = "</auto-slash-command>"
-
-export const SLASH_COMMAND_PATTERN = /^\/([a-zA-Z][\w-]*)\s*(.*)/
-
-export const EXCLUDED_COMMANDS = new Set([
-  "ralph-loop",
-  "cancel-ralph",
-  "ulw-loop",
-])

package/oh-my-opencode/src/hooks/auto-slash-command/detector.test.ts

@@ -1,296 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import {
-  parseSlashCommand,
-  detectSlashCommand,
-  isExcludedCommand,
-  removeCodeBlocks,
-  extractPromptText,
-} from "./detector"
-
-describe("auto-slash-command detector", () => {
-  describe("removeCodeBlocks", () => {
-    it("should remove markdown code blocks", () => {
-      // #given text with code blocks
-      const text = "Hello ```code here``` world"
-
-      // #when removing code blocks
-      const result = removeCodeBlocks(text)
-
-      // #then code blocks should be removed
-      expect(result).toBe("Hello  world")
-    })
-
-    it("should remove multiline code blocks", () => {
-      // #given text with multiline code blocks
-      const text = `Before
-\`\`\`javascript
-/command-inside-code
-\`\`\`
-After`
-
-      // #when removing code blocks
-      const result = removeCodeBlocks(text)
-
-      // #then code blocks should be removed
-      expect(result).toContain("Before")
-      expect(result).toContain("After")
-      expect(result).not.toContain("/command-inside-code")
-    })
-
-    it("should handle text without code blocks", () => {
-      // #given text without code blocks
-      const text = "Just regular text"
-
-      // #when removing code blocks
-      const result = removeCodeBlocks(text)
-
-      // #then text should remain unchanged
-      expect(result).toBe("Just regular text")
-    })
-  })
-
-  describe("parseSlashCommand", () => {
-    it("should parse simple command without args", () => {
-      // #given a simple slash command
-      const text = "/commit"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should extract command correctly
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("commit")
-      expect(result?.args).toBe("")
-    })
-
-    it("should parse command with arguments", () => {
-      // #given a slash command with arguments
-      const text = "/plan create a new feature for auth"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should extract command and args
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("plan")
-      expect(result?.args).toBe("create a new feature for auth")
-    })
-
-    it("should parse command with quoted arguments", () => {
-      // #given a slash command with quoted arguments
-      const text = '/execute "build the API"'
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should extract command and args
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("execute")
-      expect(result?.args).toBe('"build the API"')
-    })
-
-    it("should parse command with hyphen in name", () => {
-      // #given a slash command with hyphen
-      const text = "/frontend-template-creator project"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should extract full command name
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("frontend-template-creator")
-      expect(result?.args).toBe("project")
-    })
-
-    it("should return null for non-slash text", () => {
-      // #given text without slash
-      const text = "regular text"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should return null
-      expect(result).toBeNull()
-    })
-
-    it("should return null for slash not at start", () => {
-      // #given text with slash in middle
-      const text = "some text /command"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should return null (slash not at start)
-      expect(result).toBeNull()
-    })
-
-    it("should return null for just a slash", () => {
-      // #given just a slash
-      const text = "/"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should return null
-      expect(result).toBeNull()
-    })
-
-    it("should return null for slash followed by number", () => {
-      // #given slash followed by number
-      const text = "/123"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should return null (command must start with letter)
-      expect(result).toBeNull()
-    })
-
-    it("should handle whitespace before slash", () => {
-      // #given command with leading whitespace
-      const text = "  /commit"
-
-      // #when parsing
-      const result = parseSlashCommand(text)
-
-      // #then should parse after trimming
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("commit")
-    })
-  })
-
-  describe("isExcludedCommand", () => {
-    it("should exclude ralph-loop", () => {
-      // #given ralph-loop command
-      // #when checking exclusion
-      // #then should be excluded
-      expect(isExcludedCommand("ralph-loop")).toBe(true)
-    })
-
-    it("should exclude cancel-ralph", () => {
-      // #given cancel-ralph command
-      // #when checking exclusion
-      // #then should be excluded
-      expect(isExcludedCommand("cancel-ralph")).toBe(true)
-    })
-
-    it("should be case-insensitive for exclusion", () => {
-      // #given uppercase variants
-      // #when checking exclusion
-      // #then should still be excluded
-      expect(isExcludedCommand("RALPH-LOOP")).toBe(true)
-      expect(isExcludedCommand("Cancel-Ralph")).toBe(true)
-    })
-
-    it("should not exclude regular commands", () => {
-      // #given regular commands
-      // #when checking exclusion
-      // #then should not be excluded
-      expect(isExcludedCommand("commit")).toBe(false)
-      expect(isExcludedCommand("plan")).toBe(false)
-      expect(isExcludedCommand("execute")).toBe(false)
-    })
-  })
-
-  describe("detectSlashCommand", () => {
-    it("should detect slash command in plain text", () => {
-      // #given plain text with slash command
-      const text = "/commit fix typo"
-
-      // #when detecting
-      const result = detectSlashCommand(text)
-
-      // #then should detect
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("commit")
-      expect(result?.args).toBe("fix typo")
-    })
-
-    it("should NOT detect slash command inside code block", () => {
-      // #given slash command inside code block
-      const text = "```bash\n/command\n```"
-
-      // #when detecting
-      const result = detectSlashCommand(text)
-
-      // #then should not detect (only code block content)
-      expect(result).toBeNull()
-    })
-
-    it("should detect command when text has code blocks elsewhere", () => {
-      // #given slash command before code block
-      const text = "/commit fix\n```code```"
-
-      // #when detecting
-      const result = detectSlashCommand(text)
-
-      // #then should detect the command
-      expect(result).not.toBeNull()
-      expect(result?.command).toBe("commit")
-    })
-
-    it("should NOT detect excluded commands", () => {
-      // #given excluded command
-      const text = "/ralph-loop do something"
-
-      // #when detecting
-      const result = detectSlashCommand(text)
-
-      // #then should not detect
-      expect(result).toBeNull()
-    })
-
-    it("should return null for non-command text", () => {
-      // #given regular text
-      const text = "Just some regular text"
-
-      // #when detecting
-      const result = detectSlashCommand(text)
-
-      // #then should return null
-      expect(result).toBeNull()
-    })
-  })
-
-  describe("extractPromptText", () => {
-    it("should extract text from parts", () => {
-      // #given message parts
-      const parts = [
-        { type: "text", text: "Hello " },
-        { type: "tool_use", id: "123" },
-        { type: "text", text: "world" },
-      ]
-
-      // #when extracting
-      const result = extractPromptText(parts)
-
-      // #then should join text parts
-      expect(result).toBe("Hello  world")
-    })
-
-    it("should handle empty parts", () => {
-      // #given empty parts
-      const parts: Array<{ type: string; text?: string }> = []
-
-      // #when extracting
-      const result = extractPromptText(parts)
-
-      // #then should return empty string
-      expect(result).toBe("")
-    })
-
-    it("should handle parts without text", () => {
-      // #given parts without text content
-      const parts = [
-        { type: "tool_use", id: "123" },
-        { type: "tool_result", output: "result" },
-      ]
-
-      // #when extracting
-      const result = extractPromptText(parts)
-
-      // #then should return empty string
-      expect(result).toBe("")
-    })
-  })
-})

package/oh-my-opencode/src/hooks/auto-slash-command/detector.ts

@@ -1,65 +0,0 @@
-import {
-  SLASH_COMMAND_PATTERN,
-  EXCLUDED_COMMANDS,
-} from "./constants"
-import type { ParsedSlashCommand } from "./types"
-
-const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g
-
-export function removeCodeBlocks(text: string): string {
-  return text.replace(CODE_BLOCK_PATTERN, "")
-}
-
-export function parseSlashCommand(text: string): ParsedSlashCommand | null {
-  const trimmed = text.trim()
-
-  if (!trimmed.startsWith("/")) {
-    return null
-  }
-
-  const match = trimmed.match(SLASH_COMMAND_PATTERN)
-  if (!match) {
-    return null
-  }
-
-  const [raw, command, args] = match
-  return {
-    command: command.toLowerCase(),
-    args: args.trim(),
-    raw,
-  }
-}
-
-export function isExcludedCommand(command: string): boolean {
-  return EXCLUDED_COMMANDS.has(command.toLowerCase())
-}
-
-export function detectSlashCommand(text: string): ParsedSlashCommand | null {
-  const textWithoutCodeBlocks = removeCodeBlocks(text)
-  const trimmed = textWithoutCodeBlocks.trim()
-
-  if (!trimmed.startsWith("/")) {
-    return null
-  }
-
-  const parsed = parseSlashCommand(trimmed)
-
-  if (!parsed) {
-    return null
-  }
-
-  if (isExcludedCommand(parsed.command)) {
-    return null
-  }
-
-  return parsed
-}
-
-export function extractPromptText(
-  parts: Array<{ type: string; text?: string }>
-): string {
-  return parts
-    .filter((p) => p.type === "text")
-    .map((p) => p.text || "")
-    .join(" ")
-}

package/oh-my-opencode/src/hooks/auto-slash-command/executor.ts

@@ -1,205 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs"
-import { join, basename, dirname } from "path"
-import { homedir } from "os"
-import {
-  parseFrontmatter,
-  resolveCommandsInText,
-  resolveFileReferencesInText,
-  sanitizeModelField,
-  getClaudeConfigDir,
-} from "../../shared"
-import type { CommandFrontmatter } from "../../features/claude-code-command-loader/types"
-import { isMarkdownFile } from "../../shared/file-utils"
-import { discoverAllSkills, type LoadedSkill, type LazyContentLoader } from "../../features/opencode-skill-loader"
-import type { ParsedSlashCommand } from "./types"
-
-interface CommandScope {
-  type: "user" | "project" | "opencode" | "opencode-project" | "skill"
-}
-
-interface CommandMetadata {
-  name: string
-  description: string
-  argumentHint?: string
-  model?: string
-  agent?: string
-  subtask?: boolean
-}
-
-interface CommandInfo {
-  name: string
-  path?: string
-  metadata: CommandMetadata
-  content?: string
-  scope: CommandScope["type"]
-  lazyContentLoader?: LazyContentLoader
-}
-
-function discoverCommandsFromDir(commandsDir: string, scope: CommandScope["type"]): CommandInfo[] {
-  if (!existsSync(commandsDir)) {
-    return []
-  }
-
-  const entries = readdirSync(commandsDir, { withFileTypes: true })
-  const commands: CommandInfo[] = []
-
-  for (const entry of entries) {
-    if (!isMarkdownFile(entry)) continue
-
-    const commandPath = join(commandsDir, entry.name)
-    const commandName = basename(entry.name, ".md")
-
-    try {
-      const content = readFileSync(commandPath, "utf-8")
-      const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
-
-      const isOpencodeSource = scope === "opencode" || scope === "opencode-project"
-      const metadata: CommandMetadata = {
-        name: commandName,
-        description: data.description || "",
-        argumentHint: data["argument-hint"],
-        model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-        agent: data.agent,
-        subtask: Boolean(data.subtask),
-      }
-
-      commands.push({
-        name: commandName,
-        path: commandPath,
-        metadata,
-        content: body,
-        scope,
-      })
-    } catch {
-      continue
-    }
-  }
-
-  return commands
-}
-
-function skillToCommandInfo(skill: LoadedSkill): CommandInfo {
-  return {
-    name: skill.name,
-    path: skill.path,
-    metadata: {
-      name: skill.name,
-      description: skill.definition.description || "",
-      argumentHint: skill.definition.argumentHint,
-      model: skill.definition.model,
-      agent: skill.definition.agent,
-      subtask: skill.definition.subtask,
-    },
-    content: skill.definition.template,
-    scope: "skill",
-    lazyContentLoader: skill.lazyContent,
-  }
-}
-
-export interface ExecutorOptions {
-  skills?: LoadedSkill[]
-}
-
-async function discoverAllCommands(options?: ExecutorOptions): Promise<CommandInfo[]> {
-  const userCommandsDir = join(getClaudeConfigDir(), "commands")
-  const projectCommandsDir = join(process.cwd(), ".claude", "commands")
-  const opencodeGlobalDir = join(homedir(), ".config", "opencode", "command")
-  const opencodeProjectDir = join(process.cwd(), ".opencode", "command")
-
-  const userCommands = discoverCommandsFromDir(userCommandsDir, "user")
-  const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode")
-  const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project")
-  const opencodeProjectCommands = discoverCommandsFromDir(opencodeProjectDir, "opencode-project")
-
-  const skills = options?.skills ?? await discoverAllSkills()
-  const skillCommands = skills.map(skillToCommandInfo)
-
-  return [
-    ...opencodeProjectCommands,
-    ...projectCommands,
-    ...opencodeGlobalCommands,
-    ...userCommands,
-    ...skillCommands,
-  ]
-}
-
-async function findCommand(commandName: string, options?: ExecutorOptions): Promise<CommandInfo | null> {
-  const allCommands = await discoverAllCommands(options)
-  return allCommands.find(
-    (cmd) => cmd.name.toLowerCase() === commandName.toLowerCase()
-  ) ?? null
-}
-
-async function formatCommandTemplate(cmd: CommandInfo, args: string): Promise<string> {
-  const sections: string[] = []
-
-  sections.push(`# /${cmd.name} Command\n`)
-
-  if (cmd.metadata.description) {
-    sections.push(`**Description**: ${cmd.metadata.description}\n`)
-  }
-
-  if (args) {
-    sections.push(`**User Arguments**: ${args}\n`)
-  }
-
-  if (cmd.metadata.model) {
-    sections.push(`**Model**: ${cmd.metadata.model}\n`)
-  }
-
-  if (cmd.metadata.agent) {
-    sections.push(`**Agent**: ${cmd.metadata.agent}\n`)
-  }
-
-  sections.push(`**Scope**: ${cmd.scope}\n`)
-  sections.push("---\n")
-  sections.push("## Command Instructions\n")
-
-  let content = cmd.content || ""
-  if (!content && cmd.lazyContentLoader) {
-    content = await cmd.lazyContentLoader.load()
-  }
-
-  const commandDir = cmd.path ? dirname(cmd.path) : process.cwd()
-  const withFileRefs = await resolveFileReferencesInText(content, commandDir)
-  const resolvedContent = await resolveCommandsInText(withFileRefs)
-  sections.push(resolvedContent.trim())
-
-  if (args) {
-    sections.push("\n\n---\n")
-    sections.push("## User Request\n")
-    sections.push(args)
-  }
-
-  return sections.join("\n")
-}
-
-export interface ExecuteResult {
-  success: boolean
-  replacementText?: string
-  error?: string
-}
-
-export async function executeSlashCommand(parsed: ParsedSlashCommand, options?: ExecutorOptions): Promise<ExecuteResult> {
-  const command = await findCommand(parsed.command, options)
-
-  if (!command) {
-    return {
-      success: false,
-      error: `Command "/${parsed.command}" not found. Use the slashcommand tool to list available commands.`,
-    }
-  }
-
-  try {
-    const template = await formatCommandTemplate(command, parsed.args)
-    return {
-      success: true,
-      replacementText: template,
-    }
-  } catch (err) {
-    return {
-      success: false,
-      error: `Failed to load command "/${parsed.command}": ${err instanceof Error ? err.message : String(err)}`,
-    }
-  }
-}