T20 — Plugin tool dynamic discovery

export async function discoverPluginTools(configDirs: string[]) {
  const tools: Tool[] = []

  for (const dir of configDirs) {
    // Glob scan: cả "tool/" và "tools/" folder
    const files = await glob("{tool,tools}/*.{js,ts,mjs}", {
      cwd:      dir,
      absolute: true,
    })

    for (const file of files) {
      try {
        const mod     = await import(file)
        const toolDef = mod.default ?? mod.tool

        if (!toolDef) {
          log.warn(`Plugin file ${file} has no default export or .tool export — skipping`)
          continue
        }

        // Wrap với fromPlugin: auto-truncate + sandboxed permission
        tools.push(Tool.fromPlugin(toolDef, { source: file }))
      } catch (err) {
        // Silent fail per plugin — 1 bad plugin không block others
        log.warn(`Plugin tool load failed: ${file}`, err)
      }
    }
  }

  return tools
}

// Plugin tool format: default export object với name + description + execute
export default {
  name: "query_db",
  description: "Query the internal PostgreSQL database. Use SQL SELECT only.",

  parameters: {
    type: "object",
    properties: {
      sql: { type: "string", description: "SQL SELECT query" },
    },
    required: ["sql"],
  },

  async execute(args: { sql: string }) {
    // Tool author implement business logic
    const rows = await db.query(args.sql)
    return JSON.stringify(rows, null, 2)
    // ↑ sẽ bị wrap với truncate tự động
  },
}

import { glob } from "fast-glob"
import { pathToFileURL } from "node:url"

async function loadUserTools(pluginDirs: string[]): Promise<Tool[]> {
  const out: Tool[] = []

  for (const dir of pluginDirs) {
    const files = await glob(["tool/*.{js,ts}", "tools/*.{js,ts}"], { cwd: dir })

    for (const f of files) {
      try {
        const mod = await import(pathToFileURL(f).href)
        const def = mod.default
        if (def?.name && def?.execute) {
          out.push(wrapTool(def))  // auto-apply truncate / perm / trace
        }
      } catch (err) {
        console.warn(`Failed to load plugin: ${f}`, err)
      }
    }
  }

  return out
}

// Minimal plugin discovery system
import { glob } from "fast-glob"

interface PluginTool {
  name:        string
  description: string
  parameters:  Record<string, unknown>  // JSON Schema object
  execute:     (args: unknown) => Promise<string>
}

async function discoverTools(baseDirs: string[]): Promise<PluginTool[]> {
  const tools: PluginTool[] = []

  for (const dir of baseDirs) {
    // Convention: tool/ hoặc tools/ folder
    const files = await glob("{tool,tools}/*.{js,mjs,ts}", {
      cwd:      dir,
      absolute: true,
    })

    for (const file of files) {
      try {
        const mod = await import(file)
        const def = mod.default ?? mod.tool

        // Validate minimal shape
        if (!def?.name || !def?.execute || typeof def.execute !== "function") {
          console.warn(`[plugin] ${file}: invalid shape, skipping`)
          continue
        }

        // Wrap với safety: truncate output
        tools.push({
          ...def,
          execute: async (args: unknown) => {
            const raw = await def.execute(args)
            return typeof raw === "string" ? truncate(raw) : JSON.stringify(raw)
          },
        })

        console.log(`[plugin] Loaded tool: ${def.name} from ${file}`)
      } catch (err) {
        console.warn(`[plugin] Failed to load ${file}:`, err)
      }
    }
  }

  return tools
}