@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/hooks/rules-injector/rule-file-finder.ts

@@ -1,139 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import {
-  PROJECT_RULE_FILES,
-  PROJECT_RULE_SUBDIRS,
-  USER_RULE_DIR,
-  OPENCODE_USER_RULE_DIRS,
-} from "./constants";
-import type { RuleFileCandidate } from "./types";
-import { findRuleFilesRecursive, safeRealpathSync } from "./rule-file-scanner";
-
-export interface FindRuleFilesOptions {
-  /**
-   * When true, skip loading rules from ~/.claude/rules/.
-   * Use when claude_code integration is disabled to prevent
-   * Claude Code-specific instructions from leaking into non-Claude agents.
-   */
-  skipClaudeUserRules?: boolean;
-}
-
-/**
- * Find all rule files for a given context.
- * Searches from currentFile upward to projectRoot for rule directories,
- * then user-level directory (~/.claude/rules).
- *
- * IMPORTANT: This searches EVERY directory from file to project root.
- * Not just the project root itself.
- *
- * @param projectRoot - Project root path (or null if outside any project)
- * @param homeDir - User home directory
- * @param currentFile - Current file being edited (for distance calculation)
- * @returns Array of rule file candidates sorted by distance
- */
-export function findRuleFiles(
-  projectRoot: string | null,
-  homeDir: string,
-  currentFile: string,
-  options?: FindRuleFilesOptions,
-): RuleFileCandidate[] {
-  const candidates: RuleFileCandidate[] = [];
-  const seenRealPaths = new Set<string>();
-
-  // Search from current file's directory up to project root
-  let currentDir = dirname(currentFile);
-  let distance = 0;
-
-  while (true) {
-    // Search rule directories in current directory
-    for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join(currentDir, parent, subdir);
-      const files: string[] = [];
-      findRuleFilesRecursive(ruleDir, files);
-
-      for (const filePath of files) {
-        const realPath = safeRealpathSync(filePath);
-        if (seenRealPaths.has(realPath)) continue;
-        seenRealPaths.add(realPath);
-
-        candidates.push({
-          path: filePath,
-          realPath,
-          isGlobal: false,
-          distance,
-        });
-      }
-    }
-
-    // Stop at project root or filesystem root
-    if (projectRoot && currentDir === projectRoot) break;
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-    distance++;
-  }
-
-  // Check for single-file rules at project root (e.g., .github/copilot-instructions.md)
-  if (projectRoot) {
-    for (const ruleFile of PROJECT_RULE_FILES) {
-      const filePath = join(projectRoot, ruleFile);
-      if (existsSync(filePath)) {
-        try {
-          const stat = statSync(filePath);
-          if (stat.isFile()) {
-            const realPath = safeRealpathSync(filePath);
-            if (!seenRealPaths.has(realPath)) {
-              seenRealPaths.add(realPath);
-              candidates.push({
-                path: filePath,
-                realPath,
-                isGlobal: false,
-                distance: 0,
-                isSingleFile: true,
-              });
-            }
-          }
-        } catch {
-          // Skip if file can't be read
-        }
-      }
-    }
-  }
-
-  // Search user-level rule directories
-  // Always search OpenCode-native dirs (~/.bob/rules, ~/.opencode/rules)
-  const userRuleDirs: string[] = OPENCODE_USER_RULE_DIRS.map((dir) => join(homeDir, dir));
-
-  // Only search ~/.claude/rules when claude_code integration is not disabled
-  if (!options?.skipClaudeUserRules) {
-    userRuleDirs.push(join(homeDir, USER_RULE_DIR));
-  }
-
-  for (const userRuleDir of userRuleDirs) {
-    const userFiles: string[] = [];
-    findRuleFilesRecursive(userRuleDir, userFiles);
-
-    for (const filePath of userFiles) {
-      const realPath = safeRealpathSync(filePath);
-      if (seenRealPaths.has(realPath)) continue;
-      seenRealPaths.add(realPath);
-
-      candidates.push({
-        path: filePath,
-        realPath,
-        isGlobal: true,
-        distance: 9999, // Global rules always have max distance
-      });
-    }
-  }
-
-  // Sort by distance (closest first, then global rules last)
-  candidates.sort((a, b) => {
-    if (a.isGlobal !== b.isGlobal) {
-      return a.isGlobal ? 1 : -1;
-    }
-    return a.distance - b.distance;
-  });
-
-  return candidates;
-}

package/src/hooks/rules-injector/rule-file-scanner.ts

@@ -1,55 +0,0 @@
-import { existsSync, readdirSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { GITHUB_INSTRUCTIONS_PATTERN, RULE_EXTENSIONS } from "./constants";
-
-function isGitHubInstructionsDir(dir: string): boolean {
-  return dir.includes(".github/instructions") || dir.endsWith(".github/instructions");
-}
-
-function isValidRuleFile(fileName: string, dir: string): boolean {
-  if (isGitHubInstructionsDir(dir)) {
-    return GITHUB_INSTRUCTIONS_PATTERN.test(fileName);
-  }
-  return RULE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
-}
-
-/**
- * Recursively find all rule files (*.md, *.mdc) in a directory
- *
- * @param dir - Directory to search
- * @param results - Array to accumulate results
- */
-export function findRuleFilesRecursive(dir: string, results: string[]): void {
-  if (!existsSync(dir)) return;
-
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        findRuleFilesRecursive(fullPath, results);
-      } else if (entry.isFile()) {
-        if (isValidRuleFile(entry.name, dir)) {
-          results.push(fullPath);
-        }
-      }
-    }
-  } catch {
-    // Permission denied or other errors - silently skip
-  }
-}
-
-/**
- * Resolve symlinks safely with fallback to original path
- *
- * @param filePath - Path to resolve
- * @returns Real path or original path if resolution fails
- */
-export function safeRealpathSync(filePath: string): string {
-  try {
-    return realpathSync(filePath);
-  } catch {
-    return filePath;
-  }
-}

package/src/hooks/rules-injector/storage.ts

@@ -1,59 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-} from "node:fs";
-import { join } from "node:path";
-import { RULES_INJECTOR_STORAGE } from "./constants";
-import type { InjectedRulesData } from "./types";
-
-function getStoragePath(sessionID: string): string {
-  return join(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
-}
-
-export function loadInjectedRules(sessionID: string): {
-  contentHashes: Set<string>;
-  realPaths: Set<string>;
-} {
-  const filePath = getStoragePath(sessionID);
-  if (!existsSync(filePath))
-    return { contentHashes: new Set(), realPaths: new Set() };
-
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const data: InjectedRulesData = JSON.parse(content);
-    return {
-      contentHashes: new Set(data.injectedHashes),
-      realPaths: new Set(data.injectedRealPaths ?? []),
-    };
-  } catch {
-    return { contentHashes: new Set(), realPaths: new Set() };
-  }
-}
-
-export function saveInjectedRules(
-  sessionID: string,
-  data: { contentHashes: Set<string>; realPaths: Set<string> }
-): void {
-  if (!existsSync(RULES_INJECTOR_STORAGE)) {
-    mkdirSync(RULES_INJECTOR_STORAGE, { recursive: true });
-  }
-
-  const storageData: InjectedRulesData = {
-    sessionID,
-    injectedHashes: [...data.contentHashes],
-    injectedRealPaths: [...data.realPaths],
-    updatedAt: Date.now(),
-  };
-
-  writeFileSync(getStoragePath(sessionID), JSON.stringify(storageData, null, 2));
-}
-
-export function clearInjectedRules(sessionID: string): void {
-  const filePath = getStoragePath(sessionID);
-  if (existsSync(filePath)) {
-    unlinkSync(filePath);
-  }
-}

package/src/hooks/rules-injector/types.ts

@@ -1,57 +0,0 @@
-/**
- * Rule file metadata (Claude Code style frontmatter)
- * Supports both Claude Code format (globs, paths) and GitHub Copilot format (applyTo)
- * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
- * @see https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
- */
-export interface RuleMetadata {
-  description?: string;
-  globs?: string | string[];
-  alwaysApply?: boolean;
-}
-
-/**
- * Rule information with path context and content
- */
-export interface RuleInfo {
-  /** Absolute path to the rule file */
-  path: string;
-  /** Path relative to project root */
-  relativePath: string;
-  /** Directory distance from target file (0 = same dir) */
-  distance: number;
-  /** Rule file content (without frontmatter) */
-  content: string;
-  /** SHA-256 hash of content for deduplication */
-  contentHash: string;
-  /** Parsed frontmatter metadata */
-  metadata: RuleMetadata;
-  /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
-  matchReason: string;
-  /** Real path after symlink resolution (for duplicate detection) */
-  realPath: string;
-}
-
-/**
- * Rule file candidate with discovery context
- */
-export interface RuleFileCandidate {
-  path: string;
-  realPath: string;
-  isGlobal: boolean;
-  distance: number;
-  /** Single-file rules (e.g., .github/copilot-instructions.md) always apply without frontmatter */
-  isSingleFile?: boolean;
-}
-
-/**
- * Session storage for injected rules tracking
- */
-export interface InjectedRulesData {
-  sessionID: string;
-  /** Content hashes of already injected rules */
-  injectedHashes: string[];
-  /** Real paths of already injected rules (for symlink deduplication) */
-  injectedRealPaths: string[];
-  updatedAt: number;
-}

package/src/hooks/runtime-fallback/AGENTS.md

@@ -1,102 +0,0 @@
-# src/hooks/runtime-fallback/ — Reactive Provider Error Recovery
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-32 files. Session Tier hook that **reactively** switches to fallback models when API providers return errors at runtime (429, 503, quota exhausted, cooldown signals). Distinct from `model-fallback` (which applies preemptively at chat.params).
-
-## RUNTIME-FALLBACK vs MODEL-FALLBACK
-
-| Aspect | runtime-fallback | model-fallback |
-|--------|-----------------|----------------|
-| **Trigger** | Reactive — after error occurs | Proactive — at request time |
-| **Event** | session.error, message.updated, session.status | chat.params |
-| **Config source** | `categories[].fallback_models`, `agents[].fallback_models` | `AGENT_MODEL_REQUIREMENTS` hardcoded chains |
-| **State** | Per-session FallbackState + cooldown tracking | Module-global pendingModelFallbacks |
-| **Use case** | Provider errors during execution | Pre-configured agent fallback chains |
-
-They operate **independently** — no direct integration.
-
-## ERROR DETECTION
-
-### HTTP Status Codes (configurable)
-Default retry codes: `429, 500, 502, 503, 504`
-
-### Error Message Patterns (constants.ts)
-```
-/rate.?limit/i, /too.?many.?requests/i, /quota.*reset.*after/i,
-/exhausted.*capacity/i, /all.*credentials.*for.*model/i,
-/cool(?:ing)?.?down/i, /model.*not.*supported/i,
-/service.?unavailable/i, /overloaded/i, /temporarily.?unavailable/i
-```
-
-### Error Type Classification (error-classifier.ts)
-- `missing_api_key` — provider rejects auth
-- `model_not_found` — model unavailable
-- `quota_exceeded` — billing/quota hit
-- Auto-retry signal detection via `auto-retry-signal.ts` — extracts "retrying in ~2 weeks" style signals, triggers immediate fallback
-
-## FALLBACK STATE MACHINE
-
-```typescript
-interface FallbackState {
-  originalModel: string
-  currentModel: string
-  fallbackIndex: number
-  failedModels: Map<string, number>  // model → cooldown-until timestamp
-  attemptCount: number
-  pendingFallbackModel?: string
-}
-```
-
-## FALLBACK CHAIN RESOLUTION (fallback-models.ts)
-
-Priority order:
-1. **Session category** (via SessionCategoryRegistry)
-2. **Agent config** `fallback_models`
-3. **Agent's category** `fallback_models`
-4. **Session ID pattern match** (detect agent from session ID format)
-
-## RETRY FLOW
-
-```
-session.error / message.updated (with error) / session.status (retry signal)
-  → isRetryableError(error)?
-  → getFallbackModelsForSession(sessionID, agent)
-  → findNextAvailableFallback() — skip cooldown models
-  → prepareFallback() — update state, mark current failed
-  → dispatchFallbackRetry() — toast notification + promptAsync with new model
-  → 30s timeout — abort and try next if exceeded
-```
-
-## COOLDOWN MECHANISM
-
-Failed models enter 60s cooldown. `findNextAvailableFallback()` skips models in cooldown, preventing thrashing on persistently failing models.
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `hook.ts` | `createRuntimeFallbackHook()` — composes all handlers |
-| `event-handler.ts` | Route session lifecycle (created, error, stop, idle) |
-| `message-update-handler.ts` | Handle error parts in `message.updated` |
-| `session-status-handler.ts` | Handle provider retry signals in session.status |
-| `chat-message-handler.ts` | Apply fallback model override on chat.message |
-| `error-classifier.ts` | `isRetryableError()`, `classifyErrorType()` |
-| `auto-retry-signal.ts` | Extract "retrying in..." signals |
-| `fallback-state.ts` | State machine: createFallbackState, prepareFallback, findNextAvailableFallback, isModelInCooldown |
-| `fallback-models.ts` | Resolve chain from config hierarchy (strings + raw objects) |
-| `fallback-bootstrap-model.ts` | Derive initial model when state missing |
-| `fallback-retry-dispatcher.ts` | Toast + dispatch retry orchestration |
-| `auto-retry.ts` | Abort, timeout scheduling, cleanup |
-| `agent-resolver.ts` | Session → agent name normalization |
-| `retry-model-payload.ts` | Build model payload (providerID/modelID/variant/reasoningEffort) |
-| `visible-assistant-response.ts` | Detect if assistant produced real output vs just errors |
-| `last-user-retry-parts.ts` | Extract last user message parts for retry |
-
-## NOTES
-
-- Cooldown and failure tracking are **per-session** — concurrent sessions don't share state
-- `visible-assistant-response.ts` prevents retry if the assistant already produced a partial valid response
-- Runtime-fallback is registered in the Session Tier via `create-session-hooks.ts`

package/src/hooks/runtime-fallback/agent-resolver.ts

@@ -1,50 +0,0 @@
-import { getSessionAgent } from "../../features/claude-code-session-state"
-
-export const AGENT_NAMES = [
-  "bob",
-  "strategist",
-  "guard",
-  "critic",
-  "coder",
-  "sub",
-  "build",
-  "plan",
-  "ui",
-]
-
-export const agentPattern = new RegExp(
-  `\\b(${AGENT_NAMES
-    .sort((a, b) => b.length - a.length)
-    .map((a) => a.replace(/-/g, "\\-"))
-    .join("|")})\\b`,
-  "i",
-)
-
-export function detectAgentFromSession(sessionID: string): string | undefined {
-  const match = sessionID.match(agentPattern)
-  if (match) {
-    return match[1].toLowerCase()
-  }
-  return undefined
-}
-
-export function normalizeAgentName(agent: string | undefined): string | undefined {
-  if (!agent) return undefined
-  const normalized = agent.toLowerCase().trim()
-  if (AGENT_NAMES.includes(normalized)) {
-    return normalized
-  }
-  const match = normalized.match(agentPattern)
-  if (match) {
-    return match[1].toLowerCase()
-  }
-  return undefined
-}
-
-export function resolveAgentForSession(sessionID: string, eventAgent?: string): string | undefined {
-  return (
-    normalizeAgentName(eventAgent) ??
-    normalizeAgentName(getSessionAgent(sessionID)) ??
-    detectAgentFromSession(sessionID)
-  )
-}

package/src/hooks/runtime-fallback/auto-retry-signal.ts

@@ -1,32 +0,0 @@
-export interface AutoRetrySignal {
-  signal: string
-}
-
-const AUTO_RETRY_PATTERNS: Array<(combined: string) => boolean> = [
-  (combined) => /retrying\s+in/i.test(combined),
-  (combined) =>
-    /(?:too\s+many\s+requests|quota\s+will\s+reset\s+after|quota\s*exceeded|usage\s+limit|rate\s+limit|limit\s+reached|all\s+credentials\s+for\s+model|cool(?:ing)?\s*down|exhausted\s+your\s+capacity)/i.test(combined),
-]
-
-export function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined {
-  if (!info) return undefined
-
-  const candidates: string[] = []
-
-  const directStatus = info.status
-  if (typeof directStatus === "string") candidates.push(directStatus)
-
-  const summary = info.summary
-  if (typeof summary === "string") candidates.push(summary)
-
-  const message = info.message
-  if (typeof message === "string") candidates.push(message)
-
-  const details = info.details
-  if (typeof details === "string") candidates.push(details)
-
-  const combined = candidates.join("\n")
-  if (!combined) return undefined
-
-  return AUTO_RETRY_PATTERNS.some((test) => test(combined)) ? { signal: combined } : undefined
-}