opencode-snippets 1.1.2 → 1.2.0

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 { OPENCODE_CONFIG_DIR } 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(OPENCODE_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/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,24 @@
  */
 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
  */
-export type SnippetRegistry = Map<string, string>
+export type SnippetRegistry = Map<string, string>;
 
 /**
  * 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;
 }