@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/comment-checker/cli-runner.ts

@@ -1,127 +0,0 @@
-import type { PendingCall } from "./types"
-import { existsSync } from "fs"
-
-import { runCommentChecker, getCommentCheckerPath, startBackgroundInit, type HookInput } from "./cli"
-
-let cliPathPromise: Promise<string | null> | null = null
-let isRunning = false
-
-async function withCommentCheckerLock<T>(
-  fn: () => Promise<T>,
-  fallback: T,
-  debugLog: (...args: unknown[]) => void,
-): Promise<T> {
-  if (isRunning) {
-    debugLog("comment-checker already running, skipping")
-    return fallback
-  }
-  isRunning = true
-  try {
-    return await fn()
-  } finally {
-    isRunning = false
-  }
-}
-
-export function initializeCommentCheckerCli(debugLog: (...args: unknown[]) => void): void {
-  // 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)
-    })
-}
-
-export function getCommentCheckerCliPathPromise(): Promise<string | null> | null {
-  return cliPathPromise
-}
-
-export async function processWithCli(
-  input: { tool: string; sessionID: string; callID: string },
-  pendingCall: PendingCall,
-  output: { output: string },
-  cliPath: string,
-  customPrompt: string | undefined,
-  debugLog: (...args: unknown[]) => void,
-  deps: {
-    runCommentChecker?: typeof runCommentChecker
-  } = {},
-): Promise<void> {
-  await withCommentCheckerLock(async () => {
-    void input
-    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 (deps.runCommentChecker ?? 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")
-    }
-  }, undefined, debugLog)
-}
-
-export interface ApplyPatchEdit {
-  filePath: string
-  before: string
-  after: string
-}
-
-export async function processApplyPatchEditsWithCli(
-  sessionID: string,
-  edits: ApplyPatchEdit[],
-  output: { output: string },
-  cliPath: string,
-  customPrompt: string | undefined,
-  debugLog: (...args: unknown[]) => void,
-): Promise<void> {
-  debugLog("processing apply_patch edits:", edits.length)
-
-  for (const edit of edits) {
-    await withCommentCheckerLock(async () => {
-      const hookInput: HookInput = {
-        session_id: sessionID,
-        tool_name: "Edit",
-        transcript_path: "",
-        cwd: process.cwd(),
-        hook_event_name: "PostToolUse",
-        tool_input: {
-          file_path: edit.filePath,
-          old_string: edit.before,
-          new_string: edit.after,
-        },
-      }
-
-      const result = await runCommentChecker(hookInput, cliPath, customPrompt)
-
-      if (result.hasComments && result.message) {
-        debugLog("CLI detected comments for apply_patch file:", edit.filePath)
-        output.output += `\n\n${result.message}`
-      }
-    }, undefined, debugLog)
-  }
-}
-
-export function isCliPathUsable(cliPath: string | null): cliPath is string {
-  return Boolean(cliPath && existsSync(cliPath))
-}

package/src/hooks/comment-checker/cli.ts

@@ -1,269 +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))
-
-  let didTimeout = false
-
-  try {
-    const args = [binaryPath, "check"]
-    if (customPrompt) {
-      args.push("--prompt", customPrompt)
-    }
-    
-    const proc = spawn(args, {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    let timeoutId: ReturnType<typeof setTimeout> | null = null
-    const timeoutPromise = new Promise<"timeout">(resolve => {
-      timeoutId = setTimeout(async () => {
-        didTimeout = true
-        debugLog("comment-checker timed out after 30s; sending SIGTERM")
-        try {
-          proc.kill("SIGTERM")
-        } catch (err) {
-          debugLog("failed to SIGTERM:", err)
-        }
-        const graceTimer = setTimeout(() => {
-          try {
-            proc.kill("SIGKILL")
-            debugLog("sent SIGKILL after grace period")
-          } catch {
-          }
-        }, 1000)
-        try {
-          await proc.exited
-        } catch {
-        }
-        clearTimeout(graceTimer)
-        resolve("timeout")
-      }, 30_000)
-    })
-
-    try {
-      // Write JSON to stdin
-      proc.stdin.write(jsonInput)
-      proc.stdin.end()
-
-      const stdoutPromise = new Response(proc.stdout).text()
-      const stderrPromise = new Response(proc.stderr).text()
-      const exitCodePromise = proc.exited
-
-      const raceResult = await Promise.race([
-        Promise.all([stdoutPromise, stderrPromise, exitCodePromise] as const),
-        timeoutPromise,
-      ])
-
-      if (raceResult === "timeout") {
-        return { hasComments: false, message: "" }
-      }
-
-      const [stdout, stderr, exitCode] = raceResult
-
-      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: "" }
-    } finally {
-      if (timeoutId !== null) {
-        clearTimeout(timeoutId)
-      }
-    }
-  } catch (err) {
-    if (didTimeout) {
-      return { hasComments: false, message: "" }
-    }
-    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/src/hooks/comment-checker/downloader.ts

@@ -1,170 +0,0 @@
-import { existsSync, appendFileSync } from "fs"
-import { join } from "path"
-import { homedir, tmpdir } from "os"
-import { createRequire } from "module"
-import {
-  cleanupArchive,
-  downloadArchive,
-  ensureCacheDir,
-  ensureExecutable,
-  extractTarGz,
-  extractZipArchive,
-  getCachedBinaryPath as getCachedBinaryPathShared,
-} from "../../shared/binary-downloader"
-import { log } from "../../shared/logger"
-import { CACHE_DIR_NAME, PUBLISHED_PACKAGE_NAME } from "../../shared/plugin-identity"
-
-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 hiai-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, CACHE_DIR_NAME, "bin")
-  }
-
-  const xdgCache = process.env.XDG_CACHE_HOME
-  const base = xdgCache || join(homedir(), ".cache")
-  return join(base, CACHE_DIR_NAME, "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 {
-  return getCachedBinaryPathShared(getCacheDir(), getBinaryName())
-}
-
-/**
- * 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"
-  }
-}
-
-/**
- * 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}`)
-  log(`[${PUBLISHED_PACKAGE_NAME}] Downloading comment-checker binary...`)
-  
-  try {
-    // Ensure cache directory exists
-    ensureCacheDir(cacheDir)
-    
-    const archivePath = join(cacheDir, assetName)
-    await downloadArchive(downloadUrl, archivePath)
-    
-    debugLog(`Downloaded archive to: ${archivePath}`)
-    
-    // Extract based on file type
-    if (ext === "tar.gz") {
-      debugLog("Extracting tar.gz:", archivePath, "to", cacheDir)
-      await extractTarGz(archivePath, cacheDir)
-    } else {
-      await extractZipArchive(archivePath, cacheDir)
-    }
-    
-    // Clean up archive
-    cleanupArchive(archivePath)
-    
-    // Set execute permission on Unix
-    ensureExecutable(binaryPath)
-    
-    debugLog(`Successfully downloaded binary to: ${binaryPath}`)
-    log(`[${PUBLISHED_PACKAGE_NAME}] comment-checker binary ready.`)
-    
-    return binaryPath
-    
-  } catch (err) {
-    debugLog(`Failed to download: ${err}`)
-    log(`[${PUBLISHED_PACKAGE_NAME}] Failed to download comment-checker: ${err instanceof Error ? err.message : err}`)
-    log(`[${PUBLISHED_PACKAGE_NAME}] 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()
-}