opencode-snippets 1.1.2 → 1.3.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")?.content).toBe("Think step by step. Double-check your work.");
+      expect(snippets.get("safe")?.content).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")?.content).toBe("Content of snippet 1");
+      expect(snippets.get("snippet2")?.content).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")?.content).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")?.content).toBe("Team rule 1");
+      expect(snippets.get("domain-knowledge")?.content).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")?.content).toBe("Global snippet content");
+      expect(snippets.get("project")?.content).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")?.content).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")?.content).toBe("Global review guidelines");
+      expect(snippets.get("pr")?.content).toBe("Global review guidelines");
+      expect(snippets.get("check")?.content).toBe("Global review guidelines");
+      expect(snippets.get("test")?.content).toBe("Project test guidelines");
+      expect(snippets.get("tdd")?.content).toBe("Project test guidelines");
+      expect(snippets.get("testing")?.content).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")?.content).toBe("Project careful");
+      expect(snippets.get("safe")?.content).toBe("Project careful");
+      expect(snippets.get("cautious")?.content).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")?.content).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")?.content).toBe("");
+      expect(snippets.get("meta")?.content).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")?.content).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")?.content).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")?.content).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,88 +1,266 @@
-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 { mkdir, readdir, readFile, unlink, writeFile } 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, SnippetInfo, SnippetRegistry } from "./types.js";
 
 /**
- * Loads all snippets from the snippets directory
- * 
- * @returns A map of snippet keys (lowercase) to their content
+ * 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 SnippetInfo
  */
-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: "global" | "project",
+): 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, source);
       if (snippet) {
-        registerSnippet(snippets, snippet.name, snippet.content, snippet.aliases)
+        registerSnippet(registry, snippet);
       }
     }
+
+    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
+ * @param source - Whether this is a global or project snippet
+ * @returns The parsed snippet info, or null if parsing failed
  */
-async function loadSnippetFile(filename: string) {
+async function loadSnippetFile(
+  dir: string,
+  filename: string,
+  source: "global" | "project",
+): Promise<SnippetInfo | null> {
   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,
+      description: frontmatter.description,
+      filePath,
+      source,
+    };
   } 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 registry - The registry to add the snippet to
+ * @param snippet - The snippet info to register
+ */
+function registerSnippet(registry: SnippetRegistry, snippet: SnippetInfo): void {
+  const key = snippet.name.toLowerCase();
+
+  // If snippet with same name exists, remove its old aliases first
+  const existing = registry.get(key);
+  if (existing) {
+    for (const alias of existing.aliases) {
+      registry.delete(alias.toLowerCase());
+    }
+  }
+
+  // Register the snippet under its name
+  registry.set(key, snippet);
+
+  // Register under all aliases (pointing to the same snippet info)
+  for (const alias of snippet.aliases) {
+    registry.set(alias.toLowerCase(), snippet);
+  }
+}
+
+/**
+ * Lists all unique snippets (by name) from the registry
+ *
+ * @param registry - The snippet registry
+ * @returns Array of unique snippet info objects
+ */
+export function listSnippets(registry: SnippetRegistry): SnippetInfo[] {
+  const seen = new Set<string>();
+  const snippets: SnippetInfo[] = [];
+
+  for (const snippet of registry.values()) {
+    if (!seen.has(snippet.name)) {
+      seen.add(snippet.name);
+      snippets.push(snippet);
+    }
+  }
+
+  return snippets;
+}
+
+/**
+ * Ensures the snippets directory exists
+ */
+export async function ensureSnippetsDir(projectDir?: string): Promise<string> {
+  const dir = projectDir ? join(projectDir, ".opencode", "snippet") : PATHS.SNIPPETS_DIR;
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Creates a new snippet file
+ *
+ * @param name - The snippet name (without extension)
  * @param content - The snippet content
- * @param aliases - Alternative names for the snippet
+ * @param options - Optional metadata (aliases, description)
+ * @param projectDir - If provided, creates in project directory; otherwise global
+ * @returns The path to the created snippet file
  */
-function registerSnippet(
-  registry: SnippetRegistry,
+export async function createSnippet(
   name: string,
   content: string,
-  aliases: string[]
-) {
-  // Register with primary name (lowercase)
-  registry.set(name.toLowerCase(), content)
-  
-  // Register all aliases (lowercase)
-  for (const alias of aliases) {
-    registry.set(alias.toLowerCase(), content)
+  options: { aliases?: string[]; description?: string } = {},
+  projectDir?: string,
+): Promise<string> {
+  const dir = await ensureSnippetsDir(projectDir);
+  const filePath = join(dir, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+
+  // Build frontmatter if we have metadata
+  const frontmatter: SnippetFrontmatter = {};
+  if (options.aliases?.length) {
+    frontmatter.aliases = options.aliases;
+  }
+  if (options.description) {
+    frontmatter.description = options.description;
+  }
+
+  // Create file content with frontmatter if needed
+  let fileContent: string;
+  if (Object.keys(frontmatter).length > 0) {
+    fileContent = matter.stringify(content, frontmatter);
+  } else {
+    fileContent = content;
+  }
+
+  await writeFile(filePath, fileContent, "utf-8");
+  logger.info("Created snippet", { name, path: filePath });
+
+  return filePath;
+}
+
+/**
+ * Deletes a snippet file
+ *
+ * @param name - The snippet name (without extension)
+ * @param projectDir - If provided, looks in project directory first; otherwise global
+ * @returns The path of the deleted file, or null if not found
+ */
+export async function deleteSnippet(name: string, projectDir?: string): Promise<string | null> {
+  // Try project directory first if provided
+  if (projectDir) {
+    const projectPath = join(
+      projectDir,
+      ".opencode",
+      "snippet",
+      `${name}${CONFIG.SNIPPET_EXTENSION}`,
+    );
+    try {
+      await unlink(projectPath);
+      logger.info("Deleted project snippet", { name, path: projectPath });
+      return projectPath;
+    } catch {
+      // Not found in project, try global
+    }
+  }
+
+  // Try global directory
+  const globalPath = join(PATHS.SNIPPETS_DIR, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+  try {
+    await unlink(globalPath);
+    logger.info("Deleted global snippet", { name, path: globalPath });
+    return globalPath;
+  } catch {
+    logger.warn("Snippet not found for deletion", { name });
+    return null;
+  }
+}
+
+/**
+ * Reloads snippets into the registry from disk
+ */
+export async function reloadSnippets(
+  registry: SnippetRegistry,
+  projectDir?: string,
+): Promise<void> {
+  registry.clear();
+  const fresh = await loadSnippets(projectDir);
+  for (const [key, value] of fresh) {
+    registry.set(key, value);
   }
 }