@xiaoqiong0v0/opencode-file-tool 1.0.8 → 1.1.1

package/dist/tools/analyze.js

@@ -0,0 +1,94 @@
+import { tool } from "@opencode-ai/plugin";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DESC, T, LANG } from "../i18n.js";
+import { requireModelCfg, getCfg } from "../config.js";
+import { findFileInChain, readFileData } from "../cache.js";
+const CACHE_TYPES_LIST = ["input", "image", "video", "tts"];
+export const analyzeImageTool = tool({
+    description: DESC.analyze_image[LANG],
+    args: {
+        source: tool.schema.enum(["file_path", "base64"]).describe(DESC.analyze_args_source[LANG]),
+        data: tool.schema.string().describe(DESC.analyze_args_data[LANG]),
+        prompt: tool.schema.string().optional().describe(DESC.analyze_args_prompt[LANG]),
+    },
+    execute: async ({ source, data, prompt }, context) => {
+        let imageUrl, fileName = "";
+        if (source === "file_path" && data.startsWith("file_id:")) {
+            const segs = data.slice(8).split(":");
+            let type = "input";
+            let fid;
+            if (segs.length === 2 && CACHE_TYPES_LIST.includes(segs[0])) {
+                type = segs[0];
+                fid = parseInt(segs[1], 10);
+            }
+            else {
+                fid = parseInt(segs[0], 10);
+            }
+            const found = findFileInChain(context.sessionID, type, fid);
+            if (!found) {
+                context.metadata?.({ title: T("meta_failed") });
+                return T("file_id_not_found", { id: `${type}:${fid}` });
+            }
+            const file = found.file;
+            if (!file.cached) {
+                context.metadata?.({ title: T("meta_skip") });
+                return T("uncached_hint", { id: `${type}:${fid}` });
+            }
+            if (!file.mime.startsWith("image/")) {
+                context.metadata?.({ title: T("meta_skip") });
+                return T("not_an_image", { name: file.filename, mime: file.mime });
+            }
+            fileName = file.filename;
+            imageUrl = readFileData(context.sessionID, type, fid) || "";
+            if (!imageUrl) {
+                context.metadata?.({ title: T("meta_failed") });
+                return T("file_data_not_found", { id: `${type}:${fid}` });
+            }
+            prompt = prompt || T("describe_image", { name: fileName });
+        }
+        else if (source === "file_path") {
+            if (!existsSync(data)) {
+                const tryPath = join(context.directory, data);
+                if (existsSync(tryPath))
+                    data = tryPath;
+            }
+            if (!existsSync(data)) {
+                context.metadata?.({ title: T("meta_not_found") });
+                return T("file_not_found", { path: data });
+            }
+            const ext = data.split(".").pop()?.toLowerCase() || "";
+            const mimeMap = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", bmp: "image/bmp", gif: "image/gif", webp: "image/webp" };
+            const mime = mimeMap[ext] || "image/png";
+            fileName = data.split(/[/\\]/).pop() || "";
+            imageUrl = `data:${mime};base64,${readFileSync(data).toString("base64")}`;
+        }
+        else if (source === "base64") {
+            imageUrl = `data:image/png;base64,${data.replace(/^data:image\/\w+;base64,/, "")}`;
+        }
+        else {
+            return T("unsupported_source", { source });
+        }
+        try {
+            const cfg = requireModelCfg("vision");
+            const resp = await fetch(`${cfg.baseURL}/chat/completions`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ model: cfg.modelId, messages: [{ role: "user", content: [{ type: "text", text: prompt || T("vision_prompt_default") }, { type: "image_url", image_url: { url: imageUrl } }] }], max_tokens: getCfg().maxTokens }),
+                signal: AbortSignal.timeout(getCfg().timeout || 60000),
+            });
+            if (!resp.ok)
+                throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+            const data = await resp.json();
+            const msg = data.choices?.[0]?.message;
+            const result = msg?.content || msg?.reasoning_content || T("empty_response");
+            context.metadata?.({ title: `[Vision] ${fileName || T("meta_image")}`, metadata: { sessionID: context.sessionID, messageID: context.messageID } });
+            return "[Vision] " + result;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            context.metadata?.({ title: T("meta_error") });
+            return `[Vision Error] ${msg}`;
+        }
+    },
+});

package/dist/tools/file_tool.js

@@ -0,0 +1,105 @@
+import { tool } from "@opencode-ai/plugin";
+import { existsSync } from "node:fs";
+import { DESC, T, LANG } from "../i18n.js";
+import { CONFIG_PATH, MODEL_TYPES, CACHE_TYPES, DEFAULT_CFG, getCfg, getProviderNames, readJsonc, ENABLED, setEnabled, saveCfg } from "../config.js";
+import { readTypeStore, getRootSession } from "../cache.js";
+import { localModelList, listModelsApi, currentModelSummary } from "./file_tool_helpers.js";
+export const fileTool = tool({
+    description: DESC.file_tool[LANG],
+    args: { command: tool.schema.string().describe(DESC.file_tool_args[LANG]) },
+    execute: async ({ command }, context) => {
+        const cmd = command.trim();
+        if (cmd === "list-provider") {
+            const providerNames = getProviderNames();
+            const models = await listModelsApi(providerNames);
+            const fallbackModels = localModelList();
+            for (const m of fallbackModels)
+                if (!models.includes(m))
+                    models.push(m);
+            const modelLines = models.map(m => "  " + m).join("\n");
+            return T("current_model", { model: currentModelSummary(), list: modelLines });
+        }
+        if (cmd.startsWith("set-provider ")) {
+            const arg = cmd.slice(13).trim();
+            if (!arg)
+                return T("specify_model");
+            let type = "vision";
+            let model = arg;
+            const colon = arg.indexOf(":");
+            if (colon > 0 && MODEL_TYPES.includes(arg.slice(0, colon))) {
+                type = arg.slice(0, colon);
+                model = arg.slice(colon + 1).trim();
+            }
+            if (!model)
+                return T("specify_model");
+            const cfg = existsSync(CONFIG_PATH) ? readJsonc(CONFIG_PATH) : {};
+            const models = { ...DEFAULT_CFG.models, ...((cfg.models && typeof cfg.models === "object") ? cfg.models : {}) };
+            models[type] = model;
+            saveCfg({ models });
+            return T("model_switched", { type, model });
+        }
+        if (cmd === "disable") {
+            setEnabled(false);
+            return T("disabled");
+        }
+        if (cmd === "enable") {
+            setEnabled(true);
+            return T("enabled");
+        }
+        if (cmd === "disable-save") {
+            saveCfg({ enabled: false });
+            return T("disabled");
+        }
+        if (cmd === "enable-save") {
+            saveCfg({ enabled: true });
+            return T("enabled");
+        }
+        if (cmd === "status") {
+            const c = getCfg();
+            const fmt = (t) => c.models[t]?.model || T("model_not_set");
+            return T("status", { s: ENABLED ? T("enabled") : T("disabled"), m: fmt("vision"), i: fmt("image"), v: fmt("video"), t: fmt("tts") });
+        }
+        if (cmd === "list-cache" || cmd.startsWith("list-cache ")) {
+            const rest = cmd === "list-cache" ? "" : cmd.slice(11).trim();
+            let targetSid = context.sessionID;
+            let arg = rest;
+            if (arg === "main" || arg.startsWith("main ")) {
+                targetSid = getRootSession(context.sessionID);
+                arg = arg === "main" ? "" : arg.slice(5).trim();
+            }
+            const tokens = arg.split(/\s+/).filter(Boolean);
+            let filter = null;
+            let countStr = "1";
+            if (tokens[0] && CACHE_TYPES.includes(tokens[0])) {
+                filter = tokens[0];
+                countStr = tokens[1] || "all";
+            }
+            else if (tokens[0]) {
+                countStr = tokens[0];
+            }
+            const types = filter ? [filter] : CACHE_TYPES;
+            const lines = [];
+            for (const type of types) {
+                const store = readTypeStore(targetSid, type);
+                const entries = Object.values(store.files);
+                if (entries.length === 0)
+                    continue;
+                let show = entries;
+                if (countStr !== "all") {
+                    const n = parseInt(countStr, 10);
+                    if (!isNaN(n) && n > 0)
+                        show = entries.slice(-n);
+                }
+                lines.push(`  ${type}:`);
+                for (const f of show) {
+                    const src = f.msgId ? `msg_${f.msgId.slice(-8)}` : type === "input" ? "input" : "generated";
+                    lines.push(`    ${f.filename} (${type}:${f.id}) [${src}]`);
+                }
+            }
+            if (lines.length === 0)
+                return `${targetSid}: ${T("no_cache")}`;
+            return `${targetSid}:\n${lines.join("\n")}`;
+        }
+        return T("unknown_cmd", { cmd });
+    },
+});

package/dist/tools/file_tool_helpers.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { T } from "../i18n.js";
+import { OPENCODE_CONFIG, CONFIG_DIR, MODEL_TYPES, getProviderCreds, getCfg, log } from "../config.js";
+export function localModelList() {
+    const models = [];
+    try {
+        const oc = JSON.parse(readFileSync(OPENCODE_CONFIG, "utf-8"));
+        for (const [pName, pVal] of Object.entries(oc.provider || {}))
+            for (const mId of Object.keys(pVal.models || {}))
+                models.push(`${pName}/${mId}`);
+    }
+    catch { }
+    const modelsJsonPath = join(CONFIG_DIR, ".cache/opencode/models.json");
+    if (existsSync(modelsJsonPath)) {
+        try {
+            const mc = JSON.parse(readFileSync(modelsJsonPath, "utf-8"));
+            for (const [pName, pVal] of Object.entries(mc)) {
+                const entry = pVal;
+                if (entry && typeof entry === "object" && entry.models && typeof entry.models === "object")
+                    for (const mId of Object.keys(entry.models))
+                        models.push(`${pName}/${mId}`);
+            }
+        }
+        catch (e) {
+            log.error(`Failed to read model cache ${modelsJsonPath}`, e instanceof Error ? e : Error(String(e)));
+        }
+    }
+    return models;
+}
+export async function listModelsApi(providerNames) {
+    const results = await Promise.allSettled([...providerNames].map(async (pName) => {
+        const creds = getProviderCreds(pName);
+        if (!creds)
+            return [];
+        const base = creds.baseURL.replace(/\/+$/, "");
+        const resp = await fetch(`${base}/models`, {
+            headers: { Authorization: `Bearer ${creds.apiKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!resp.ok)
+            return [];
+        const data = await resp.json();
+        const list = Array.isArray(data?.data) ? data.data.map((m) => m?.id).filter(Boolean) : [];
+        return list.map((m) => `${pName}/${m}`);
+    }));
+    const models = [];
+    for (const r of results)
+        if (r.status === "fulfilled")
+            for (const m of r.value)
+                if (!models.includes(m))
+                    models.push(m);
+    return models;
+}
+export function currentModelSummary() {
+    const c = getCfg();
+    const lines = MODEL_TYPES.map(t => `  ${t}: ${c.models[t]?.model || T("model_not_set")}`);
+    return lines.join("\n");
+}

package/dist/tools/generate.js

@@ -0,0 +1,107 @@
+import { tool } from "@opencode-ai/plugin";
+import { DESC, T, LANG } from "../i18n.js";
+import { requireModelCfg } from "../config.js";
+import { readTypeStore, registerGeneratedFile, fetchToBuffer, buildGenFilename, extForMime } from "../cache.js";
+import { generateVideo } from "../providers.js";
+import { genError } from "../utils.js";
+const GEN_TIMEOUT = 300000;
+export const textToImageTool = tool({
+    description: DESC.text_to_image[LANG],
+    args: {
+        prompt: tool.schema.string().describe(DESC.gen_args_prompt[LANG]),
+        size: tool.schema.string().optional().describe(DESC.gen_args_size[LANG]),
+    },
+    execute: async ({ prompt, size }, context) => {
+        try {
+            const cfg = requireModelCfg("image");
+            const body = { model: cfg.modelId, prompt };
+            if (size)
+                body.size = size;
+            const resp = await fetch(`${cfg.baseURL}/images/generations`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(GEN_TIMEOUT),
+            });
+            if (!resp.ok)
+                throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+            const data = await resp.json();
+            const item = data?.data?.[0];
+            if (!item)
+                throw new Error(T("gen_no_result"));
+            let buffer, mime = "image/png";
+            if (item.b64_json)
+                buffer = Buffer.from(item.b64_json, "base64");
+            else if (item.url) {
+                const d = await fetchToBuffer(item.url);
+                buffer = d.buffer;
+                mime = d.mime;
+            }
+            else
+                throw new Error(T("gen_no_result"));
+            const store = readTypeStore(context.sessionID, "image");
+            const r = registerGeneratedFile(context.sessionID, "image", buildGenFilename("image", mime, store.nextId), mime, context.messageID, buffer);
+            context.metadata?.({ title: "[ImageGen]", metadata: { sessionID: context.sessionID, messageID: context.messageID } });
+            return T("image_generated", { name: `image_${r.id}.${extForMime(mime)}`, id: `image:${r.id}`, path: r.path });
+        }
+        catch (e) {
+            context.metadata?.({ title: T("meta_error") });
+            return genError(e);
+        }
+    },
+});
+export const textToVideoTool = tool({
+    description: DESC.text_to_video[LANG],
+    args: {
+        prompt: tool.schema.string().describe(DESC.gen_args_prompt[LANG]),
+        duration: tool.schema.number().optional().describe(DESC.gen_args_duration[LANG]),
+    },
+    execute: async ({ prompt, duration }, context) => {
+        try {
+            const cfg = requireModelCfg("video");
+            const url = await generateVideo(cfg, prompt, duration);
+            const d = await fetchToBuffer(url);
+            const store = readTypeStore(context.sessionID, "video");
+            const r = registerGeneratedFile(context.sessionID, "video", buildGenFilename("video", d.mime, store.nextId), d.mime, context.messageID, d.buffer);
+            context.metadata?.({ title: "[VideoGen]", metadata: { sessionID: context.sessionID, messageID: context.messageID } });
+            return T("video_generated", { name: `video_${r.id}.${extForMime(d.mime)}`, id: `video:${r.id}`, path: r.path });
+        }
+        catch (e) {
+            context.metadata?.({ title: T("meta_error") });
+            return genError(e);
+        }
+    },
+});
+export const textToSpeechTool = tool({
+    description: DESC.text_to_speech[LANG],
+    args: {
+        text: tool.schema.string().describe(DESC.gen_args_prompt[LANG]),
+        voice: tool.schema.string().optional().describe(DESC.gen_args_voice[LANG]),
+    },
+    execute: async ({ text, voice }, context) => {
+        try {
+            const cfg = requireModelCfg("tts");
+            const body = { model: cfg.modelId, input: text };
+            if (voice)
+                body.voice = voice;
+            const resp = await fetch(`${cfg.baseURL}/audio/speech`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${cfg.apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(GEN_TIMEOUT),
+            });
+            if (!resp.ok)
+                throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+            const buf = Buffer.from(await resp.arrayBuffer());
+            const mime = resp.headers.get("content-type")?.split(";")[0] || "audio/mpeg";
+            const store = readTypeStore(context.sessionID, "tts");
+            const r = registerGeneratedFile(context.sessionID, "tts", buildGenFilename("tts", mime, store.nextId), mime, context.messageID, buf);
+            context.metadata?.({ title: "[TTS]", metadata: { sessionID: context.sessionID, messageID: context.messageID } });
+            return T("tts_generated", { name: `tts_${r.id}.${extForMime(mime)}`, id: `tts:${r.id}`, path: r.path });
+        }
+        catch (e) {
+            context.metadata?.({ title: T("meta_error") });
+            return genError(e);
+        }
+    },
+});

package/dist/utils.js

@@ -0,0 +1,32 @@
+import { T } from "./i18n.js";
+import { fetchToBuffer, registerGeneratedFile, buildGenFilename, readTypeStore } from "./cache.js";
+export function isAgnesProvider(baseURL) {
+    return /agnes/i.test(baseURL);
+}
+export async function postJson(url, apiKey, body, timeout = 300000) {
+    const resp = await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeout),
+    });
+    if (!resp.ok)
+        throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+    return resp.json();
+}
+export async function getJson(url, apiKey, timeout = 30000) {
+    const resp = await fetch(url, { headers: { Authorization: `Bearer ${apiKey}` }, signal: AbortSignal.timeout(timeout) });
+    if (!resp.ok)
+        throw new Error(T("err_api", { status: String(resp.status), msg: (await resp.text().catch(() => "unknown")).slice(0, 200) }));
+    return resp.json();
+}
+export async function downloadAndRegister(context, type, url) {
+    const d = await fetchToBuffer(url);
+    const store = readTypeStore(context.sessionID, type);
+    const r = registerGeneratedFile(context.sessionID, type, buildGenFilename(type, d.mime, store.nextId), d.mime, context.messageID, d.buffer);
+    return { id: r.id, path: r.path, mime: d.mime };
+}
+export function genError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return `[Gen Error] ${msg}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaoqiong0v0/opencode-file-tool",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "type": "module",
   "description": "File cache & image analysis plugin for OpenCode. Auto-caches pasted images, analyzes via multimodal model.",
   "files": [