@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

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

@@ -1,189 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { relative, resolve } from "node:path";
-import { findProjectRoot, findRuleFiles } from "./finder";
-import type { FindRuleFilesOptions } from "./rule-file-finder";
-import {
-  createContentHash,
-  isDuplicateByContentHash,
-  isDuplicateByRealPath,
-  shouldApplyRule,
-} from "./matcher";
-import { parseRuleFrontmatter } from "./parser";
-import { saveInjectedRules } from "./storage";
-import type { SessionInjectedRulesCache } from "./cache";
-import type { RuleMetadata } from "./types";
-
-type ToolExecuteOutput = {
-  title: string;
-  output: string;
-  metadata: unknown;
-};
-
-type RuleToInject = {
-  relativePath: string;
-  matchReason: string;
-  content: string;
-  distance: number;
-};
-
-type DynamicTruncator = {
-  truncate: (
-    sessionID: string,
-    content: string
-  ) => Promise<{ result: string; truncated: boolean }>;
-};
-
-interface ParsedRuleEntry {
-  mtimeMs: number;
-  size: number;
-  metadata: RuleMetadata;
-  body: string;
-}
-
-const parsedRuleCache = new Map<string, ParsedRuleEntry>();
-
-function resolveFilePath(
-  workspaceDirectory: string,
-  path: string
-): string | null {
-  if (!path) return null;
-  if (path.startsWith("/")) return path;
-  return resolve(workspaceDirectory, path);
-}
-
-export function createRuleInjectionProcessor(deps: {
-  workspaceDirectory: string;
-  truncator: DynamicTruncator;
-  getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
-  ruleFinderOptions?: FindRuleFilesOptions;
-  readFileSync?: typeof readFileSync;
-  statSync?: typeof statSync;
-  homedir?: typeof homedir;
-  shouldApplyRule?: typeof shouldApplyRule;
-  isDuplicateByRealPath?: typeof isDuplicateByRealPath;
-  createContentHash?: typeof createContentHash;
-  isDuplicateByContentHash?: typeof isDuplicateByContentHash;
-  saveInjectedRules?: typeof saveInjectedRules;
-}): {
-  processFilePathForInjection: (
-    filePath: string,
-    sessionID: string,
-    output: ToolExecuteOutput
-  ) => Promise<void>;
-} {
-  const {
-    workspaceDirectory,
-    truncator,
-    getSessionCache,
-    ruleFinderOptions,
-    readFileSync: readRuleFileSync = readFileSync,
-    statSync: statRuleSync = statSync,
-    homedir: getHomeDir = homedir,
-    shouldApplyRule: shouldApplyRuleImpl = shouldApplyRule,
-    isDuplicateByRealPath: isDuplicateByRealPathImpl = isDuplicateByRealPath,
-    createContentHash: createContentHashImpl = createContentHash,
-    isDuplicateByContentHash: isDuplicateByContentHashImpl = isDuplicateByContentHash,
-    saveInjectedRules: saveInjectedRulesImpl = saveInjectedRules,
-  } = deps;
-
-  function getParsedRule(filePath: string, realPath: string): { metadata: RuleMetadata; body: string } {
-    try {
-      const stat = statRuleSync(filePath);
-      const cached = parsedRuleCache.get(realPath);
-
-      if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-        return { metadata: cached.metadata, body: cached.body };
-      }
-
-      const rawContent = readRuleFileSync(filePath, "utf-8");
-      const { metadata, body } = parseRuleFrontmatter(rawContent);
-      parsedRuleCache.set(realPath, {
-        mtimeMs: stat.mtimeMs,
-        size: stat.size,
-        metadata,
-        body,
-      });
-      return { metadata, body };
-    } catch {
-      const rawContent = readRuleFileSync(filePath, "utf-8");
-      return parseRuleFrontmatter(rawContent);
-    }
-  }
-
-  async function processFilePathForInjection(
-    filePath: string,
-    sessionID: string,
-    output: ToolExecuteOutput
-  ): Promise<void> {
-    const resolved = resolveFilePath(workspaceDirectory, filePath);
-    if (!resolved) return;
-
-    const projectRoot = findProjectRoot(resolved);
-    const cache = getSessionCache(sessionID);
-    const home = getHomeDir();
-
-    const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved, ruleFinderOptions);
-    const toInject: RuleToInject[] = [];
-    let dirty = false;
-
-    for (const candidate of ruleFileCandidates) {
-      if (isDuplicateByRealPathImpl(candidate.realPath, cache.realPaths)) continue;
-
-      try {
-        const { metadata, body } = getParsedRule(
-          candidate.path,
-          candidate.realPath
-        );
-
-        let matchReason: string;
-        if (candidate.isSingleFile) {
-          matchReason = "copilot-instructions (always apply)";
-        } else {
-          const matchResult = shouldApplyRuleImpl(metadata, resolved, projectRoot);
-          if (!matchResult.applies) continue;
-          matchReason = matchResult.reason ?? "matched";
-        }
-
-        const contentHash = createContentHashImpl(body);
-        if (isDuplicateByContentHashImpl(contentHash, cache.contentHashes)) continue;
-
-        const relativePath = projectRoot
-          ? relative(projectRoot, candidate.path)
-          : candidate.path;
-
-        toInject.push({
-          relativePath,
-          matchReason,
-          content: body,
-          distance: candidate.distance,
-        });
-
-        cache.realPaths.add(candidate.realPath);
-        cache.contentHashes.add(contentHash);
-        dirty = true;
-      } catch {}
-    }
-
-    if (toInject.length === 0) return;
-
-    toInject.sort((a, b) => a.distance - b.distance);
-
-    for (const rule of toInject) {
-      const { result, truncated } = await truncator.truncate(
-        sessionID,
-        rule.content
-      );
-      const truncationNotice = truncated
-        ? `\n\n[Note: Content was truncated to save context window space. For full context, please read the file directly: ${rule.relativePath}]`
-        : "";
-      output.output += `\n\n[Rule: ${rule.relativePath}]\n[Match: ${rule.matchReason}]\n${result}${truncationNotice}`;
-    }
-
-    if (dirty) {
-      saveInjectedRulesImpl(sessionID, cache);
-    }
-  }
-
-  return { processFilePathForInjection };
-}

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

@@ -1,63 +0,0 @@
-import { createHash } from "crypto"
-import { relative } from "node:path"
-import picomatch from "picomatch"
-import type { RuleMetadata } from "./types"
-
-export interface MatchResult {
-  applies: boolean
-  reason?: string
-}
-
-/**
- * Check if a rule should apply to the current file based on metadata
- */
-export function shouldApplyRule(
-  metadata: RuleMetadata,
-  currentFilePath: string,
-  projectRoot: string | null
-): MatchResult {
-  if (metadata.alwaysApply === true) {
-    return { applies: true, reason: "alwaysApply" }
-  }
-
-  const globs = metadata.globs
-  if (!globs) {
-    return { applies: false }
-  }
-
-  const patterns = Array.isArray(globs) ? globs : [globs]
-  if (patterns.length === 0) {
-    return { applies: false }
-  }
-
-  const relativePath = projectRoot ? relative(projectRoot, currentFilePath) : currentFilePath
-
-  for (const pattern of patterns) {
-    if (picomatch.isMatch(relativePath, pattern, { dot: true, bash: true })) {
-      return { applies: true, reason: `glob: ${pattern}` }
-    }
-  }
-
-  return { applies: false }
-}
-
-/**
- * Check if realPath already exists in cache (symlink deduplication)
- */
-export function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean {
-  return cache.has(realPath)
-}
-
-/**
- * Create SHA-256 hash of content, truncated to 16 chars
- */
-export function createContentHash(content: string): string {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16)
-}
-
-/**
- * Check if content hash already exists in cache
- */
-export function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean {
-  return cache.has(hash)
-}

package/src/hooks/rules-injector/output-path.ts

@@ -1,22 +0,0 @@
-export interface ToolExecuteOutputShape {
-  title: string;
-  metadata: unknown;
-}
-
-export function getRuleInjectionFilePath(
-  output: ToolExecuteOutputShape
-): string | null {
-  const metadata = output.metadata as Record<string, unknown> | null;
-  const metadataFilePath =
-    metadata && typeof metadata === "object" ? metadata.filePath : undefined;
-
-  if (typeof metadataFilePath === "string" && metadataFilePath.length > 0) {
-    return metadataFilePath;
-  }
-
-  if (typeof output.title === "string" && output.title.length > 0) {
-    return output.title;
-  }
-
-  return null;
-}

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

@@ -1,211 +0,0 @@
-import type { RuleMetadata } from "./types";
-
-export interface RuleFrontmatterResult {
-  metadata: RuleMetadata;
-  body: string;
-}
-
-/**
- * Parse YAML frontmatter from rule file content
- * Supports:
- * - Single string: globs: "**\/*.py"
- * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
- * - Multi-line array:
- *   globs:
- *     - "**\/*.py"
- *     - "src/**\/*.ts"
- * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
- * - Claude Code 'paths' field (alias for globs)
- */
-export function parseRuleFrontmatter(content: string): RuleFrontmatterResult {
-  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-  const match = content.match(frontmatterRegex);
-
-  if (!match) {
-    return { metadata: {}, body: content };
-  }
-
-  const yamlContent = match[1];
-  const body = match[2];
-
-  try {
-    const metadata = parseYamlContent(yamlContent);
-    return { metadata, body };
-  } catch {
-    return { metadata: {}, body: content };
-  }
-}
-
-/**
- * Parse YAML content without external library
- */
-function parseYamlContent(yamlContent: string): RuleMetadata {
-  const lines = yamlContent.split("\n");
-  const metadata: RuleMetadata = {};
-
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const colonIndex = line.indexOf(":");
-
-    if (colonIndex === -1) {
-      i++;
-      continue;
-    }
-
-    const key = line.slice(0, colonIndex).trim();
-    const rawValue = line.slice(colonIndex + 1).trim();
-
-    if (key === "description") {
-      metadata.description = parseStringValue(rawValue);
-    } else if (key === "alwaysApply") {
-      metadata.alwaysApply = rawValue === "true";
-    } else if (key === "globs" || key === "paths" || key === "applyTo") {
-      const { value, consumed } = parseArrayOrStringValue(rawValue, lines, i);
-      // Merge paths into globs (Claude Code compatibility)
-      if (key === "paths") {
-        metadata.globs = mergeGlobs(metadata.globs, value);
-      } else {
-        metadata.globs = mergeGlobs(metadata.globs, value);
-      }
-      i += consumed;
-      continue;
-    }
-
-    i++;
-  }
-
-  return metadata;
-}
-
-/**
- * Parse a string value, removing surrounding quotes
- */
-function parseStringValue(value: string): string {
-  if (!value) return "";
-
-  // Remove surrounding quotes
-  if (
-    (value.startsWith('"') && value.endsWith('"')) ||
-    (value.startsWith("'") && value.endsWith("'"))
-  ) {
-    return value.slice(1, -1);
-  }
-
-  return value;
-}
-
-/**
- * Parse array or string value from YAML
- * Returns the parsed value and number of lines consumed
- */
-function parseArrayOrStringValue(
-  rawValue: string,
-  lines: string[],
-  currentIndex: number
-): { value: string | string[]; consumed: number } {
-  // Case 1: Inline array ["a", "b", "c"]
-  if (rawValue.startsWith("[")) {
-    return { value: parseInlineArray(rawValue), consumed: 1 };
-  }
-
-  // Case 2: Multi-line array (value is empty, next lines start with "  - ")
-  if (!rawValue || rawValue === "") {
-    const arrayItems: string[] = [];
-    let consumed = 1;
-
-    for (let j = currentIndex + 1; j < lines.length; j++) {
-      const nextLine = lines[j];
-
-      // Check if this is an array item (starts with whitespace + dash)
-      const arrayMatch = nextLine.match(/^\s+-\s*(.*)$/);
-      if (arrayMatch) {
-        const itemValue = parseStringValue(arrayMatch[1].trim());
-        if (itemValue) {
-          arrayItems.push(itemValue);
-        }
-        consumed++;
-      } else if (nextLine.trim() === "") {
-        // Skip empty lines within array
-        consumed++;
-      } else {
-        // Not an array item, stop
-        break;
-      }
-    }
-
-    if (arrayItems.length > 0) {
-      return { value: arrayItems, consumed };
-    }
-  }
-
-  // Case 3: Comma-separated patterns in single string
-  const stringValue = parseStringValue(rawValue);
-  if (stringValue.includes(",")) {
-    const items = stringValue
-      .split(",")
-      .map((s) => s.trim())
-      .filter((s) => s.length > 0);
-    return { value: items, consumed: 1 };
-  }
-
-  // Case 4: Single string value
-  return { value: stringValue, consumed: 1 };
-}
-
-/**
- * Parse inline JSON-like array: ["a", "b", "c"]
- */
-function parseInlineArray(value: string): string[] {
-  // Remove brackets
-  const content = value.slice(1, value.lastIndexOf("]")).trim();
-  if (!content) return [];
-
-  const items: string[] = [];
-  let current = "";
-  let inQuote = false;
-  let quoteChar = "";
-
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i];
-
-    if (!inQuote && (char === '"' || char === "'")) {
-      inQuote = true;
-      quoteChar = char;
-    } else if (inQuote && char === quoteChar) {
-      inQuote = false;
-      quoteChar = "";
-    } else if (!inQuote && char === ",") {
-      const trimmed = current.trim();
-      if (trimmed) {
-        items.push(parseStringValue(trimmed));
-      }
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-
-  // Don't forget the last item
-  const trimmed = current.trim();
-  if (trimmed) {
-    items.push(parseStringValue(trimmed));
-  }
-
-  return items;
-}
-
-/**
- * Merge two globs values (for combining paths and globs)
- */
-function mergeGlobs(
-  existing: string | string[] | undefined,
-  newValue: string | string[]
-): string | string[] {
-  if (!existing) return newValue;
-
-  const existingArray = Array.isArray(existing) ? existing : [existing];
-  const newArray = Array.isArray(newValue) ? newValue : [newValue];
-
-  return [...existingArray, ...newArray];
-}

package/src/hooks/rules-injector/project-root-finder.ts

@@ -1,36 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { PROJECT_MARKERS } from "./constants";
-
-/**
- * Find project root by walking up from startPath.
- * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)
- *
- * @param startPath - Starting path to search from (file or directory)
- * @returns Project root path or null if not found
- */
-export function findProjectRoot(startPath: string): string | null {
-  let current: string;
-
-  try {
-    const stat = statSync(startPath);
-    current = stat.isDirectory() ? startPath : dirname(startPath);
-  } catch {
-    current = dirname(startPath);
-  }
-
-  while (true) {
-    for (const marker of PROJECT_MARKERS) {
-      const markerPath = join(current, marker);
-      if (existsSync(markerPath)) {
-        return current;
-      }
-    }
-
-    const parent = dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}

package/src/hooks/rules-injector/rule-distance.ts

@@ -1,53 +0,0 @@
-import { dirname, relative } from "node:path";
-
-/**
- * Calculate directory distance between a rule file and current file.
- * Distance is based on common ancestor within project root.
- *
- * @param rulePath - Path to the rule file
- * @param currentFile - Path to the current file being edited
- * @param projectRoot - Project root for relative path calculation
- * @returns Distance (0 = same directory, higher = further)
- */
-export function calculateDistance(
-  rulePath: string,
-  currentFile: string,
-  projectRoot: string | null,
-): number {
-  if (!projectRoot) {
-    return 9999;
-  }
-
-  try {
-    const ruleDir = dirname(rulePath);
-    const currentDir = dirname(currentFile);
-
-    const ruleRel = relative(projectRoot, ruleDir);
-    const currentRel = relative(projectRoot, currentDir);
-
-    // Handle paths outside project root
-    if (ruleRel.startsWith("..") || currentRel.startsWith("..")) {
-      return 9999;
-    }
-
-    // Split by both forward and back slashes for cross-platform compatibility
-    // path.relative() returns OS-native separators (backslashes on Windows)
-    const ruleParts = ruleRel ? ruleRel.split(/[/\\]/) : [];
-    const currentParts = currentRel ? currentRel.split(/[/\\]/) : [];
-
-    // Find common prefix length
-    let common = 0;
-    for (let i = 0; i < Math.min(ruleParts.length, currentParts.length); i++) {
-      if (ruleParts[i] === currentParts[i]) {
-        common++;
-      } else {
-        break;
-      }
-    }
-
-    // Distance is how many directories up from current file to common ancestor
-    return currentParts.length - common;
-  } catch {
-    return 9999;
-  }
-}