opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/claude-code-hooks/transcript.ts

@@ -1,252 +0,0 @@
-import { join } from "path"
-import { mkdirSync, appendFileSync, existsSync, writeFileSync, unlinkSync } from "fs"
-import { tmpdir } from "os"
-import { randomUUID } from "crypto"
-import type { TranscriptEntry } from "./types"
-import { transformToolName } from "../../shared/tool-name"
-import { getClaudeConfigDir } from "../../shared"
-
-const TRANSCRIPT_DIR = join(getClaudeConfigDir(), "transcripts")
-
-export function getTranscriptPath(sessionId: string): string {
-  return join(TRANSCRIPT_DIR, `${sessionId}.jsonl`)
-}
-
-function ensureTranscriptDir(): void {
-  if (!existsSync(TRANSCRIPT_DIR)) {
-    mkdirSync(TRANSCRIPT_DIR, { recursive: true })
-  }
-}
-
-export function appendTranscriptEntry(
-  sessionId: string,
-  entry: TranscriptEntry
-): void {
-  ensureTranscriptDir()
-  const path = getTranscriptPath(sessionId)
-  const line = JSON.stringify(entry) + "\n"
-  appendFileSync(path, line)
-}
-
-export function recordToolUse(
-  sessionId: string,
-  toolName: string,
-  toolInput: Record<string, unknown>
-): void {
-  appendTranscriptEntry(sessionId, {
-    type: "tool_use",
-    timestamp: new Date().toISOString(),
-    tool_name: toolName,
-    tool_input: toolInput,
-  })
-}
-
-export function recordToolResult(
-  sessionId: string,
-  toolName: string,
-  toolInput: Record<string, unknown>,
-  toolOutput: Record<string, unknown>
-): void {
-  appendTranscriptEntry(sessionId, {
-    type: "tool_result",
-    timestamp: new Date().toISOString(),
-    tool_name: toolName,
-    tool_input: toolInput,
-    tool_output: toolOutput,
-  })
-}
-
-export function recordUserMessage(
-  sessionId: string,
-  content: string
-): void {
-  appendTranscriptEntry(sessionId, {
-    type: "user",
-    timestamp: new Date().toISOString(),
-    content,
-  })
-}
-
-export function recordAssistantMessage(
-  sessionId: string,
-  content: string
-): void {
-  appendTranscriptEntry(sessionId, {
-    type: "assistant",
-    timestamp: new Date().toISOString(),
-    content,
-  })
-}
-
-// ============================================================================
-// Claude Code Compatible Transcript Builder (PORT FROM DISABLED)
-// ============================================================================
-
-/**
- * OpenCode API response type (loosely typed)
- */
-interface OpenCodeMessagePart {
-  type: string
-  tool?: string
-  state?: {
-    status?: string
-    input?: Record<string, unknown>
-  }
-}
-
-interface OpenCodeMessage {
-  info?: {
-    role?: string
-  }
-  parts?: OpenCodeMessagePart[]
-}
-
-/**
- * Claude Code compatible transcript entry (from disabled file)
- */
-interface DisabledTranscriptEntry {
-  type: "assistant"
-  message: {
-    role: "assistant"
-    content: Array<{
-      type: "tool_use"
-      name: string
-      input: Record<string, unknown>
-    }>
-  }
-}
-
-/**
- * Build Claude Code compatible transcript from session messages
- * 
- * PORT FROM DISABLED: This calls client.session.messages() API to fetch
- * the full session history and builds a JSONL file in Claude Code format.
- * 
- * @param client OpenCode client instance
- * @param sessionId Session ID
- * @param directory Working directory
- * @param currentToolName Current tool being executed (added as last entry)
- * @param currentToolInput Current tool input
- * @returns Temp file path (caller must call deleteTempTranscript!)
- */
-export async function buildTranscriptFromSession(
-  client: {
-    session: {
-      messages: (opts: { path: { id: string }; query?: { directory: string } }) => Promise<unknown>
-    }
-  },
-  sessionId: string,
-  directory: string,
-  currentToolName: string,
-  currentToolInput: Record<string, unknown>
-): Promise<string | null> {
-  try {
-    const response = await client.session.messages({
-      path: { id: sessionId },
-      query: { directory },
-    })
-
-    // Handle various response formats
-    const messages = (response as { "200"?: unknown[]; data?: unknown[] })["200"]
-      ?? (response as { data?: unknown[] }).data
-      ?? (Array.isArray(response) ? response : [])
-
-    const entries: string[] = []
-
-    if (Array.isArray(messages)) {
-      for (const msg of messages as OpenCodeMessage[]) {
-        if (msg.info?.role !== "assistant") continue
-
-        for (const part of msg.parts || []) {
-          if (part.type !== "tool") continue
-          if (part.state?.status !== "completed") continue
-          if (!part.state?.input) continue
-
-          const rawToolName = part.tool as string
-          const toolName = transformToolName(rawToolName)
-
-          const entry: DisabledTranscriptEntry = {
-            type: "assistant",
-            message: {
-              role: "assistant",
-              content: [
-                {
-                  type: "tool_use",
-                  name: toolName,
-                  input: part.state.input,
-                },
-              ],
-            },
-          }
-          entries.push(JSON.stringify(entry))
-        }
-      }
-    }
-
-    // Always add current tool call as the last entry
-    const currentEntry: DisabledTranscriptEntry = {
-      type: "assistant",
-      message: {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            name: transformToolName(currentToolName),
-            input: currentToolInput,
-          },
-        ],
-      },
-    }
-    entries.push(JSON.stringify(currentEntry))
-
-    // Write to temp file
-    const tempPath = join(
-      tmpdir(),
-      `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`
-    )
-    writeFileSync(tempPath, entries.join("\n") + "\n")
-
-    return tempPath
-  } catch {
-    // CRITICAL FIX: Even on API failure, create file with current tool entry only
-    // (matching original disabled behavior - never return null with incompatible format)
-    try {
-      const currentEntry: DisabledTranscriptEntry = {
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [
-            {
-              type: "tool_use",
-              name: transformToolName(currentToolName),
-              input: currentToolInput,
-            },
-          ],
-        },
-      }
-      const tempPath = join(
-        tmpdir(),
-        `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`
-      )
-      writeFileSync(tempPath, JSON.stringify(currentEntry) + "\n")
-      return tempPath
-    } catch {
-      // If even this fails, return null (truly catastrophic failure)
-      return null
-    }
-  }
-}
-
-/**
- * Delete temp transcript file (call in finally block)
- * 
- * PORT FROM DISABLED: Cleanup mechanism to avoid disk accumulation
- */
-export function deleteTempTranscript(path: string | null): void {
-  if (!path) return
-  try {
-    unlinkSync(path)
-  } catch {
-    // Ignore deletion errors
-  }
-}

package/oh-my-opencode/src/hooks/claude-code-hooks/types.ts

@@ -1,204 +0,0 @@
-/**
- * Claude Code Hooks Type Definitions
- * Maps Claude Code hook concepts to OpenCode plugin events
- */
-
-export type ClaudeHookEvent =
-  | "PreToolUse"
-  | "PostToolUse"
-  | "UserPromptSubmit"
-  | "Stop"
-  | "PreCompact"
-
-export interface HookMatcher {
-  matcher: string
-  hooks: HookCommand[]
-}
-
-export interface HookCommand {
-  type: "command"
-  command: string
-}
-
-export interface ClaudeHooksConfig {
-  PreToolUse?: HookMatcher[]
-  PostToolUse?: HookMatcher[]
-  UserPromptSubmit?: HookMatcher[]
-  Stop?: HookMatcher[]
-  PreCompact?: HookMatcher[]
-}
-
-export interface PreToolUseInput {
-  session_id: string
-  transcript_path?: string
-  cwd: string
-  permission_mode?: PermissionMode
-  hook_event_name: "PreToolUse"
-  tool_name: string
-  tool_input: Record<string, unknown>
-  tool_use_id?: string
-  hook_source?: HookSource
-}
-
-export interface PostToolUseInput {
-  session_id: string
-  transcript_path?: string
-  cwd: string
-  permission_mode?: PermissionMode
-  hook_event_name: "PostToolUse"
-  tool_name: string
-  tool_input: Record<string, unknown>
-  tool_response: {
-    title?: string
-    output?: string
-    [key: string]: unknown
-  }
-  tool_use_id?: string
-  hook_source?: HookSource
-}
-
-export interface UserPromptSubmitInput {
-  session_id: string
-  cwd: string
-  permission_mode?: PermissionMode
-  hook_event_name: "UserPromptSubmit"
-  prompt: string
-  session?: {
-    id: string
-  }
-  hook_source?: HookSource
-}
-
-export type PermissionMode = "default" | "plan" | "acceptEdits" | "bypassPermissions"
-
-export type HookSource = "opencode-plugin"
-
-export interface StopInput {
-  session_id: string
-  transcript_path?: string
-  cwd: string
-  permission_mode?: PermissionMode
-  hook_event_name: "Stop"
-  stop_hook_active: boolean
-  todo_path?: string
-  hook_source?: HookSource
-}
-
-export interface PreCompactInput {
-  session_id: string
-  cwd: string
-  hook_event_name: "PreCompact"
-  hook_source?: HookSource
-}
-
-export type PermissionDecision = "allow" | "deny" | "ask"
-
-/**
- * Common JSON fields for all hook outputs (Claude Code spec)
- */
-export interface HookCommonOutput {
-  /** If false, Claude stops entirely */
-  continue?: boolean
-  /** Message shown to user when continue=false */
-  stopReason?: string
-  /** Suppress output from transcript */
-  suppressOutput?: boolean
-  /** Warning/message displayed to user */
-  systemMessage?: string
-}
-
-export interface PreToolUseOutput extends HookCommonOutput {
-  /** Deprecated: use hookSpecificOutput.permissionDecision instead */
-  decision?: "allow" | "deny" | "approve" | "block" | "ask"
-  /** Deprecated: use hookSpecificOutput.permissionDecisionReason instead */
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName: "PreToolUse"
-    permissionDecision: PermissionDecision
-    permissionDecisionReason?: string
-    updatedInput?: Record<string, unknown>
-  }
-}
-
-export interface PostToolUseOutput extends HookCommonOutput {
-  decision?: "block"
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName: "PostToolUse"
-    /** Additional context to provide to Claude */
-    additionalContext?: string
-  }
-}
-
-export interface HookResult {
-  exitCode: number
-  stdout?: string
-  stderr?: string
-}
-
-export interface TranscriptEntry {
-  type: "tool_use" | "tool_result" | "user" | "assistant"
-  timestamp: string
-  tool_name?: string
-  tool_input?: Record<string, unknown>
-  tool_output?: Record<string, unknown>
-  content?: string
-}
-
-export interface TodoItem {
-  id: string
-  content: string
-  status: "pending" | "in_progress" | "completed" | "cancelled"
-  priority?: "low" | "medium" | "high"
-  created_at: string
-  updated_at?: string
-}
-
-export interface ClaudeCodeTodoItem {
-  content: string
-  status: string // "pending" | "in_progress" | "completed"
-  activeForm: string
-}
-
-export interface TodoFile {
-  session_id: string
-  items: TodoItem[]
-  created_at: string
-  updated_at: string
-}
-
-export interface StopOutput {
-  decision?: "block" | "continue"
-  reason?: string
-  stop_hook_active?: boolean
-  permission_mode?: PermissionMode
-  inject_prompt?: string
-}
-
-export interface PreCompactOutput extends HookCommonOutput {
-  /** Additional context to inject into compaction prompt */
-  context?: string[]
-  hookSpecificOutput?: {
-    hookEventName: "PreCompact"
-    /** Additional context strings to inject */
-    additionalContext?: string[]
-  }
-}
-
-export type ClaudeCodeContent =
-  | { type: "text"; text: string }
-  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
-  | { type: "tool_result"; tool_use_id: string; content: string }
-
-export interface ClaudeCodeMessage {
-  type: "user" | "assistant"
-  message: {
-    role: "user" | "assistant"
-    content: ClaudeCodeContent[]
-  }
-}
-
-export interface PluginConfig {
-  disabledHooks?: boolean | ClaudeHookEvent[]
-  keywordDetectorDisabled?: boolean
-}

package/oh-my-opencode/src/hooks/claude-code-hooks/user-prompt-submit.ts

@@ -1,117 +0,0 @@
-import type {
-  UserPromptSubmitInput,
-  PostToolUseOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, executeHookCommand, log } from "../../shared"
-import { DEFAULT_CONFIG } from "./plugin-config"
-import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
-
-const USER_PROMPT_SUBMIT_TAG_OPEN = "<user-prompt-submit-hook>"
-const USER_PROMPT_SUBMIT_TAG_CLOSE = "</user-prompt-submit-hook>"
-
-export interface MessagePart {
-  type: "text" | "tool_use" | "tool_result"
-  text?: string
-  [key: string]: unknown
-}
-
-export interface UserPromptSubmitContext {
-  sessionId: string
-  parentSessionId?: string
-  prompt: string
-  parts: MessagePart[]
-  cwd: string
-  permissionMode?: "default" | "acceptEdits" | "bypassPermissions"
-}
-
-export interface UserPromptSubmitResult {
-  block: boolean
-  reason?: string
-  modifiedParts: MessagePart[]
-  messages: string[]
-}
-
-export async function executeUserPromptSubmitHooks(
-  ctx: UserPromptSubmitContext,
-  config: ClaudeHooksConfig | null,
-  extendedConfig?: PluginExtendedConfig | null
-): Promise<UserPromptSubmitResult> {
-  const modifiedParts = ctx.parts
-  const messages: string[] = []
-
-  if (ctx.parentSessionId) {
-    return { block: false, modifiedParts, messages }
-  }
-
-  if (
-    ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_OPEN) &&
-    ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_CLOSE)
-  ) {
-    return { block: false, modifiedParts, messages }
-  }
-
-  if (!config) {
-    return { block: false, modifiedParts, messages }
-  }
-
-  const matchers = findMatchingHooks(config, "UserPromptSubmit")
-  if (matchers.length === 0) {
-    return { block: false, modifiedParts, messages }
-  }
-
-  const stdinData: UserPromptSubmitInput = {
-    session_id: ctx.sessionId,
-    cwd: ctx.cwd,
-    permission_mode: ctx.permissionMode ?? "bypassPermissions",
-    hook_event_name: "UserPromptSubmit",
-    prompt: ctx.prompt,
-    session: { id: ctx.sessionId },
-    hook_source: "opencode-plugin",
-  }
-
-  for (const matcher of matchers) {
-    for (const hook of matcher.hooks) {
-      if (hook.type !== "command") continue
-
-      if (isHookCommandDisabled("UserPromptSubmit", hook.command, extendedConfig ?? null)) {
-        log("UserPromptSubmit hook command skipped (disabled by config)", { command: hook.command })
-        continue
-      }
-
-      const result = await executeHookCommand(
-        hook.command,
-        JSON.stringify(stdinData),
-        ctx.cwd,
-        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
-      )
-
-      if (result.stdout) {
-        const output = result.stdout.trim()
-        if (output.startsWith(USER_PROMPT_SUBMIT_TAG_OPEN)) {
-          messages.push(output)
-        } else {
-          messages.push(`${USER_PROMPT_SUBMIT_TAG_OPEN}\n${output}\n${USER_PROMPT_SUBMIT_TAG_CLOSE}`)
-        }
-      }
-
-      if (result.exitCode !== 0) {
-        try {
-          const output = JSON.parse(result.stdout || "{}") as PostToolUseOutput
-          if (output.decision === "block") {
-            return {
-              block: true,
-              reason: output.reason || result.stderr,
-              modifiedParts,
-              messages,
-            }
-          }
-         } catch {
-          // Ignore JSON parse errors
-         }
-      }
-    }
-  }
-
-  return { block: false, modifiedParts, messages }
-}

package/oh-my-opencode/src/hooks/comment-checker/cli.test.ts

@@ -1,68 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from "bun:test"
-
-describe("comment-checker CLI path resolution", () => {
-  describe("lazy initialization", () => {
-    // #given module is imported
-    // #when COMMENT_CHECKER_CLI_PATH is accessed
-    // #then findCommentCheckerPathSync should NOT have been called during import
-    
-    test("getCommentCheckerPathSync should be lazy - not called on module import", async () => {
-      // #given a fresh module import
-      // We need to verify that importing the module doesn't immediately call findCommentCheckerPathSync
-      
-      // #when we import the module
-      const cliModule = await import("./cli")
-      
-      // #then getCommentCheckerPathSync should exist and be callable
-      expect(typeof cliModule.getCommentCheckerPathSync).toBe("function")
-      
-      // The key test: calling getCommentCheckerPathSync should work
-      // (we can't easily test that it wasn't called on import without mocking,
-      // but we can verify the function exists and returns expected types)
-      const result = cliModule.getCommentCheckerPathSync()
-      expect(result === null || typeof result === "string").toBe(true)
-    })
-
-    test("getCommentCheckerPathSync should cache result after first call", async () => {
-      // #given getCommentCheckerPathSync is called once
-      const cliModule = await import("./cli")
-      const firstResult = cliModule.getCommentCheckerPathSync()
-      
-      // #when called again
-      const secondResult = cliModule.getCommentCheckerPathSync()
-      
-      // #then should return same cached result
-      expect(secondResult).toBe(firstResult)
-    })
-
-    test("COMMENT_CHECKER_CLI_PATH export should not exist (removed for lazy loading)", async () => {
-      // #given the cli module
-      const cliModule = await import("./cli")
-      
-      // #when checking for COMMENT_CHECKER_CLI_PATH
-      // #then it should not exist (replaced with lazy getter)
-      expect("COMMENT_CHECKER_CLI_PATH" in cliModule).toBe(false)
-    })
-  })
-
-  describe("runCommentChecker", () => {
-    test("should use getCommentCheckerPathSync for fallback path resolution", async () => {
-      // #given runCommentChecker is called without explicit path
-      const { runCommentChecker } = await import("./cli")
-      
-      // #when called with input containing no comments
-      const result = await runCommentChecker({
-        session_id: "test",
-        tool_name: "Write",
-        transcript_path: "",
-        cwd: "/tmp",
-        hook_event_name: "PostToolUse",
-        tool_input: { file_path: "/tmp/test.ts", content: "const x = 1" },
-      })
-      
-      // #then should return CheckResult type (binary may or may not exist)
-      expect(typeof result.hasComments).toBe("boolean")
-      expect(typeof result.message).toBe("string")
-    })
-  })
-})