opencode-snippets 1.1.2 → 1.2.0

package/src/loader.test.ts

@@ -0,0 +1,261 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { loadSnippets } from "../src/loader.js";
+
+describe("loadSnippets - Dual Path Support", () => {
+  let tempDir: string;
+  let globalSnippetDir: string;
+  let projectSnippetDir: string;
+
+  beforeEach(async () => {
+    // Create temporary directories for testing
+    tempDir = join(process.cwd(), ".test-temp");
+    globalSnippetDir = join(tempDir, "global-snippet");
+    projectSnippetDir = join(tempDir, "project", ".opencode", "snippet");
+
+    await mkdir(globalSnippetDir, { recursive: true });
+    await mkdir(projectSnippetDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directories
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("Global snippets only", () => {
+    it("should load snippets with aliases", async () => {
+      await writeFile(
+        join(globalSnippetDir, "careful.md"),
+        `---
+aliases: safe
+---
+Think step by step. Double-check your work.`,
+      );
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+
+      expect(snippets.size).toBe(2);
+      expect(snippets.get("careful")).toBe("Think step by step. Double-check your work.");
+      expect(snippets.get("safe")).toBe("Think step by step. Double-check your work.");
+    });
+
+    it("should load multiple snippets from global directory", async () => {
+      await writeFile(join(globalSnippetDir, "snippet1.md"), "Content of snippet 1");
+      await writeFile(join(globalSnippetDir, "snippet2.md"), "Content of snippet 2");
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+
+      expect(snippets.size).toBe(2);
+      expect(snippets.get("snippet1")).toBe("Content of snippet 1");
+      expect(snippets.get("snippet2")).toBe("Content of snippet 2");
+    });
+  });
+
+  describe("Project snippets only", () => {
+    it("should load snippets from project directory", async () => {
+      await writeFile(
+        join(projectSnippetDir, "project-specific.md"),
+        "This is a project-specific snippet",
+      );
+
+      // Load with project directory
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      expect(snippets.size).toBe(1);
+      expect(snippets.get("project-specific")).toBe("This is a project-specific snippet");
+    });
+
+    it("should handle missing global directory when project exists", async () => {
+      await writeFile(join(projectSnippetDir, "team-rule.md"), "Team rule 1");
+      await writeFile(join(projectSnippetDir, "domain-knowledge.md"), "Domain knowledge");
+
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      expect(snippets.size).toBe(2);
+      expect(snippets.get("team-rule")).toBe("Team rule 1");
+      expect(snippets.get("domain-knowledge")).toBe("Domain knowledge");
+    });
+  });
+
+  describe("Both global and project snippets", () => {
+    it("should merge global and project snippets", async () => {
+      // Create global snippet
+      await writeFile(join(globalSnippetDir, "global.md"), "Global snippet content");
+
+      // Create project snippet
+      await writeFile(join(projectSnippetDir, "project.md"), "Project snippet content");
+
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      expect(snippets.size).toBe(2);
+      expect(snippets.get("global")).toBe("Global snippet content");
+      expect(snippets.get("project")).toBe("Project snippet content");
+    });
+
+    it("should allow project snippets to override global snippets", async () => {
+      // Create global snippet
+      await writeFile(join(globalSnippetDir, "careful.md"), "Global careful content");
+
+      // Create project snippet with same name
+      await writeFile(join(projectSnippetDir, "careful.md"), "Project-specific careful content");
+
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      // Project snippet should override global
+      expect(snippets.get("careful")).toBe("Project-specific careful content");
+      expect(snippets.size).toBe(1);
+    });
+  });
+
+  describe("Alias handling", () => {
+    it("should handle multiple aliases from different sources", async () => {
+      // Global snippet with aliases
+      await writeFile(
+        join(globalSnippetDir, "review.md"),
+        `---
+aliases:
+  - pr
+  - check
+---
+Global review guidelines`,
+      );
+
+      // Project snippet with aliases
+      await writeFile(
+        join(projectSnippetDir, "test.md"),
+        `---
+aliases:
+  - tdd
+  - testing
+---
+Project test guidelines`,
+      );
+
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      expect(snippets.size).toBe(6); // review, pr, check, test, tdd, testing
+      expect(snippets.get("review")).toBe("Global review guidelines");
+      expect(snippets.get("pr")).toBe("Global review guidelines");
+      expect(snippets.get("check")).toBe("Global review guidelines");
+      expect(snippets.get("test")).toBe("Project test guidelines");
+      expect(snippets.get("tdd")).toBe("Project test guidelines");
+      expect(snippets.get("testing")).toBe("Project test guidelines");
+    });
+
+    it("should allow project to override global aliases", async () => {
+      // Global snippet with aliases
+      await writeFile(
+        join(globalSnippetDir, "careful.md"),
+        `---
+aliases:
+  - safe
+  - cautious
+---
+Global careful`,
+      );
+
+      // Project snippet with same name but different aliases
+      await writeFile(
+        join(projectSnippetDir, "careful.md"),
+        `---
+aliases: safe
+---
+Project careful`,
+      );
+
+      const projectDir = join(tempDir, "project");
+      const snippets = await loadSnippets(projectDir, globalSnippetDir);
+
+      // Project should override with its aliases
+      expect(snippets.get("careful")).toBe("Project careful");
+      expect(snippets.get("safe")).toBe("Project careful");
+      expect(snippets.get("cautious")).toBeUndefined();
+      expect(snippets.size).toBe(2);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty snippet content", async () => {
+      await writeFile(join(globalSnippetDir, "empty.md"), "");
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+      expect(snippets.size).toBe(1);
+      expect(snippets.get("empty")).toBe("");
+    });
+
+    it("should handle snippet with only metadata", async () => {
+      await writeFile(
+        join(globalSnippetDir, "metadata-only.md"),
+        `---
+description: "A snippet with only metadata"
+aliases: meta
+---`,
+      );
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+      expect(snippets.size).toBe(2);
+      expect(snippets.get("metadata-only")).toBe("");
+      expect(snippets.get("meta")).toBe("");
+    });
+
+    it("should handle multiline content", async () => {
+      await writeFile(
+        join(globalSnippetDir, "multiline.md"),
+        `Line 1
+Line 2
+Line 3`,
+      );
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+      expect(snippets.get("multiline")).toBe("Line 1\nLine 2\nLine 3");
+    });
+
+    it("should ignore non-.md files", async () => {
+      await writeFile(join(globalSnippetDir, "not-a-snippet.txt"), "This should be ignored");
+      await writeFile(join(globalSnippetDir, "valid.md"), "This should be loaded");
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+      expect(snippets.size).toBe(1);
+      expect(snippets.get("valid")).toBe("This should be loaded");
+      expect(snippets.has("not-a-snippet")).toBe(false);
+    });
+
+    it("should handle invalid frontmatter", async () => {
+      await writeFile(
+        join(globalSnippetDir, "bad-frontmatter.md"),
+        `---
+invalid yaml
+---
+Content`,
+      );
+
+      await writeFile(join(globalSnippetDir, "special-chars.md"), "Special content");
+
+      const snippets = await loadSnippets(undefined, globalSnippetDir);
+      // Should load valid snippet, skip invalid one
+      expect(snippets.get("special-chars")).toBe("Special content");
+    });
+
+    it("should handle non-existent directories gracefully", async () => {
+      const snippets = await loadSnippets(undefined, "/nonexistent/path");
+      expect(snippets.size).toBe(0);
+    });
+  });
+
+  describe("Smoke test - real global snippets", () => {
+    it("should load real global snippets without crashing", async () => {
+      // This is a smoke test - just verify it doesn't crash
+      const snippets = await loadSnippets();
+
+      // We don't assert specific content since we don't control user's global snippets
+      // Just verify it returns a Map
+      expect(snippets).toBeInstanceOf(Map);
+      expect(Array.isArray(Array.from(snippets.keys()))).toBe(true);
+    });
+  });
+});

package/src/loader.ts

@@ -1,72 +1,114 @@
-import { readdir, readFile } from "node:fs/promises"
-import { join, basename } from "node:path"
-import matter from "gray-matter"
-import type { SnippetRegistry, SnippetFrontmatter } from "./types.js"
-import { PATHS, CONFIG } from "./constants.js"
-import { logger } from "./logger.js"
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import matter from "gray-matter";
+import { CONFIG, PATHS } from "./constants.js";
+import { logger } from "./logger.js";
+import type { SnippetFrontmatter, SnippetRegistry } from "./types.js";
 
 /**
- * Loads all snippets from the snippets directory
- * 
+ * Loads all snippets from global and project directories
+ *
+ * @param projectDir - Optional project directory path (from ctx.directory)
+ * @param globalDir - Optional global snippets directory (for testing)
  * @returns A map of snippet keys (lowercase) to their content
  */
-export async function loadSnippets(): Promise<SnippetRegistry> {
-  const snippets: SnippetRegistry = new Map()
-  
+export async function loadSnippets(
+  projectDir?: string,
+  globalDir?: string,
+): Promise<SnippetRegistry> {
+  const snippets: SnippetRegistry = new Map();
+
+  // Load from global directory first (use provided or default)
+  const globalSnippetsDir = globalDir ?? PATHS.SNIPPETS_DIR;
+  await loadFromDirectory(globalSnippetsDir, snippets, "global");
+
+  // Load from project directory if provided (overrides global)
+  if (projectDir) {
+    const projectSnippetsDir = join(projectDir, ".opencode", "snippet");
+    await loadFromDirectory(projectSnippetsDir, snippets, "project");
+  }
+
+  return snippets;
+}
+
+/**
+ * Loads snippets from a specific directory
+ *
+ * @param dir - Directory to load snippets from
+ * @param registry - Registry to populate
+ * @param source - Source label for logging
+ */
+async function loadFromDirectory(
+  dir: string,
+  registry: SnippetRegistry,
+  source: string,
+): Promise<void> {
   try {
-    const files = await readdir(PATHS.SNIPPETS_DIR)
-    
+    const files = await readdir(dir);
+
     for (const file of files) {
-      if (!file.endsWith(CONFIG.SNIPPET_EXTENSION)) continue
-      
-      const snippet = await loadSnippetFile(file)
+      if (!file.endsWith(CONFIG.SNIPPET_EXTENSION)) continue;
+
+      const snippet = await loadSnippetFile(dir, file);
       if (snippet) {
-        registerSnippet(snippets, snippet.name, snippet.content, snippet.aliases)
+        registerSnippet(registry, snippet.name, snippet.content, snippet.aliases);
       }
     }
+
+    logger.debug(`Loaded snippets from ${source} directory`, {
+      path: dir,
+      fileCount: files.length,
+    });
   } catch (error) {
     // Snippets directory doesn't exist or can't be read - that's fine
-    logger.info("Snippets directory not found or unreadable", { 
-      path: PATHS.SNIPPETS_DIR,
-      error: error instanceof Error ? error.message : String(error)
-    })
-    // Return empty registry
+    logger.debug(`${source} snippets directory not found or unreadable`, {
+      path: dir,
+      error: error instanceof Error ? error.message : String(error),
+    });
   }
-  
-  return snippets
 }
 
 /**
  * Loads and parses a single snippet file
- * 
+ *
+ * @param dir - Directory containing the snippet file
  * @param filename - The filename to load (e.g., "my-snippet.md")
  * @returns The parsed snippet data, or null if parsing failed
  */
-async function loadSnippetFile(filename: string) {
+async function loadSnippetFile(dir: string, filename: string) {
   try {
-    const name = basename(filename, CONFIG.SNIPPET_EXTENSION)
-    const filePath = join(PATHS.SNIPPETS_DIR, filename)
-    const fileContent = await readFile(filePath, "utf-8")
-    const parsed = matter(fileContent)
-    
-    const content = parsed.content.trim()
-    const frontmatter = parsed.data as SnippetFrontmatter
-    const aliases = Array.isArray(frontmatter.aliases) ? frontmatter.aliases : []
-    
-    return { name, content, aliases }
+    const name = basename(filename, CONFIG.SNIPPET_EXTENSION);
+    const filePath = join(dir, filename);
+    const fileContent = await readFile(filePath, "utf-8");
+    const parsed = matter(fileContent);
+
+    const content = parsed.content.trim();
+    const frontmatter = parsed.data as SnippetFrontmatter;
+
+    // Handle aliases as string or array
+    let aliases: string[] = [];
+    if (frontmatter.aliases) {
+      if (Array.isArray(frontmatter.aliases)) {
+        aliases = frontmatter.aliases;
+      } else {
+        aliases = [frontmatter.aliases];
+      }
+    }
+
+    return { name, content, aliases };
   } catch (error) {
     // Failed to read or parse this snippet - skip it
-    logger.warn("Failed to load snippet file", { 
+    logger.warn("Failed to load snippet file", {
       filename,
-      error: error instanceof Error ? error.message : String(error)
-    })
-    return null
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return null;
   }
 }
 
 /**
  * Registers a snippet and its aliases in the registry
- * 
+ *
  * @param registry - The snippet registry to update
  * @param name - The primary name of the snippet
  * @param content - The snippet content
@@ -76,13 +118,25 @@ function registerSnippet(
   registry: SnippetRegistry,
   name: string,
   content: string,
-  aliases: string[]
+  aliases: string[],
 ) {
+  const key = name.toLowerCase();
+
+  // If snippet already exists, remove all entries with the old content
+  const oldContent = registry.get(key);
+  if (oldContent !== undefined) {
+    for (const [k, v] of registry.entries()) {
+      if (v === oldContent) {
+        registry.delete(k);
+      }
+    }
+  }
+
   // Register with primary name (lowercase)
-  registry.set(name.toLowerCase(), content)
-  
+  registry.set(key, content);
+
   // Register all aliases (lowercase)
   for (const alias of aliases) {
-    registry.set(alias.toLowerCase(), content)
+    registry.set(alias.toLowerCase(), content);
   }
 }

package/src/logger.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+describe("Logger", () => {
+  let tempDir: string;
+  let originalEnv: NodeJS.ProcessEnv;
+  let Logger: typeof import("../src/logger.js").Logger;
+
+  beforeAll(() => {
+    originalEnv = { ...process.env };
+  });
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "snippets-logger-test-"));
+    Logger = require("../src/logger.js").Logger;
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+    process.env = originalEnv;
+  });
+
+  describe("isDebugEnabled", () => {
+    it("should return false when DEBUG_SNIPPETS is not set", () => {
+      delete process.env.DEBUG_SNIPPETS;
+      const testLogger = new Logger(join(tempDir, "logs"));
+      expect(testLogger.enabled).toBe(false);
+    });
+
+    it("should return true when DEBUG_SNIPPETS=1", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const testLogger = new Logger(join(tempDir, "logs"));
+      expect(testLogger.enabled).toBe(true);
+    });
+
+    it("should return true when DEBUG_SNIPPETS=true", () => {
+      process.env.DEBUG_SNIPPETS = "true";
+      const testLogger = new Logger(join(tempDir, "logs"));
+      expect(testLogger.enabled).toBe(true);
+    });
+
+    it("should return false for other values", () => {
+      process.env.DEBUG_SNIPPETS = "yes";
+      const testLogger = new Logger(join(tempDir, "logs"));
+      expect(testLogger.enabled).toBe(false);
+    });
+  });
+
+  describe("log writing", () => {
+    it("should not write logs when debug is disabled", () => {
+      delete process.env.DEBUG_SNIPPETS;
+      const writeSpy = vi.spyOn(require("fs"), "writeFileSync");
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("test message", { key: "value" });
+      expect(writeSpy).not.toHaveBeenCalled();
+    });
+
+    it("should write logs when debug is enabled", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("test debug message", { test: true });
+      logger.info("test info message");
+      logger.warn("test warn message");
+      logger.error("test error message");
+    });
+
+    it("should format data correctly", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("with data", {
+        string: "hello",
+        number: 42,
+        bool: true,
+        nullVal: null,
+        undefinedVal: undefined,
+      });
+    });
+
+    it("should handle empty data", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("no data");
+      logger.debug("empty object", {});
+      logger.debug("empty array", { items: [] as unknown[] });
+    });
+
+    it("should format arrays compactly", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("small array", { items: [1, 2, 3] });
+      logger.debug("large array", { items: [1, 2, 3, 4, 5, 6] });
+    });
+
+    it("should handle objects in data", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.debug("nested object", {
+        nested: { a: 1, b: 2 },
+        long: "this is a very long string that should be truncated if over 50 characters",
+      });
+    });
+  });
+
+  describe("file output", () => {
+    it("should create log file in daily directory", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.info("file output test", { test: true });
+
+      const today = new Date().toISOString().split("T")[0];
+      const logFile = join(tempDir, "logs", "daily", `${today}.log`);
+
+      expect(existsSync(logFile)).toBe(true);
+      const content = readFileSync(logFile, "utf-8");
+      expect(content).toContain("file output test");
+      expect(content).toContain("test=true");
+    });
+
+    it("should append to existing log file", () => {
+      process.env.DEBUG_SNIPPETS = "1";
+      const logger = new Logger(join(tempDir, "logs"));
+      logger.info("first message");
+      logger.info("second message");
+
+      const today = new Date().toISOString().split("T")[0];
+      const logFile = join(tempDir, "logs", "daily", `${today}.log`);
+      const content = readFileSync(logFile, "utf-8");
+
+      expect(content).toContain("first message");
+      expect(content).toContain("second message");
+    });
+  });
+});