@hiai-gg/hiai-opencode 0.1.0 → 0.1.1

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

@@ -1,139 +1,139 @@
-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;
-}
+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 +1,55 @@
-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;
-  }
-}
+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 +1,59 @@
-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);
-  }
-}
+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 +1,57 @@
-/**
- * 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;
-}
+/**
+ * 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;
+}