opencode-snippets 1.1.2 → 1.3.0

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");
+    });
+  });
+});

package/src/logger.ts

@@ -1,121 +1,121 @@
-import { writeFileSync, mkdirSync, existsSync } from "fs"
-import { join } from "path"
-import { OPENCODE_CONFIG_DIR } from "./constants.js"
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { PATHS } from "./constants.js";
 
 /**
  * Check if debug logging is enabled via environment variable
  */
 function isDebugEnabled(): boolean {
-    const value = process.env.DEBUG_SNIPPETS
-    return value === "1" || value === "true"
+  const value = process.env.DEBUG_SNIPPETS;
+  return value === "1" || value === "true";
 }
 
 export class Logger {
-    private logDir: string
+  private logDir: string;
 
-    constructor() {
-        this.logDir = join(OPENCODE_CONFIG_DIR, "logs", "snippets")
-    }
+  constructor(logDirOverride?: string) {
+    this.logDir = logDirOverride ?? join(PATHS.CONFIG_DIR, "logs", "snippets");
+  }
 
-    private get enabled(): boolean {
-        return isDebugEnabled()
-    }
+  get enabled(): boolean {
+    return isDebugEnabled();
+  }
 
-    private ensureLogDir() {
-        if (!existsSync(this.logDir)) {
-            mkdirSync(this.logDir, { recursive: true })
-        }
+  private ensureLogDir() {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
     }
-
-    private formatData(data?: any): string {
-        if (!data) return ""
-
-        const parts: string[] = []
-        for (const [key, value] of Object.entries(data)) {
-            if (value === undefined || value === null) continue
-
-            // Format arrays compactly
-            if (Array.isArray(value)) {
-                if (value.length === 0) continue
-                parts.push(`${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`)
-            }
-            else if (typeof value === 'object') {
-                const str = JSON.stringify(value)
-                if (str.length < 50) {
-                    parts.push(`${key}=${str}`)
-                }
-            }
-            else {
-                parts.push(`${key}=${value}`)
-            }
+  }
+
+  private formatData(data?: Record<string, unknown>): string {
+    if (!data) return "";
+
+    const parts: string[] = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === undefined || value === null) continue;
+
+      // Format arrays compactly
+      if (Array.isArray(value)) {
+        if (value.length === 0) continue;
+        parts.push(
+          `${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`,
+        );
+      } else if (typeof value === "object") {
+        const str = JSON.stringify(value);
+        if (str.length < 50) {
+          parts.push(`${key}=${str}`);
         }
-        return parts.join(" ")
+      } else {
+        parts.push(`${key}=${value}`);
+      }
     }
-
-    private getCallerFile(): string {
-        const originalPrepareStackTrace = Error.prepareStackTrace
-        try {
-            const err = new Error()
-            Error.prepareStackTrace = (_, stack) => stack
-            const stack = err.stack as unknown as NodeJS.CallSite[]
-            Error.prepareStackTrace = originalPrepareStackTrace
-
-            for (let i = 3; i < stack.length; i++) {
-                const filename = stack[i]?.getFileName()
-                if (filename && !filename.includes('logger.')) {
-                    const match = filename.match(/([^/\\]+)\.[tj]s$/)
-                    return match ? match[1] : 'unknown'
-                }
-            }
-            return 'unknown'
-        } catch {
-            return 'unknown'
+    return parts.join(" ");
+  }
+
+  private getCallerFile(): string {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      const err = new Error();
+      Error.prepareStackTrace = (_, stack) => stack;
+      const stack = err.stack as unknown as NodeJS.CallSite[];
+      Error.prepareStackTrace = originalPrepareStackTrace;
+
+      for (let i = 3; i < stack.length; i++) {
+        const filename = stack[i]?.getFileName();
+        if (filename && !filename.includes("logger.")) {
+          const match = filename.match(/([^/\\]+)\.[tj]s$/);
+          return match ? match[1] : "unknown";
         }
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
     }
+  }
 
-    private write(level: string, component: string, message: string, data?: any) {
-        if (!this.enabled) return
-
-        try {
-            this.ensureLogDir()
-
-            const timestamp = new Date().toISOString()
-            const dataStr = this.formatData(data)
+  private write(level: string, component: string, message: string, data?: Record<string, unknown>) {
+    if (!this.enabled) return;
 
-            const dailyLogDir = join(this.logDir, "daily")
-            if (!existsSync(dailyLogDir)) {
-                mkdirSync(dailyLogDir, { recursive: true })
-            }
+    try {
+      this.ensureLogDir();
 
-            const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""}\n`
+      const timestamp = new Date().toISOString();
+      const dataStr = this.formatData(data);
 
-            const logFile = join(dailyLogDir, `${new Date().toISOString().split('T')[0]}.log`)
-            writeFileSync(logFile, logLine, { flag: "a" })
-        } catch (error) {
-            // Silent fail
-        }
-    }
-
-    info(message: string, data?: any) {
-        const component = this.getCallerFile()
-        this.write("INFO", component, message, data)
-    }
+      const dailyLogDir = join(this.logDir, "daily");
+      if (!existsSync(dailyLogDir)) {
+        mkdirSync(dailyLogDir, { recursive: true });
+      }
 
-    debug(message: string, data?: any) {
-        const component = this.getCallerFile()
-        this.write("DEBUG", component, message, data)
-    }
-
-    warn(message: string, data?: any) {
-        const component = this.getCallerFile()
-        this.write("WARN", component, message, data)
-    }
+      const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? ` | ${dataStr}` : ""}\n`;
 
-    error(message: string, data?: any) {
-        const component = this.getCallerFile()
-        this.write("ERROR", component, message, data)
+      const logFile = join(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`);
+      writeFileSync(logFile, logLine, { flag: "a" });
+    } catch {
+      // Silent fail
     }
+  }
+
+  info(message: string, data?: Record<string, unknown>) {
+    const component = this.getCallerFile();
+    this.write("INFO", component, message, data);
+  }
+
+  debug(message: string, data?: Record<string, unknown>) {
+    const component = this.getCallerFile();
+    this.write("DEBUG", component, message, data);
+  }
+
+  warn(message: string, data?: Record<string, unknown>) {
+    const component = this.getCallerFile();
+    this.write("WARN", component, message, data);
+  }
+
+  error(message: string, data?: Record<string, unknown>) {
+    const component = this.getCallerFile();
+    this.write("ERROR", component, message, data);
+  }
 }
 
 // Export singleton logger instance
-export const logger = new Logger()
+export const logger = new Logger();

package/src/notification.ts

@@ -0,0 +1,29 @@
+import { logger } from "./logger.js";
+
+/**
+ * Sends a message that will be displayed but ignored by the AI
+ * Used for command output that shouldn't trigger AI responses
+ *
+ * @param client - The OpenCode client instance
+ * @param sessionId - The current session ID
+ * @param text - The text to display
+ */
+export async function sendIgnoredMessage(
+  client: any,
+  sessionId: string,
+  text: string,
+): Promise<void> {
+  try {
+    await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text, ignored: true }],
+      },
+    });
+  } catch (error) {
+    logger.error("Failed to send ignored message", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}

package/src/shell.ts

@@ -1,44 +1,50 @@
-import { PATTERNS } from "./constants.js"
-import { logger } from "./logger.js"
+import { PATTERNS } from "./constants.js";
+import { logger } from "./logger.js";
 
 /**
  * Executes shell commands in text using !`command` syntax
- * 
+ *
  * @param text - The text containing shell commands to execute
  * @param ctx - The plugin context (with Bun shell)
  * @returns The text with shell commands replaced by their output
  */
-export async function executeShellCommands(
-  text: string,
-  ctx: any
-): Promise<string> {
-  let result = text
-  
+export type ShellContext = {
+  $: (
+    template: TemplateStringsArray,
+    ...args: unknown[]
+  ) => {
+    quiet: () => { nothrow: () => { text: () => Promise<string> } };
+  };
+};
+
+export async function executeShellCommands(text: string, ctx: ShellContext): Promise<string> {
+  let result = text;
+
   // Reset regex state (global flag requires this)
-  PATTERNS.SHELL_COMMAND.lastIndex = 0
-  
+  PATTERNS.SHELL_COMMAND.lastIndex = 0;
+
   // Find all shell command matches
-  const matches = [...text.matchAll(PATTERNS.SHELL_COMMAND)]
-  
+  const matches = [...text.matchAll(PATTERNS.SHELL_COMMAND)];
+
   // Execute each command and replace in text
   for (const match of matches) {
-    const cmd = match[1]
-    const placeholder = match[0]
-    
+    const cmd = match[1];
+    const _placeholder = match[0];
+
     try {
-      const output = await ctx.$`${{ raw: cmd }}`.quiet().nothrow().text()
-      // Format like slash commands: print command first, then output
-      const replacement = `$ ${cmd}\n--> ${output.trim()}`
-      result = result.replace(placeholder, replacement)
+      const output = await ctx.$`${{ raw: cmd }}`.quiet().nothrow().text();
+      // Deviate from slash commands' substitution mechanism: print command first, then output
+      const replacement = `$ ${cmd}\n--> ${output.trim()}`;
+      result = result.replace(_placeholder, replacement);
     } catch (error) {
       // If shell command fails, leave it as-is
       // This preserves the original syntax for debugging
       logger.warn("Shell command execution failed", {
         command: cmd,
-        error: error instanceof Error ? error.message : String(error)
-      })
+        error: error instanceof Error ? error.message : String(error),
+      });
     }
   }
-  
-  return result
+
+  return result;
 }

package/src/types.ts

@@ -3,24 +3,36 @@
  */
 export interface Snippet {
   /** The primary name/key of the snippet */
-  name: string
+  name: string;
   /** The content of the snippet (without frontmatter) */
-  content: string
+  content: string;
   /** Alternative names that also trigger this snippet */
-  aliases: string[]
+  aliases: string[];
 }
 
 /**
- * Snippet registry that maps keys to content
+ * Extended snippet info with file metadata
  */
-export type SnippetRegistry = Map<string, string>
+export interface SnippetInfo {
+  name: string;
+  content: string;
+  aliases: string[];
+  description?: string;
+  filePath: string;
+  source: "global" | "project";
+}
+
+/**
+ * Snippet registry that maps keys to snippet info
+ */
+export type SnippetRegistry = Map<string, SnippetInfo>;
 
 /**
  * Frontmatter data from snippet files
  */
 export interface SnippetFrontmatter {
   /** Alternative hashtags for this snippet */
-  aliases?: string[]
+  aliases?: string[];
   /** Optional description of what this snippet does */
-  description?: string
+  description?: string;
 }