opencode-manifold 0.4.13 → 0.4.15

package/dist/tui.js

@@ -5,7 +5,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { readFile, writeFile, readdir } from "fs/promises";
+import { readFile, writeFile, readdir, mkdir } from "fs/promises";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
@@ -2754,6 +2754,15 @@ async function updateAgentModel(agentName, modelId, directory) {
 }
 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"
+      }
+    },
     {
       title: "Manifold Models",
       value: "manifold-models",
@@ -2774,13 +2783,73 @@ var tui = async (api) => {
     }
   ]);
   api.event.on("tui.command.execute", async (event) => {
-    if (event.properties.command === "manifold-models") {
+    if (event.properties.command === "manifold-init") {
+      await handleManifoldInit(api);
+    } else if (event.properties.command === "manifold-models") {
       await handleManifoldModels(api);
     } else if (event.properties.command === "manifold-update") {
       await handleManifoldUpdate(api);
     }
   });
 };
+async function copyMissingFiles(src, dest) {
+  const { existsSync: existsSync2, mkdir: mkdir2, writeFile: writeFile2, readdir: readdir2 } = await import("fs/promises");
+  const { join: join2 } = await import("path");
+  if (!existsSync2(src))
+    return [];
+  await mkdir2(dest, { recursive: true });
+  const copied = [];
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, entry.name);
+    if (entry.isDirectory()) {
+      const subCopied = await copyMissingFiles(srcPath, destPath);
+      if (subCopied.length > 0) {
+        copied.push(entry.name);
+      }
+    } else if (!existsSync2(destPath)) {
+      await writeFile2(destPath, await readFile(srcPath));
+      copied.push(entry.name);
+    }
+  }
+  return copied;
+}
+async function handleManifoldInit(api) {
+  const directory = api.state.path.directory;
+  const globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
+  if (!existsSync(globalTemplatesDir)) {
+    api.ui.toast({
+      variant: "error",
+      message: "Global templates not found. Plugin may not be installed correctly."
+    });
+    return;
+  }
+  const agentsDir = join(directory, ".opencode", "agents");
+  const skillsDir = join(directory, ".opencode", "skills");
+  const manifoldDir = join(directory, "Manifold");
+  await mkdir(agentsDir, { recursive: true });
+  await mkdir(skillsDir, { recursive: true });
+  await mkdir(manifoldDir, { recursive: true });
+  const agentsCopied = await copyMissingFiles(join(globalTemplatesDir, "agents"), agentsDir);
+  const skillsCopied = await copyMissingFiles(join(globalTemplatesDir, "skills"), skillsDir);
+  const manifoldCopied = await copyMissingFiles(join(globalTemplatesDir, "manifold"), manifoldDir);
+  const initialized = [];
+  if (agentsCopied.length > 0) {
+    initialized.push(`agents (${agentsCopied.join(", ")})`);
+  }
+  if (skillsCopied.length > 0) {
+    initialized.push(`skills (${skillsCopied.join(", ")})`);
+  }
+  if (manifoldCopied.length > 0) {
+    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
+  }
+  const message = initialized.length > 0 ? `Manifold initialized: ${initialized.join(", ")}` : "All Manifold files already present.";
+  api.ui.toast({
+    variant: "success",
+    message
+  });
+}
 async function handleManifoldModels(api) {
   const directory = api.state.path.directory;
   const agents = await getManifoldAgents(directory);
@@ -2851,6 +2920,7 @@ async function handleManifoldModels(api) {
 }
 async function handleManifoldUpdate(api) {
   const directory = api.state.path.directory;
+  const { rm } = await import("fs/promises");
   const settingsPath = join(directory, "Manifold", "settings.json");
   let settings = {};
   if (existsSync(settingsPath)) {
@@ -2859,29 +2929,10 @@ async function handleManifoldUpdate(api) {
       settings = JSON.parse(content);
     } catch {}
   }
+  const globalConfigDir = join(homedir(), ".config", "opencode", "manifold");
   const configuredPaths = settings.updateCachePaths || [];
-  if (configuredPaths.length === 0) {
-    api.ui.dialog.setSize("large");
-    api.ui.ui.DialogSelect({
-      title: "Manifold Plugin Update",
-      options: [
-        {
-          title: "Configure Cache Paths",
-          value: "configure",
-          description: "Add updateCachePaths to Manifold/settings.json",
-          footer: "Opens settings file"
-        }
-      ],
-      onSelect: () => {
-        api.ui.toast({
-          variant: "info",
-          message: "Add updateCachePaths to Manifold/settings.json"
-        });
-      }
-    });
-    return;
-  }
-  const resolvedPaths = configuredPaths.map((p) => {
+  const pathsToClear = [...new Set([...configuredPaths, globalConfigDir])];
+  const resolvedPaths = pathsToClear.map((p) => {
     const expanded = p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
     return expanded;
   });
@@ -2891,9 +2942,9 @@ async function handleManifoldUpdate(api) {
       title: "Manifold Plugin Update",
       options: [
         {
-          title: "Clear Cache",
+          title: "Clear Plugin & Template Cache",
           value: "confirm",
-          description: `Will clear ${resolvedPaths.length} path(s)`,
+          description: `Will clear ${resolvedPaths.length} path(s) including global templates`,
           footer: resolvedPaths.map((p) => `• ${p}`).join(`
 `)
         },
@@ -2908,36 +2959,21 @@ async function handleManifoldUpdate(api) {
           resolve();
           return;
         }
-        const { exec } = await import("child_process");
-        const { promisify } = await import("util");
-        const execAsync = promisify(exec);
         const cleared = [];
-        const skipped = [];
         const blocked = [];
         for (const pathStr of resolvedPaths) {
           try {
-            await execAsync(`rm -rf "${pathStr}"`);
-            cleared.push(pathStr);
+            if (existsSync(pathStr)) {
+              await rm(pathStr, { recursive: true, force: true });
+              cleared.push(pathStr);
+            }
           } catch (error) {
-            blocked.push({ path: pathStr, reason: `Failed to delete: ${error}` });
+            blocked.push({ path: pathStr, reason: `${error}` });
           }
         }
-        let message = "";
-        if (cleared.length > 0) {
-          message += `✅ Cleared: ${cleared.length} path(s)
-`;
-        }
-        if (blocked.length > 0) {
-          message += `\uD83D\uDEAB Blocked: ${blocked.length} path(s)
-`;
-        }
-        if (cleared.length > 0) {
-          message += `
-Restart opencode to pull the latest plugin version.`;
-        }
         api.ui.toast({
           variant: cleared.length > 0 ? "success" : "error",
-          message: cleared.length > 0 ? `Cache cleared. Restart opencode to update.` : `Cache update blocked`
+          message: cleared.length > 0 ? `Cache cleared. Restart opencode to update.` : `No paths cleared or update blocked`
         });
         resolve();
       }

package/package.json

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