@koriit/opencode-claude-bridge 0.1.3 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koriit/opencode-claude-bridge",
-  "version": "0.1.3",
+  "version": "0.1.7",
   "description": "An OpenCode plugin that bridges enabled Claude Code plugins (commands, agents, skills, MCP, LSP) into OpenCode at runtime, namespaced so they never shadow your existing items.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -5,7 +5,7 @@ import { injectCommandsAndAgents } from "./inject.js"
 import { injectSkills } from "./skill-inject.js"
 import { injectMcp } from "./mcp-inject.js"
 import { injectLsp } from "./lsp-inject.js"
-import { createLogger } from "./logger.js"
+import { createLogger, type LoggingClient } from "./logger.js"
 import { listClaudePlugins, selectEnabledPlugins } from "./selection.js"
 import { collectExistingSkillNames } from "./skill-scan.js"
 
@@ -51,7 +51,7 @@ export const server: Plugin = async (_input, options) => {
 
   return {
     config: async (cfg) => {
-      const logger = createLogger(bridge.strict)
+      const logger = createLogger(bridge.strict, _input.client as unknown as LoggingClient)
       try {
         // Replay parse-time validation warnings (strict-promotable).
         for (const w of warnings) logger.warn(w)

package/src/logger.ts

@@ -1,17 +1,18 @@
+/** Minimal duck-type for the OpenCode client — only the log() method we use. */
+export interface LoggingClient {
+  log(params: { service?: string; level?: "debug" | "info" | "warn" | "error"; message?: string }): unknown
+}
+
 /** Thrown when a soft warning is promoted to a hard error under `strict` mode. */
 export class BridgeError extends Error {
   override name = "BridgeError"
 }
 
-/** Prefix every line the bridge emits so its output is greppable in OpenCode's logs. */
-export const LOG_PREFIX = "[opencode-claude-bridge]"
-
 export interface WarnOptions {
   /**
    * Whether this warning should be promoted to a hard error under `strict`.
    * Defaults to `true` (parse failures, missing CLI). Set `false` for advisory
-   * warnings that must never abort the hook even in strict mode (e.g. the §9
-   * version-range notice, which always still attempts injection).
+   * warnings that must never abort the hook even in strict mode.
    */
   fatalInStrict?: boolean
 }
@@ -28,26 +29,72 @@ export interface Logger {
   hadWarnings(): boolean
 }
 
+
 /**
- * Create a logger bound to the resolved `strict` flag. The hook itself is responsible
- * for catching {@link BridgeError} in non-strict paths; in strict mode it lets the
- * error propagate so OpenCode surfaces a hard failure (design §10).
+ * Fallback output logger used when no real OpenCode client is available (tests,
+ * edge-case early errors). Writes to process.stderr in OpenCode's structured
+ * format and only when --print-logs is in argv — matching OpenCode's own
+ * log-visibility behaviour.
  */
-export function createLogger(strict: boolean): Logger {
+const fallbackLog = (() => {
+  const enabled = process.argv.includes("--print-logs")
+  let last = Date.now()
+
+  function write(level: "INFO" | "WARN", msg: string): void {
+    if (!enabled) return
+    const now = Date.now()
+    const ts = new Date(now).toISOString().split(".")[0]
+    const diff = now - last
+    last = now
+    process.stderr.write(`${level.padEnd(5)} ${ts} +${diff}ms service=opencode-claude-bridge ${msg}\n`)
+  }
+
+  return {
+    info: (msg: string) => write("INFO", msg),
+    warn: (msg: string) => write("WARN", msg),
+  }
+})()
+
+/**
+ * Create a logger bound to the resolved `strict` flag and the OpenCode client.
+ *
+ * When a client is provided, log entries are posted to the server via
+ * `client.log()` — they flow through OpenCode's own log pipeline, appear in
+ * the log file, and respect `--print-logs` automatically.
+ *
+ * When no client is provided (tests, early-startup errors) the fallback logger
+ * writes to process.stderr in the same format, gated on `--print-logs`.
+ */
+export function createLogger(strict: boolean, client?: LoggingClient): Logger {
   let warningCount = 0
+
+  function logInfo(msg: string): void {
+    if (typeof client?.log === "function") {
+      void client.log({ service: "opencode-claude-bridge", level: "info", message: msg })
+    } else {
+      fallbackLog.info(msg)
+    }
+  }
+
+  function logWarn(msg: string): void {
+    if (typeof client?.log === "function") {
+      void client.log({ service: "opencode-claude-bridge", level: "warn", message: msg })
+    } else {
+      fallbackLog.warn(msg)
+    }
+  }
+
   return {
-    info(msg: string): void {
-      console.log(`${LOG_PREFIX} ${msg}`)
+    info(msg) {
+      logInfo(msg)
     },
-    warn(msg: string, opts?: WarnOptions): void {
+    warn(msg, opts) {
       const fatalInStrict = opts?.fatalInStrict ?? true
       warningCount++
-      if (strict && fatalInStrict) {
-        throw new BridgeError(msg)
-      }
-      console.warn(`${LOG_PREFIX} warning: ${msg}`)
+      if (strict && fatalInStrict) throw new BridgeError(msg)
+      logWarn(msg)
     },
-    hadWarnings(): boolean {
+    hadWarnings() {
       return warningCount > 0
     },
   }

package/src/skill-inject.ts

@@ -353,12 +353,14 @@ async function injectPluginSkills(
       continue
     }
 
-    const bareName = extractSkillName(content)
-    if (bareName === null) {
-      logger.warn(
-        `SKILL.md at "${skillMdPath}" from plugin "${plugin.id}" has no frontmatter name; skipping`,
+    const extractedName = extractSkillName(content)
+    // Fall back to the directory name when the SKILL.md has no `name:` field —
+    // the directory name is the conventional skill identifier and is always present.
+    const bareName = extractedName ?? subdir
+    if (extractedName === null) {
+      logger.info(
+        `SKILL.md at "${skillMdPath}" from plugin "${plugin.id}" has no frontmatter name; using directory name "${subdir}"`,
       )
-      continue
     }
 
     const { name: allocatedName, renamed } = allocator.claim(plugin.id, bareName)