opencode-manifold 0.5.23 → 0.5.25

package/dist/index.js

@@ -595,7 +595,8 @@ var ManifoldPlugin = async (ctx) => {
   });
   return {
     tool: {
-      execute_task: executeTaskTool(client, directory)
+      execute_task: executeTaskTool(client, directory),
+      getModelPath: getModelPathTool
     },
     "command.execute.before": async (input, output) => {
       await client.app.log({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-manifold",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "Multi-agent development system for opencode with persistent knowledge",
   "main": "dist/index.js",
   "type": "module",

package/dist/tui.js

@@ -1,340 +0,0 @@
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/tools/get-model-path.ts
-var exports_get_model_path = {};
-__export(exports_get_model_path, {
-  setPluginContext: () => setPluginContext,
-  getModelPathTool: () => getModelPathTool,
-  getModelPath: () => getModelPath
-});
-import { tool } from "@opencode-ai/plugin";
-async function getModelPath(client, sessionID) {
-  if (sessionID) {
-    try {
-      const messagesResponse = await client.session.messages({
-        path: { id: sessionID }
-      });
-      if (messagesResponse.data && messagesResponse.data.length > 0) {
-        const lastMessage = messagesResponse.data[messagesResponse.data.length - 1];
-        if (lastMessage.info) {
-          if (lastMessage.info.role === "assistant") {
-            const assistantMsg = lastMessage.info;
-            return `${assistantMsg.providerID}/${assistantMsg.modelID}`;
-          }
-          if (lastMessage.info.model) {
-            const { providerID, modelID } = lastMessage.info.model;
-            return `${providerID}/${modelID}`;
-          }
-        }
-      }
-    } catch (error) {
-      await client.app.log({
-        body: {
-          service: "opencode-manifold",
-          level: "warn",
-          message: `Error getting model from session messages: ${error}`
-        }
-      });
-    }
-  }
-  try {
-    const providersResponse = await client.config.providers({});
-    if (providersResponse.data && providersResponse.data.default) {
-      const defaults = providersResponse.data.default;
-      const defaultModel = defaults["model"] || defaults["small_model"];
-      if (defaultModel && typeof defaultModel === "string") {
-        return defaultModel;
-      }
-    }
-  } catch (error) {
-    await client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "warn",
-        message: `Error getting default model from config: ${error}`
-      }
-    });
-  }
-  return "No active model found";
-}
-function setPluginContext(client) {
-  pluginClient = client;
-}
-function getModelPathClient() {
-  if (!pluginClient) {
-    throw new Error("Plugin client not initialized");
-  }
-  return pluginClient;
-}
-var pluginClient = null, getModelPathTool;
-var init_get_model_path = __esm(() => {
-  getModelPathTool = tool({
-    description: "Returns the model path (provider/model) for the currently active session. Use this to get the correct model string for agent MD file model: attributes.",
-    args: {},
-    async execute(_args, context) {
-      const client = getModelPathClient();
-      const modelPath = await getModelPath(client, context.sessionID);
-      return modelPath;
-    }
-  });
-});
-
-// src/init.ts
-import { readFile, writeFile, mkdir, readdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { homedir } from "os";
-import { createRequire as createRequire2 } from "module";
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire2(import.meta.url);
-function getBundledTemplatesDir() {
-  const possiblePaths = [
-    join(__dirname2, "..", "src", "templates"),
-    join(__dirname2, "templates"),
-    join(__dirname2, "..", "templates")
-  ];
-  for (const p of possiblePaths) {
-    if (existsSync(p))
-      return p;
-  }
-  return possiblePaths[0];
-}
-var bundledTemplatesDir = getBundledTemplatesDir();
-var globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
-async function getPluginVersion() {
-  try {
-    const packageJson = require2(join(__dirname2, "..", "package.json"));
-    return packageJson.version || "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-async function dirHasContent(dirPath) {
-  if (!existsSync(dirPath))
-    return false;
-  try {
-    const entries = await readdir(dirPath);
-    return entries.length > 0;
-  } catch {
-    return false;
-  }
-}
-async function copyMissingFiles(src, dest) {
-  if (!existsSync(src))
-    return [];
-  await mkdir(dest, { recursive: true });
-  const copied = [];
-  const entries = await readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const subCopied = await copyMissingFiles(srcPath, destPath);
-      if (subCopied.length > 0) {
-        copied.push(entry.name);
-      }
-    } else if (!existsSync(destPath)) {
-      await writeFile(destPath, await readFile(srcPath));
-      copied.push(entry.name);
-    }
-  }
-  return copied;
-}
-async function copyFiles(src, dest) {
-  if (!existsSync(src))
-    return [];
-  await mkdir(dest, { recursive: true });
-  const copied = [];
-  const entries = await readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const subCopied = await copyFiles(srcPath, destPath);
-      if (subCopied.length > 0) {
-        copied.push(entry.name);
-      }
-    } else {
-      await writeFile(destPath, await readFile(srcPath));
-      copied.push(entry.name);
-    }
-  }
-  return copied;
-}
-async function copyFile(src, dest) {
-  if (!existsSync(src))
-    return;
-  const destDir = dirname(dest);
-  if (!existsSync(destDir)) {
-    await mkdir(destDir, { recursive: true });
-  }
-  await writeFile(dest, await readFile(src));
-}
-async function ensureGlobalTemplates(ctx) {
-  await ctx.client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Synchronizing global templates..."
-    }
-  });
-  if (!existsSync(bundledTemplatesDir)) {
-    await ctx.client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "error",
-        message: `Bundled templates not found at ${bundledTemplatesDir}`
-      }
-    });
-    return;
-  }
-  if (existsSync(globalTemplatesDir)) {
-    const { rm } = await import("fs/promises");
-    await rm(globalTemplatesDir, { recursive: true, force: true });
-  }
-  await copyFiles(bundledTemplatesDir, globalTemplatesDir);
-  const globalCommandsDir = join(homedir(), ".config", "opencode", "commands");
-  const initCommandSrc = join(bundledTemplatesDir, "commands", "manifold-init.md");
-  const initCommandDest = join(globalCommandsDir, "manifold-init.md");
-  if (existsSync(initCommandSrc)) {
-    await copyFile(initCommandSrc, initCommandDest);
-  }
-  await ctx.client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: "Global templates synchronized"
-    }
-  });
-}
-async function initProject(directory, client) {
-  const initialized = [];
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Running /manifold-init in ${directory}`
-    }
-  });
-  if (!await dirHasContent(globalTemplatesDir)) {
-    await client.app.log({
-      body: {
-        service: "opencode-manifold",
-        level: "error",
-        message: `Global templates not found at ${globalTemplatesDir}. Plugin may not have loaded correctly.`
-      }
-    });
-    return initialized;
-  }
-  const agentsCopied = await copyMissingFiles(join(globalTemplatesDir, "agents"), join(directory, ".opencode", "agents"));
-  if (agentsCopied.length > 0) {
-    initialized.push(`agents (${agentsCopied.join(", ")})`);
-  }
-  const skillsCopied = await copyMissingFiles(join(globalTemplatesDir, "skills"), join(directory, ".opencode", "skills"));
-  if (skillsCopied.length > 0) {
-    initialized.push(`skills (${skillsCopied.join(", ")})`);
-  }
-  const manifoldCopied = await copyMissingFiles(join(globalTemplatesDir, "manifold"), join(directory, "Manifold"));
-  if (manifoldCopied.length > 0) {
-    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
-  }
-  const projectCommandsDir = join(directory, ".opencode", "commands");
-  const commandsToCopy = [];
-  const commandsInitialized = [];
-  for (const cmd of commandsToCopy) {
-    const src = join(globalTemplatesDir, "commands", cmd);
-    const dest = join(projectCommandsDir, cmd);
-    if (existsSync(src) && !existsSync(dest)) {
-      await copyFile(src, dest);
-      commandsInitialized.push(cmd);
-    }
-  }
-  if (commandsInitialized.length > 0) {
-    initialized.push(`commands (${commandsInitialized.join(", ")})`);
-  }
-  const version = await getPluginVersion();
-  await writeFile(join(directory, "Manifold", "VERSION"), version + `
-`);
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `/manifold-init complete: ${initialized.join(", ") || "already initialized"}`
-    }
-  });
-  return initialized;
-}
-
-// src/tui.ts
-var tui = async (api) => {
-  api.command.register(() => [
-    {
-      title: "Manifold Init",
-      value: "manifold-init",
-      description: "Initialize Manifold agents, skills, and settings in this project",
-      category: "Manifold",
-      slash: { name: "manifold-init" },
-      onSelect: async () => {
-        try {
-          const directory = api.state.project?.directory;
-          if (!directory) {
-            api.ui.toast({
-              variant: "error",
-              message: "No project directory found"
-            });
-            return;
-          }
-          const initialized = await initProject(directory, api.client);
-          api.ui.toast({
-            variant: "success",
-            message: `Manifold initialized: ${initialized.join(", ") || "already setup"}`
-          });
-        } catch (error) {
-          api.ui.toast({
-            variant: "error",
-            message: `Init failed: ${error}`
-          });
-        }
-      }
-    },
-    {
-      title: "Get Model Path",
-      value: "manifold-model-path",
-      description: "Return the currently active model path for agent MD files",
-      category: "Manifold",
-      slash: { name: "manifold-model-path" },
-      onSelect: () => {
-        const sessionID = api.state.session?.id;
-        if (!sessionID) {
-          api.ui.toast({ variant: "error", message: "No active session" });
-          return;
-        }
-        Promise.resolve().then(() => (init_get_model_path(), exports_get_model_path)).then(({ getModelPath: getModelPath2 }) => {
-          getModelPath2(api.client, sessionID).then((modelPath) => {
-            api.ui.toast({ variant: "success", message: modelPath });
-          });
-        });
-      }
-    }
-  ]);
-};
-export {
-  tui
-};