opencode-repos 0.3.0 → 0.3.2

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

@@ -1,254 +0,0 @@
-import { describe, expect, it, beforeEach, mock, spyOn } from "bun:test"
-import type {
-  AutoSlashCommandHookInput,
-  AutoSlashCommandHookOutput,
-} from "./types"
-
-// Import real shared module to avoid mock leaking to other test files
-import * as shared from "../../shared"
-
-// Spy on log instead of mocking the entire module
-const logMock = spyOn(shared, "log").mockImplementation(() => {})
-
-
-
-const { createAutoSlashCommandHook } = await import("./index")
-
-function createMockInput(sessionID: string, messageID?: string): AutoSlashCommandHookInput {
-  return {
-    sessionID,
-    messageID: messageID ?? `msg-${Date.now()}-${Math.random()}`,
-    agent: "test-agent",
-    model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
-  }
-}
-
-function createMockOutput(text: string): AutoSlashCommandHookOutput {
-  return {
-    message: {
-      agent: "test-agent",
-      model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
-      path: { cwd: "/test", root: "/test" },
-      tools: {},
-    },
-    parts: [{ type: "text", text }],
-  }
-}
-
-describe("createAutoSlashCommandHook", () => {
-  beforeEach(() => {
-    logMock.mockClear()
-  })
-
-  describe("slash command replacement", () => {
-    it("should not modify message when command not found", async () => {
-      // #given a slash command that doesn't exist
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-notfound-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/nonexistent-command args")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should NOT modify the message (feature inactive when command not found)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should not modify message for unknown command (feature inactive)", async () => {
-      // #given unknown slash command
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-tags-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/some-command")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should NOT modify (command not found = feature inactive)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should not modify for unknown command (no prepending)", async () => {
-      // #given unknown slash command
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-replace-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/test-cmd some args")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify (feature inactive for unknown commands)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-
-  describe("no slash command", () => {
-    it("should do nothing for regular text", async () => {
-      // #given regular text without slash
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-regular-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("Just regular text")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should do nothing for slash in middle of text", async () => {
-      // #given slash in middle
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-middle-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("Please run /commit later")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not detect (not at start)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-
-  describe("excluded commands", () => {
-    it("should NOT trigger for ralph-loop command", async () => {
-      // #given ralph-loop command
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-ralph-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/ralph-loop do something")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify (excluded command)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should NOT trigger for cancel-ralph command", async () => {
-      // #given cancel-ralph command
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-cancel-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/cancel-ralph")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-
-  describe("already processed", () => {
-    it("should skip if auto-slash-command tags already present", async () => {
-      // #given text with existing tags
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-existing-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput(
-        "<auto-slash-command>/commit</auto-slash-command>"
-      )
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-
-  describe("code blocks", () => {
-    it("should NOT detect command inside code block", async () => {
-      // #given command inside code block
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-codeblock-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("```\n/commit\n```")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not detect
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-
-  describe("edge cases", () => {
-    it("should handle empty text", async () => {
-      // #given empty text
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-empty-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("")
-
-      // #when hook is called
-      // #then should not throw
-      await expect(hook["chat.message"](input, output)).resolves.toBeUndefined()
-    })
-
-    it("should handle just slash", async () => {
-      // #given just slash
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-slash-only-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput("/")
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should handle command with special characters in args (not found = no modification)", async () => {
-      // #given command with special characters that doesn't exist
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-special-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output = createMockOutput('/execute "test & stuff <tag>"')
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify (command not found = feature inactive)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-
-    it("should handle multiple text parts (unknown command = no modification)", async () => {
-      // #given multiple text parts with unknown command
-      const hook = createAutoSlashCommandHook()
-      const sessionID = `test-session-multi-${Date.now()}`
-      const input = createMockInput(sessionID)
-      const output: AutoSlashCommandHookOutput = {
-        message: {},
-        parts: [
-          { type: "text", text: "/truly-nonexistent-xyz-cmd " },
-          { type: "text", text: "some args" },
-        ],
-      }
-      const originalText = output.parts[0].text
-
-      // #when hook is called
-      await hook["chat.message"](input, output)
-
-      // #then should not modify (command not found = feature inactive)
-      expect(output.parts[0].text).toBe(originalText)
-    })
-  })
-})

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

@@ -1,89 +0,0 @@
-import {
-  detectSlashCommand,
-  extractPromptText,
-} from "./detector"
-import { executeSlashCommand, type ExecutorOptions } from "./executor"
-import { log } from "../../shared"
-import {
-  AUTO_SLASH_COMMAND_TAG_OPEN,
-  AUTO_SLASH_COMMAND_TAG_CLOSE,
-} from "./constants"
-import type {
-  AutoSlashCommandHookInput,
-  AutoSlashCommandHookOutput,
-} from "./types"
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-
-export * from "./detector"
-export * from "./executor"
-export * from "./constants"
-export * from "./types"
-
-const sessionProcessedCommands = new Set<string>()
-
-export interface AutoSlashCommandHookOptions {
-  skills?: LoadedSkill[]
-}
-
-export function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions) {
-  const executorOptions: ExecutorOptions = {
-    skills: options?.skills,
-  }
-
-  return {
-    "chat.message": async (
-      input: AutoSlashCommandHookInput,
-      output: AutoSlashCommandHookOutput
-    ): Promise<void> => {
-      const promptText = extractPromptText(output.parts)
-
-      if (
-        promptText.includes(AUTO_SLASH_COMMAND_TAG_OPEN) ||
-        promptText.includes(AUTO_SLASH_COMMAND_TAG_CLOSE)
-      ) {
-        return
-      }
-
-      const parsed = detectSlashCommand(promptText)
-
-      if (!parsed) {
-        return
-      }
-
-      const commandKey = `${input.sessionID}:${input.messageID}:${parsed.command}`
-      if (sessionProcessedCommands.has(commandKey)) {
-        return
-      }
-      sessionProcessedCommands.add(commandKey)
-
-      log(`[auto-slash-command] Detected: /${parsed.command}`, {
-        sessionID: input.sessionID,
-        args: parsed.args,
-      })
-
-      const result = await executeSlashCommand(parsed, executorOptions)
-
-      const idx = output.parts.findIndex((p) => p.type === "text" && p.text)
-      if (idx < 0) {
-        return
-      }
-
-      if (!result.success || !result.replacementText) {
-        log(`[auto-slash-command] Command not found, skipping`, {
-          sessionID: input.sessionID,
-          command: parsed.command,
-          error: result.error,
-        })
-        return
-      }
-
-      const taggedContent = `${AUTO_SLASH_COMMAND_TAG_OPEN}\n${result.replacementText}\n${AUTO_SLASH_COMMAND_TAG_CLOSE}`
-      output.parts[idx].text = taggedContent
-
-      log(`[auto-slash-command] Replaced message with command template`, {
-        sessionID: input.sessionID,
-        command: parsed.command,
-      })
-    },
-  }
-}

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

@@ -1,23 +0,0 @@
-export interface AutoSlashCommandHookInput {
-  sessionID: string
-  agent?: string
-  model?: { providerID: string; modelID: string }
-  messageID?: string
-}
-
-export interface AutoSlashCommandHookOutput {
-  message: Record<string, unknown>
-  parts: Array<{ type: string; text?: string; [key: string]: unknown }>
-}
-
-export interface ParsedSlashCommand {
-  command: string
-  args: string
-  raw: string
-}
-
-export interface AutoSlashCommandResult {
-  detected: boolean
-  parsedCommand?: ParsedSlashCommand
-  injectedMessage?: string
-}

package/oh-my-opencode/src/hooks/auto-update-checker/cache.ts

@@ -1,93 +0,0 @@
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { CACHE_DIR, PACKAGE_NAME } from "./constants"
-import { log } from "../../shared/logger"
-
-interface BunLockfile {
-  workspaces?: {
-    ""?: {
-      dependencies?: Record<string, string>
-    }
-  }
-  packages?: Record<string, unknown>
-}
-
-function stripTrailingCommas(json: string): string {
-  return json.replace(/,(\s*[}\]])/g, "$1")
-}
-
-function removeFromBunLock(packageName: string): boolean {
-  const lockPath = path.join(CACHE_DIR, "bun.lock")
-  if (!fs.existsSync(lockPath)) return false
-
-  try {
-    const content = fs.readFileSync(lockPath, "utf-8")
-    const lock = JSON.parse(stripTrailingCommas(content)) as BunLockfile
-    let modified = false
-
-    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
-      delete lock.workspaces[""].dependencies[packageName]
-      modified = true
-    }
-
-    if (lock.packages?.[packageName]) {
-      delete lock.packages[packageName]
-      modified = true
-    }
-
-    if (modified) {
-      fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2))
-      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`)
-    }
-
-    return modified
-  } catch {
-    return false
-  }
-}
-
-export function invalidatePackage(packageName: string = PACKAGE_NAME): boolean {
-  try {
-    const pkgDir = path.join(CACHE_DIR, "node_modules", packageName)
-    const pkgJsonPath = path.join(CACHE_DIR, "package.json")
-
-    let packageRemoved = false
-    let dependencyRemoved = false
-    let lockRemoved = false
-
-    if (fs.existsSync(pkgDir)) {
-      fs.rmSync(pkgDir, { recursive: true, force: true })
-      log(`[auto-update-checker] Package removed: ${pkgDir}`)
-      packageRemoved = true
-    }
-
-    if (fs.existsSync(pkgJsonPath)) {
-      const content = fs.readFileSync(pkgJsonPath, "utf-8")
-      const pkgJson = JSON.parse(content)
-      if (pkgJson.dependencies?.[packageName]) {
-        delete pkgJson.dependencies[packageName]
-        fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2))
-        log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`)
-        dependencyRemoved = true
-      }
-    }
-
-    lockRemoved = removeFromBunLock(packageName)
-
-    if (!packageRemoved && !dependencyRemoved && !lockRemoved) {
-      log(`[auto-update-checker] Package not found, nothing to invalidate: ${packageName}`)
-      return false
-    }
-
-    return true
-  } catch (err) {
-    log("[auto-update-checker] Failed to invalidate package:", err)
-    return false
-  }
-}
-
-/** @deprecated Use invalidatePackage instead - this nukes ALL plugins */
-export function invalidateCache(): boolean {
-  log("[auto-update-checker] WARNING: invalidateCache is deprecated, use invalidatePackage")
-  return invalidatePackage()
-}

package/oh-my-opencode/src/hooks/auto-update-checker/checker.test.ts

@@ -1,24 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { getLatestVersion } from "./checker"
-
-describe("auto-update-checker/checker", () => {
-  describe("getLatestVersion", () => {
-    test("accepts channel parameter", async () => {
-      const result = await getLatestVersion("beta")
-      
-      expect(typeof result === "string" || result === null).toBe(true)
-    })
-
-    test("accepts latest channel", async () => {
-      const result = await getLatestVersion("latest")
-      
-      expect(typeof result === "string" || result === null).toBe(true)
-    })
-
-    test("works without channel (defaults to latest)", async () => {
-      const result = await getLatestVersion()
-      
-      expect(typeof result === "string" || result === null).toBe(true)
-    })
-  })
-})