opencode-repos 0.3.0 → 0.3.1

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

@@ -1,223 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { relative, resolve } from "node:path";
-import { findProjectRoot, findRuleFiles } from "./finder";
-import {
-  createContentHash,
-  isDuplicateByContentHash,
-  isDuplicateByRealPath,
-  shouldApplyRule,
-} from "./matcher";
-import { parseRuleFrontmatter } from "./parser";
-import {
-  clearInjectedRules,
-  loadInjectedRules,
-  saveInjectedRules,
-} from "./storage";
-import { createDynamicTruncator } from "../../shared/dynamic-truncator";
-
-interface ToolExecuteInput {
-  tool: string;
-  sessionID: string;
-  callID: string;
-}
-
-interface ToolExecuteOutput {
-  title: string;
-  output: string;
-  metadata: unknown;
-}
-
-interface ToolExecuteBeforeOutput {
-  args: unknown;
-}
-
-interface BatchToolCall {
-  tool: string;
-  parameters: Record<string, unknown>;
-}
-
-interface EventInput {
-  event: {
-    type: string;
-    properties?: unknown;
-  };
-}
-
-interface RuleToInject {
-  relativePath: string;
-  matchReason: string;
-  content: string;
-  distance: number;
-}
-
-const TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
-
-export function createRulesInjectorHook(ctx: PluginInput) {
-  const sessionCaches = new Map<
-    string,
-    { contentHashes: Set<string>; realPaths: Set<string> }
-  >();
-  const pendingBatchFiles = new Map<string, string[]>();
-  const truncator = createDynamicTruncator(ctx);
-
-  function getSessionCache(sessionID: string): {
-    contentHashes: Set<string>;
-    realPaths: Set<string>;
-  } {
-    if (!sessionCaches.has(sessionID)) {
-      sessionCaches.set(sessionID, loadInjectedRules(sessionID));
-    }
-    return sessionCaches.get(sessionID)!;
-  }
-
-  function resolveFilePath(path: string): string | null {
-    if (!path) return null;
-    if (path.startsWith("/")) return path;
-    return resolve(ctx.directory, path);
-  }
-
-  async function processFilePathForInjection(
-    filePath: string,
-    sessionID: string,
-    output: ToolExecuteOutput
-  ): Promise<void> {
-    const resolved = resolveFilePath(filePath);
-    if (!resolved) return;
-
-    const projectRoot = findProjectRoot(resolved);
-    const cache = getSessionCache(sessionID);
-    const home = homedir();
-
-    const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved);
-    const toInject: RuleToInject[] = [];
-
-    for (const candidate of ruleFileCandidates) {
-      if (isDuplicateByRealPath(candidate.realPath, cache.realPaths)) continue;
-
-      try {
-        const rawContent = readFileSync(candidate.path, "utf-8");
-        const { metadata, body } = parseRuleFrontmatter(rawContent);
-
-        let matchReason: string;
-        if (candidate.isSingleFile) {
-          matchReason = "copilot-instructions (always apply)";
-        } else {
-          const matchResult = shouldApplyRule(metadata, resolved, projectRoot);
-          if (!matchResult.applies) continue;
-          matchReason = matchResult.reason ?? "matched";
-        }
-
-        const contentHash = createContentHash(body);
-        if (isDuplicateByContentHash(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);
-      } 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}`;
-    }
-
-    saveInjectedRules(sessionID, cache);
-  }
-
-  function extractFilePathFromToolCall(call: BatchToolCall): string | null {
-    const params = call.parameters;
-    return (params?.filePath ?? params?.file_path ?? params?.path) as string | null;
-  }
-
-  const toolExecuteBefore = async (
-    input: ToolExecuteInput,
-    output: ToolExecuteBeforeOutput
-  ) => {
-    if (input.tool.toLowerCase() !== "batch") return;
-
-    const args = output.args as { tool_calls?: BatchToolCall[] } | undefined;
-    if (!args?.tool_calls) return;
-
-    const filePaths: string[] = [];
-    for (const call of args.tool_calls) {
-      if (TRACKED_TOOLS.includes(call.tool.toLowerCase())) {
-        const filePath = extractFilePathFromToolCall(call);
-        if (filePath) {
-          filePaths.push(filePath);
-        }
-      }
-    }
-
-    if (filePaths.length > 0) {
-      pendingBatchFiles.set(input.callID, filePaths);
-    }
-  };
-
-  const toolExecuteAfter = async (
-    input: ToolExecuteInput,
-    output: ToolExecuteOutput
-  ) => {
-    const toolName = input.tool.toLowerCase();
-
-    if (TRACKED_TOOLS.includes(toolName)) {
-      await processFilePathForInjection(output.title, input.sessionID, output);
-      return;
-    }
-
-    if (toolName === "batch") {
-      const filePaths = pendingBatchFiles.get(input.callID);
-      if (filePaths) {
-        for (const filePath of filePaths) {
-          await processFilePathForInjection(filePath, input.sessionID, output);
-        }
-        pendingBatchFiles.delete(input.callID);
-      }
-    }
-  };
-
-  const eventHandler = async ({ event }: EventInput) => {
-    const props = event.properties as Record<string, unknown> | undefined;
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined;
-      if (sessionInfo?.id) {
-        sessionCaches.delete(sessionInfo.id);
-        clearInjectedRules(sessionInfo.id);
-      }
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = (props?.sessionID ??
-        (props?.info as { id?: string } | undefined)?.id) as string | undefined;
-      if (sessionID) {
-        sessionCaches.delete(sessionID);
-        clearInjectedRules(sessionID);
-      }
-    }
-  };
-
-  return {
-    "tool.execute.before": toolExecuteBefore,
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  };
-}

package/oh-my-opencode/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/oh-my-opencode/src/hooks/rules-injector/parser.test.ts

@@ -1,226 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseRuleFrontmatter } from "./parser";
-
-describe("parseRuleFrontmatter", () => {
-  describe("applyTo field (GitHub Copilot format)", () => {
-    it("should parse applyTo as single string", () => {
-      // #given frontmatter with applyTo as single string
-      const content = `---
-applyTo: "*.ts"
----
-Rule content here`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then globs should contain the pattern
-      expect(result.metadata.globs).toBe("*.ts");
-      expect(result.body).toBe("Rule content here");
-    });
-
-    it("should parse applyTo as inline array", () => {
-      // #given frontmatter with applyTo as inline array
-      const content = `---
-applyTo: ["*.ts", "*.tsx"]
----
-Rule content`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then globs should be array
-      expect(result.metadata.globs).toEqual(["*.ts", "*.tsx"]);
-    });
-
-    it("should parse applyTo as multi-line array", () => {
-      // #given frontmatter with applyTo as multi-line array
-      const content = `---
-applyTo:
-  - "*.ts"
-  - "src/**/*.js"
----
-Content`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then globs should be array
-      expect(result.metadata.globs).toEqual(["*.ts", "src/**/*.js"]);
-    });
-
-    it("should parse applyTo as comma-separated string", () => {
-      // #given frontmatter with comma-separated applyTo
-      const content = `---
-applyTo: "*.ts, *.js"
----
-Content`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then globs should be array
-      expect(result.metadata.globs).toEqual(["*.ts", "*.js"]);
-    });
-
-    it("should merge applyTo and globs when both present", () => {
-      // #given frontmatter with both applyTo and globs
-      const content = `---
-globs: "*.md"
-applyTo: "*.ts"
----
-Content`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should merge both into globs array
-      expect(result.metadata.globs).toEqual(["*.md", "*.ts"]);
-    });
-
-    it("should parse applyTo without quotes", () => {
-      // #given frontmatter with unquoted applyTo
-      const content = `---
-applyTo: **/*.py
----
-Python rules`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should parse correctly
-      expect(result.metadata.globs).toBe("**/*.py");
-    });
-
-    it("should parse applyTo with description", () => {
-      // #given frontmatter with applyTo and description (GitHub Copilot style)
-      const content = `---
-applyTo: "**/*.ts,**/*.tsx"
-description: "TypeScript coding standards"
----
-# TypeScript Guidelines`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should parse both fields
-      expect(result.metadata.globs).toEqual(["**/*.ts", "**/*.tsx"]);
-      expect(result.metadata.description).toBe("TypeScript coding standards");
-    });
-  });
-
-  describe("existing globs/paths parsing (backward compatibility)", () => {
-    it("should still parse globs field correctly", () => {
-      // #given existing globs format
-      const content = `---
-globs: ["*.py", "**/*.ts"]
----
-Python/TypeScript rules`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should work as before
-      expect(result.metadata.globs).toEqual(["*.py", "**/*.ts"]);
-    });
-
-    it("should still parse paths field as alias", () => {
-      // #given paths field (Claude Code style)
-      const content = `---
-paths: ["src/**"]
----
-Source rules`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should map to globs
-      expect(result.metadata.globs).toEqual(["src/**"]);
-    });
-
-    it("should parse alwaysApply correctly", () => {
-      // #given frontmatter with alwaysApply
-      const content = `---
-alwaysApply: true
----
-Always apply this rule`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should recognize alwaysApply
-      expect(result.metadata.alwaysApply).toBe(true);
-    });
-  });
-
-  describe("no frontmatter", () => {
-    it("should return empty metadata and full body for plain markdown", () => {
-      // #given markdown without frontmatter
-      const content = `# Instructions
-This is a plain rule file without frontmatter.`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should have empty metadata
-      expect(result.metadata).toEqual({});
-      expect(result.body).toBe(content);
-    });
-
-    it("should handle empty content", () => {
-      // #given empty content
-      const content = "";
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should return empty metadata and body
-      expect(result.metadata).toEqual({});
-      expect(result.body).toBe("");
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle frontmatter with only applyTo", () => {
-      // #given minimal GitHub Copilot format
-      const content = `---
-applyTo: "**"
----
-Apply to all files`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should parse correctly
-      expect(result.metadata.globs).toBe("**");
-      expect(result.body).toBe("Apply to all files");
-    });
-
-    it("should handle mixed array formats", () => {
-      // #given globs as multi-line and applyTo as inline
-      const content = `---
-globs:
-  - "*.md"
-applyTo: ["*.ts", "*.js"]
----
-Mixed format`;
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should merge both
-      expect(result.metadata.globs).toEqual(["*.md", "*.ts", "*.js"]);
-    });
-
-    it("should handle Windows-style line endings", () => {
-      // #given content with CRLF
-      const content = "---\r\napplyTo: \"*.ts\"\r\n---\r\nWindows content";
-
-      // #when parsing
-      const result = parseRuleFrontmatter(content);
-
-      // #then should parse correctly
-      expect(result.metadata.globs).toBe("*.ts");
-      expect(result.body).toBe("Windows content");
-    });
-  });
-});