opencode-repos 0.3.0 → 0.3.2

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

@@ -1,221 +0,0 @@
-import { spawn } from "bun"
-import { createRequire } from "module"
-import { dirname, join } from "path"
-import { existsSync } from "fs"
-import * as fs from "fs"
-import { tmpdir } from "os"
-import { getCachedBinaryPath, ensureCommentCheckerBinary } from "./downloader"
-
-const DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1"
-const DEBUG_FILE = join(tmpdir(), "comment-checker-debug.log")
-
-function debugLog(...args: unknown[]) {
-  if (DEBUG) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}\n`
-    fs.appendFileSync(DEBUG_FILE, msg)
-  }
-}
-
-function getBinaryName(): string {
-  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker"
-}
-
-function findCommentCheckerPathSync(): string | null {
-  const binaryName = getBinaryName()
-
-  // Check cached binary first (safest path - no module resolution needed)
-  const cachedPath = getCachedBinaryPath()
-  if (cachedPath) {
-    debugLog("found binary in cache:", cachedPath)
-    return cachedPath
-  }
-
-  // Guard against undefined import.meta.url (can happen on Windows during plugin loading)
-  if (!import.meta.url) {
-    debugLog("import.meta.url is undefined, skipping package resolution")
-    return null
-  }
-
-  try {
-    const require = createRequire(import.meta.url)
-    const cliPkgPath = require.resolve("@code-yeongyu/comment-checker/package.json")
-    const cliDir = dirname(cliPkgPath)
-    const binaryPath = join(cliDir, "bin", binaryName)
-
-    if (existsSync(binaryPath)) {
-      debugLog("found binary in main package:", binaryPath)
-      return binaryPath
-    }
-  } catch (err) {
-    debugLog("main package not installed or resolution failed:", err)
-  }
-
-  debugLog("no binary found in known locations")
-  return null
-}
-
-// Cached resolved path
-let resolvedCliPath: string | null = null
-let initPromise: Promise<string | null> | null = null
-
-/**
- * Asynchronously get comment-checker binary path.
- * Will trigger lazy download if binary not found.
- */
-export async function getCommentCheckerPath(): Promise<string | null> {
-  // Return cached path if already resolved
-  if (resolvedCliPath !== null) {
-    return resolvedCliPath
-  }
-
-  // Return existing promise if initialization is in progress
-  if (initPromise) {
-    return initPromise
-  }
-
-  initPromise = (async () => {
-    // First try sync path resolution
-    const syncPath = findCommentCheckerPathSync()
-    if (syncPath && existsSync(syncPath)) {
-      resolvedCliPath = syncPath
-      debugLog("using sync-resolved path:", syncPath)
-      return syncPath
-    }
-
-    // Lazy download if not found
-    debugLog("triggering lazy download...")
-    const downloadedPath = await ensureCommentCheckerBinary()
-    if (downloadedPath) {
-      resolvedCliPath = downloadedPath
-      debugLog("using downloaded path:", downloadedPath)
-      return downloadedPath
-    }
-
-    debugLog("no binary available")
-    return null
-  })()
-
-  return initPromise
-}
-
-/**
- * Synchronously get comment-checker path (no download).
- * Returns cached path or searches known locations.
- */
-export function getCommentCheckerPathSync(): string | null {
-  return resolvedCliPath ?? findCommentCheckerPathSync()
-}
-
-/**
- * Start background initialization.
- * Call this early to trigger download while other init happens.
- */
-export function startBackgroundInit(): void {
-  if (!initPromise) {
-    initPromise = getCommentCheckerPath()
-    initPromise.then(path => {
-      debugLog("background init complete:", path || "no binary")
-    }).catch(err => {
-      debugLog("background init error:", err)
-    })
-  }
-}
-
-export interface HookInput {
-  session_id: string
-  tool_name: string
-  transcript_path: string
-  cwd: string
-  hook_event_name: string
-  tool_input: {
-    file_path?: string
-    content?: string
-    old_string?: string
-    new_string?: string
-    edits?: Array<{ old_string: string; new_string: string }>
-  }
-  tool_response?: unknown
-}
-
-export interface CheckResult {
-  hasComments: boolean
-  message: string
-}
-
-/**
- * Run comment-checker CLI with given input.
- * @param input Hook input to check
- * @param cliPath Optional explicit path to CLI binary
- * @param customPrompt Optional custom prompt to replace default warning message
- */
-export async function runCommentChecker(input: HookInput, cliPath?: string, customPrompt?: string): Promise<CheckResult> {
-  const binaryPath = cliPath ?? resolvedCliPath ?? getCommentCheckerPathSync()
-  
-  if (!binaryPath) {
-    debugLog("comment-checker binary not found")
-    return { hasComments: false, message: "" }
-  }
-
-  if (!existsSync(binaryPath)) {
-    debugLog("comment-checker binary does not exist:", binaryPath)
-    return { hasComments: false, message: "" }
-  }
-
-  const jsonInput = JSON.stringify(input)
-  debugLog("running comment-checker with input:", jsonInput.substring(0, 200))
-
-  try {
-    const args = [binaryPath]
-    if (customPrompt) {
-      args.push("--prompt", customPrompt)
-    }
-    
-    const proc = spawn(args, {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    // Write JSON to stdin
-    proc.stdin.write(jsonInput)
-    proc.stdin.end()
-
-    const stdout = await new Response(proc.stdout).text()
-    const stderr = await new Response(proc.stderr).text()
-    const exitCode = await proc.exited
-
-    debugLog("exit code:", exitCode, "stdout length:", stdout.length, "stderr length:", stderr.length)
-
-    if (exitCode === 0) {
-      return { hasComments: false, message: "" }
-    }
-
-    if (exitCode === 2) {
-      // Comments detected - message is in stderr
-      return { hasComments: true, message: stderr }
-    }
-
-    // Error case
-    debugLog("unexpected exit code:", exitCode, "stderr:", stderr)
-    return { hasComments: false, message: "" }
-  } catch (err) {
-    debugLog("failed to run comment-checker:", err)
-    return { hasComments: false, message: "" }
-  }
-}
-
-/**
- * Check if CLI is available (sync check, no download).
- */
-export function isCliAvailable(): boolean {
-  const path = getCommentCheckerPathSync()
-  return path !== null && existsSync(path)
-}
-
-/**
- * Check if CLI will be available (async, may trigger download).
- */
-export async function ensureCliAvailable(): Promise<boolean> {
-  const path = await getCommentCheckerPath()
-  return path !== null && existsSync(path)
-}

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

@@ -1,196 +0,0 @@
-import { spawn } from "bun"
-import { existsSync, mkdirSync, chmodSync, unlinkSync, appendFileSync } from "fs"
-import { join } from "path"
-import { homedir, tmpdir } from "os"
-import { createRequire } from "module"
-import { extractZip } from "../../shared"
-
-const DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1"
-const DEBUG_FILE = join(tmpdir(), "comment-checker-debug.log")
-
-function debugLog(...args: unknown[]) {
-  if (DEBUG) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:downloader] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}\n`
-    appendFileSync(DEBUG_FILE, msg)
-  }
-}
-
-const REPO = "code-yeongyu/go-claude-code-comment-checker"
-
-interface PlatformInfo {
-  os: string
-  arch: string
-  ext: "tar.gz" | "zip"
-}
-
-const PLATFORM_MAP: Record<string, PlatformInfo> = {
-  "darwin-arm64": { os: "darwin", arch: "arm64", ext: "tar.gz" },
-  "darwin-x64": { os: "darwin", arch: "amd64", ext: "tar.gz" },
-  "linux-arm64": { os: "linux", arch: "arm64", ext: "tar.gz" },
-  "linux-x64": { os: "linux", arch: "amd64", ext: "tar.gz" },
-  "win32-x64": { os: "windows", arch: "amd64", ext: "zip" },
-}
-
-/**
- * Get the cache directory for oh-my-opencode binaries.
- * On Windows: Uses %LOCALAPPDATA% or %APPDATA% (Windows conventions)
- * On Unix: Follows XDG Base Directory Specification
- */
-export function getCacheDir(): string {
-  if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA
-    const base = localAppData || join(homedir(), "AppData", "Local")
-    return join(base, "oh-my-opencode", "bin")
-  }
-
-  const xdgCache = process.env.XDG_CACHE_HOME
-  const base = xdgCache || join(homedir(), ".cache")
-  return join(base, "oh-my-opencode", "bin")
-}
-
-/**
- * Get the binary name based on platform.
- */
-export function getBinaryName(): string {
-  return process.platform === "win32" ? "comment-checker.exe" : "comment-checker"
-}
-
-/**
- * Get the cached binary path if it exists.
- */
-export function getCachedBinaryPath(): string | null {
-  const binaryPath = join(getCacheDir(), getBinaryName())
-  return existsSync(binaryPath) ? binaryPath : null
-}
-
-/**
- * Get the version from the installed @code-yeongyu/comment-checker package.
- */
-function getPackageVersion(): string {
-  try {
-    const require = createRequire(import.meta.url)
-    const pkg = require("@code-yeongyu/comment-checker/package.json")
-    return pkg.version
-  } catch {
-    // Fallback to hardcoded version if package not found
-    return "0.4.1"
-  }
-}
-
-/**
- * Extract tar.gz archive using system tar command.
- */
-async function extractTarGz(archivePath: string, destDir: string): Promise<void> {
-  debugLog("Extracting tar.gz:", archivePath, "to", destDir)
-  
-  const proc = spawn(["tar", "-xzf", archivePath, "-C", destDir], {
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  
-  const exitCode = await proc.exited
-  
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text()
-    throw new Error(`tar extraction failed (exit ${exitCode}): ${stderr}`)
-  }
-}
-
-
-
-/**
- * Download the comment-checker binary from GitHub Releases.
- * Returns the path to the downloaded binary, or null on failure.
- */
-export async function downloadCommentChecker(): Promise<string | null> {
-  const platformKey = `${process.platform}-${process.arch}`
-  const platformInfo = PLATFORM_MAP[platformKey]
-  
-  if (!platformInfo) {
-    debugLog(`Unsupported platform: ${platformKey}`)
-    return null
-  }
-  
-  const cacheDir = getCacheDir()
-  const binaryName = getBinaryName()
-  const binaryPath = join(cacheDir, binaryName)
-  
-  // Already exists in cache
-  if (existsSync(binaryPath)) {
-    debugLog("Binary already cached at:", binaryPath)
-    return binaryPath
-  }
-  
-  const version = getPackageVersion()
-  const { os, arch, ext } = platformInfo
-  const assetName = `comment-checker_v${version}_${os}_${arch}.${ext}`
-  const downloadUrl = `https://github.com/${REPO}/releases/download/v${version}/${assetName}`
-  
-  debugLog(`Downloading from: ${downloadUrl}`)
-  console.log(`[oh-my-opencode] Downloading comment-checker binary...`)
-  
-  try {
-    // Ensure cache directory exists
-    if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true })
-    }
-    
-    // Download with fetch() - Bun handles redirects automatically
-    const response = await fetch(downloadUrl, { redirect: "follow" })
-    
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-    }
-    
-    const archivePath = join(cacheDir, assetName)
-    const arrayBuffer = await response.arrayBuffer()
-    await Bun.write(archivePath, arrayBuffer)
-    
-    debugLog(`Downloaded archive to: ${archivePath}`)
-    
-    // Extract based on file type
-    if (ext === "tar.gz") {
-      await extractTarGz(archivePath, cacheDir)
-    } else {
-      await extractZip(archivePath, cacheDir)
-    }
-    
-    // Clean up archive
-    if (existsSync(archivePath)) {
-      unlinkSync(archivePath)
-    }
-    
-    // Set execute permission on Unix
-    if (process.platform !== "win32" && existsSync(binaryPath)) {
-      chmodSync(binaryPath, 0o755)
-    }
-    
-    debugLog(`Successfully downloaded binary to: ${binaryPath}`)
-    console.log(`[oh-my-opencode] comment-checker binary ready.`)
-    
-    return binaryPath
-    
-  } catch (err) {
-    debugLog(`Failed to download: ${err}`)
-    console.error(`[oh-my-opencode] Failed to download comment-checker: ${err instanceof Error ? err.message : err}`)
-    console.error(`[oh-my-opencode] Comment checking disabled.`)
-    return null
-  }
-}
-
-/**
- * Ensure the comment-checker binary is available.
- * First checks cache, then downloads if needed.
- * Returns the binary path or null if unavailable.
- */
-export async function ensureCommentCheckerBinary(): Promise<string | null> {
-  // Check cache first
-  const cachedPath = getCachedBinaryPath()
-  if (cachedPath) {
-    debugLog("Using cached binary:", cachedPath)
-    return cachedPath
-  }
-  
-  // Download if not cached
-  return downloadCommentChecker()
-}

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

@@ -1,171 +0,0 @@
-import type { PendingCall } from "./types"
-import { runCommentChecker, getCommentCheckerPath, startBackgroundInit, type HookInput } from "./cli"
-import type { CommentCheckerConfig } from "../../config/schema"
-
-import * as fs from "fs"
-import { existsSync } from "fs"
-import { tmpdir } from "os"
-import { join } from "path"
-
-const DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1"
-const DEBUG_FILE = join(tmpdir(), "comment-checker-debug.log")
-
-function debugLog(...args: unknown[]) {
-  if (DEBUG) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map(a => typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a)).join(' ')}\n`
-    fs.appendFileSync(DEBUG_FILE, msg)
-  }
-}
-
-const pendingCalls = new Map<string, PendingCall>()
-const PENDING_CALL_TTL = 60_000
-
-let cliPathPromise: Promise<string | null> | null = null
-let cleanupIntervalStarted = false
-
-function cleanupOldPendingCalls(): void {
-  const now = Date.now()
-  for (const [callID, call] of pendingCalls) {
-    if (now - call.timestamp > PENDING_CALL_TTL) {
-      pendingCalls.delete(callID)
-    }
-  }
-}
-
-export function createCommentCheckerHooks(config?: CommentCheckerConfig) {
-  debugLog("createCommentCheckerHooks called", { config })
-
-  if (!cleanupIntervalStarted) {
-    cleanupIntervalStarted = true
-    setInterval(cleanupOldPendingCalls, 10_000)
-  }
-  
-  // Start background CLI initialization (may trigger lazy download)
-  startBackgroundInit()
-  cliPathPromise = getCommentCheckerPath()
-  cliPathPromise.then(path => {
-    debugLog("CLI path resolved:", path || "disabled (no binary)")
-  }).catch(err => {
-    debugLog("CLI path resolution error:", err)
-  })
-  
-  return {
-    "tool.execute.before": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { args: Record<string, unknown> }
-    ): Promise<void> => {
-      debugLog("tool.execute.before:", { tool: input.tool, callID: input.callID, args: output.args })
-      
-      const toolLower = input.tool.toLowerCase()
-      if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
-        debugLog("skipping non-write/edit tool:", toolLower)
-        return
-      }
-
-      const filePath = (output.args.filePath ?? output.args.file_path ?? output.args.path) as string | undefined
-      const content = output.args.content as string | undefined
-      const oldString = output.args.oldString ?? output.args.old_string as string | undefined
-      const newString = output.args.newString ?? output.args.new_string as string | undefined
-      const edits = output.args.edits as Array<{ old_string: string; new_string: string }> | undefined
-
-      debugLog("extracted filePath:", filePath)
-
-      if (!filePath) {
-        debugLog("no filePath found")
-        return
-      }
-
-      debugLog("registering pendingCall:", { callID: input.callID, filePath, tool: toolLower })
-      pendingCalls.set(input.callID, {
-        filePath,
-        content,
-        oldString: oldString as string | undefined,
-        newString: newString as string | undefined,
-        edits,
-        tool: toolLower as "write" | "edit" | "multiedit",
-        sessionID: input.sessionID,
-        timestamp: Date.now(),
-      })
-    },
-
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { title: string; output: string; metadata: unknown }
-    ): Promise<void> => {
-      debugLog("tool.execute.after:", { tool: input.tool, callID: input.callID })
-      
-      const pendingCall = pendingCalls.get(input.callID)
-      if (!pendingCall) {
-        debugLog("no pendingCall found for:", input.callID)
-        return
-      }
-
-      pendingCalls.delete(input.callID)
-      debugLog("processing pendingCall:", pendingCall)
-
-      // Only skip if the output indicates a tool execution failure
-      const outputLower = output.output.toLowerCase()
-      const isToolFailure = 
-        outputLower.includes("error:") || 
-        outputLower.includes("failed to") ||
-        outputLower.includes("could not") ||
-        outputLower.startsWith("error")
-      
-      if (isToolFailure) {
-        debugLog("skipping due to tool failure in output")
-        return
-      }
-
-      try {
-        // Wait for CLI path resolution
-        const cliPath = await cliPathPromise
-        
-        if (!cliPath || !existsSync(cliPath)) {
-          // CLI not available - silently skip comment checking
-          debugLog("CLI not available, skipping comment check")
-          return
-        }
-        
-        // CLI mode only
-        debugLog("using CLI:", cliPath)
-        await processWithCli(input, pendingCall, output, cliPath, config?.custom_prompt)
-      } catch (err) {
-        debugLog("tool.execute.after failed:", err)
-      }
-    },
-  }
-}
-
-async function processWithCli(
-  input: { tool: string; sessionID: string; callID: string },
-  pendingCall: PendingCall,
-  output: { output: string },
-  cliPath: string,
-  customPrompt?: string
-): Promise<void> {
-  debugLog("using CLI mode with path:", cliPath)
-  
-  const hookInput: HookInput = {
-    session_id: pendingCall.sessionID,
-    tool_name: pendingCall.tool.charAt(0).toUpperCase() + pendingCall.tool.slice(1),
-    transcript_path: "",
-    cwd: process.cwd(),
-    hook_event_name: "PostToolUse",
-    tool_input: {
-      file_path: pendingCall.filePath,
-      content: pendingCall.content,
-      old_string: pendingCall.oldString,
-      new_string: pendingCall.newString,
-      edits: pendingCall.edits,
-    },
-  }
-  
-  const result = await runCommentChecker(hookInput, cliPath, customPrompt)
-  
-  if (result.hasComments && result.message) {
-    debugLog("CLI detected comments, appending message")
-    output.output += `\n\n${result.message}`
-  } else {
-    debugLog("CLI: no comments detected")
-  }
-}

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

@@ -1,33 +0,0 @@
-export type CommentType = "line" | "block" | "docstring"
-
-export interface CommentInfo {
-  text: string
-  lineNumber: number
-  filePath: string
-  commentType: CommentType
-  isDocstring: boolean
-  metadata?: Record<string, string>
-}
-
-export interface PendingCall {
-  filePath: string
-  content?: string
-  oldString?: string
-  newString?: string
-  edits?: Array<{ old_string: string; new_string: string }>
-  tool: "write" | "edit" | "multiedit"
-  sessionID: string
-  timestamp: number
-}
-
-export interface FileComments {
-  filePath: string
-  comments: CommentInfo[]
-}
-
-export interface FilterResult {
-  shouldSkip: boolean
-  reason?: string
-}
-
-export type CommentFilter = (comment: CommentInfo) => FilterResult

package/oh-my-opencode/src/hooks/compaction-context-injector/index.ts

@@ -1,61 +0,0 @@
-import { injectHookMessage } from "../../features/hook-message-injector"
-import { log } from "../../shared/logger"
-import { createSystemDirective, SystemDirectiveTypes } from "../../shared/system-directive"
-
-export interface SummarizeContext {
-  sessionID: string
-  providerID: string
-  modelID: string
-  usageRatio: number
-  directory: string
-}
-
-const SUMMARIZE_CONTEXT_PROMPT = `${createSystemDirective(SystemDirectiveTypes.COMPACTION_CONTEXT)}
-
-When summarizing this session, you MUST include the following sections in your summary:
-
-## 1. User Requests (As-Is)
-- List all original user requests exactly as they were stated
-- Preserve the user's exact wording and intent
-
-## 2. Final Goal
-- What the user ultimately wanted to achieve
-- The end result or deliverable expected
-
-## 3. Work Completed
-- What has been done so far
-- Files created/modified
-- Features implemented
-- Problems solved
-
-## 4. Remaining Tasks
-- What still needs to be done
-- Pending items from the original request
-- Follow-up tasks identified during the work
-
-## 5. MUST NOT Do (Critical Constraints)
-- Things that were explicitly forbidden
-- Approaches that failed and should not be retried
-- User's explicit restrictions or preferences
-- Anti-patterns identified during the session
-
-This context is critical for maintaining continuity after compaction.
-`
-
-export function createCompactionContextInjector() {
-  return async (ctx: SummarizeContext): Promise<void> => {
-    log("[compaction-context-injector] injecting context", { sessionID: ctx.sessionID })
-
-    const success = injectHookMessage(ctx.sessionID, SUMMARIZE_CONTEXT_PROMPT, {
-      agent: "general",
-      model: { providerID: ctx.providerID, modelID: ctx.modelID },
-      path: { cwd: ctx.directory },
-    })
-
-    if (success) {
-      log("[compaction-context-injector] context injected", { sessionID: ctx.sessionID })
-    } else {
-      log("[compaction-context-injector] injection failed", { sessionID: ctx.sessionID })
-    }
-  }
-}