@vuau/agent-memory 0.1.1 → 0.2.1

package/README.md

@@ -82,9 +82,18 @@ npx @vuau/agent-memory init
 npx @vuau/agent-memory init --force          # Overwrite existing files
 npx @vuau/agent-memory init --name "My App"  # Custom project name
 npx @vuau/agent-memory init --no-copilot     # Skip copilot-instructions.md
+npx @vuau/agent-memory init --opencode       # Wire up OpenCode plugin
 npx @vuau/agent-memory doctor                # Validate structure
 ```
 
+#### `--opencode` flag
+
+Wires up the OpenCode plugin automatically:
+- Creates/updates `.opencode/package.json` with `@vuau/agent-memory` dependency
+- Creates/updates `opencode.json` with `"plugin": ["@vuau/agent-memory"]`
+
+After running, restart OpenCode to activate the plugin.
+
 ## How It Works
 
 ### For AI Agents

package/dist/bin/cli.js

@@ -15,15 +15,12 @@ var COPILOT_INSTRUCTIONS = ".github/copilot-instructions.md";
 
 // src/core/scaffold.ts
 function getTemplatesDir() {
-  try {
-    const thisDir = dirname(fileURLToPath(import.meta.url));
-    const candidate = resolve(thisDir, "../../templates");
-    if (existsSync(candidate)) return candidate;
-  } catch {
-  }
-  const candidate2 = resolve(__dirname, "../../templates");
-  if (existsSync(candidate2)) return candidate2;
-  throw new Error("Cannot locate templates directory");
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const fromSource = resolve(thisDir, "../../templates");
+  if (existsSync(fromSource)) return fromSource;
+  const fromDist = resolve(thisDir, "../templates");
+  if (existsSync(fromDist)) return fromDist;
+  throw new Error(`Cannot locate templates directory (checked ${fromSource} and ${fromDist})`);
 }
 var TEMPLATES_DIR = getTemplatesDir();
 function readTemplate(name) {
@@ -79,8 +76,57 @@ function scaffold(projectDir, config = {}, force = false) {
     writeFileSync(specKeep, "");
     result.created.push(`${SPEC_DIR}/.gitkeep`);
   }
+  if (config.opencode) {
+    scaffoldOpenCode(projectDir, result, force);
+  }
   return result;
 }
+function scaffoldOpenCode(projectDir, result, force) {
+  const PACKAGE_NAME = "@vuau/agent-memory";
+  const opencodePkgPath = join(projectDir, ".opencode", "package.json");
+  const opencodeDir = join(projectDir, ".opencode");
+  if (!existsSync(opencodeDir)) {
+    mkdirSync(opencodeDir, { recursive: true });
+  }
+  if (!existsSync(opencodePkgPath)) {
+    writeFileSync(
+      opencodePkgPath,
+      JSON.stringify({ dependencies: { [PACKAGE_NAME]: "latest" } }, null, 2) + "\n"
+    );
+    result.created.push(".opencode/package.json");
+  } else {
+    const pkg = JSON.parse(readFileSync(opencodePkgPath, "utf-8"));
+    const deps = pkg.dependencies || {};
+    if (!deps[PACKAGE_NAME] || force) {
+      deps[PACKAGE_NAME] = "latest";
+      pkg.dependencies = deps;
+      writeFileSync(opencodePkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      if (!deps[PACKAGE_NAME]) {
+        result.created.push(".opencode/package.json");
+      }
+    } else {
+      result.skipped.push(".opencode/package.json");
+    }
+  }
+  const opencodeJsonPath = join(projectDir, "opencode.json");
+  if (!existsSync(opencodeJsonPath)) {
+    writeFileSync(
+      opencodeJsonPath,
+      JSON.stringify({ plugin: [PACKAGE_NAME] }, null, 2) + "\n"
+    );
+    result.created.push("opencode.json");
+  } else {
+    const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+    const plugins = config.plugin || [];
+    if (!plugins.includes(PACKAGE_NAME)) {
+      config.plugin = [...plugins, PACKAGE_NAME];
+      writeFileSync(opencodeJsonPath, JSON.stringify(config, null, 2) + "\n");
+      result.created.push("opencode.json (merged plugin)");
+    } else {
+      result.skipped.push("opencode.json");
+    }
+  }
+}
 function guessProjectName(dir) {
   const pkgPath = join(dir, "package.json");
   if (existsSync(pkgPath)) {
@@ -151,6 +197,53 @@ function doctor(projectDir) {
       });
     }
   }
+  const opencodePkgPath = join2(projectDir, ".opencode", "package.json");
+  const opencodeJsonPath = join2(projectDir, "opencode.json");
+  const opencodeExists = existsSync2(join2(projectDir, ".opencode"));
+  if (opencodeExists) {
+    if (!existsSync2(opencodePkgPath)) {
+      issues.push({
+        level: "warning",
+        file: ".opencode/package.json",
+        message: "Missing \u2014 run 'agent-memory init --opencode' to wire up the plugin"
+      });
+    } else {
+      try {
+        const pkg = JSON.parse(readFileSync2(opencodePkgPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (!deps["@vuau/agent-memory"]) {
+          issues.push({
+            level: "warning",
+            file: ".opencode/package.json",
+            message: "@vuau/agent-memory not in dependencies \u2014 run 'agent-memory init --opencode'"
+          });
+        }
+      } catch {
+        issues.push({ level: "warning", file: ".opencode/package.json", message: "Invalid JSON" });
+      }
+    }
+    if (!existsSync2(opencodeJsonPath)) {
+      issues.push({
+        level: "warning",
+        file: "opencode.json",
+        message: "Missing \u2014 run 'agent-memory init --opencode' to wire up the plugin"
+      });
+    } else {
+      try {
+        const config = JSON.parse(readFileSync2(opencodeJsonPath, "utf-8"));
+        const plugins = config.plugin || [];
+        if (!plugins.includes("@vuau/agent-memory")) {
+          issues.push({
+            level: "warning",
+            file: "opencode.json",
+            message: "@vuau/agent-memory not in plugin array \u2014 run 'agent-memory init --opencode'"
+          });
+        }
+      } catch {
+        issues.push({ level: "warning", file: "opencode.json", message: "Invalid JSON" });
+      }
+    }
+  }
   return { ok: issues.filter((i) => i.level === "error").length === 0, issues };
 }
 
@@ -170,18 +263,21 @@ Options (init):
   --force                        Overwrite existing files
   --name <name>                  Project name (default: from package.json)
   --no-copilot                   Skip .github/copilot-instructions.md
+  --opencode                     Wire up OpenCode plugin (.opencode/package.json + opencode.json)
 `);
 }
 function runInit() {
   const force = args.includes("--force");
   const noCopilot = args.includes("--no-copilot");
+  const opencode = args.includes("--opencode");
   const nameIdx = args.indexOf("--name");
   const projectName = nameIdx !== -1 ? args[nameIdx + 1] : void 0;
   const cwd = process.cwd();
   console.log(`Initializing agent memory in ${cwd}...`);
   const result = scaffold(cwd, {
     projectName,
-    copilotInstructions: !noCopilot
+    copilotInstructions: !noCopilot,
+    opencode
   }, force);
   if (result.created.length > 0) {
     console.log("\nCreated:");
@@ -201,7 +297,11 @@ function runInit() {
   console.log("\nNext steps:");
   console.log("  1. Edit AGENTS.md \u2014 add your project-specific rules");
   console.log("  2. Add spec files to .agents/spec/ for detailed documentation");
-  console.log('  3. For OpenCode: add to opencode.json \u2192 { "plugin": ["@vuau/agent-memory"] }');
+  if (opencode) {
+    console.log("  3. Restart OpenCode to activate the plugin");
+  } else {
+    console.log("  3. For OpenCode: run with --opencode flag to wire up the plugin");
+  }
   console.log("");
 }
 function runDoctor() {

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/opencode/plugin.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/core/scaffold.ts
@@ -17,15 +17,12 @@ var COPILOT_INSTRUCTIONS = ".github/copilot-instructions.md";
 
 // src/core/scaffold.ts
 function getTemplatesDir() {
-  try {
-    const thisDir = dirname(fileURLToPath(import.meta.url));
-    const candidate = resolve(thisDir, "../../templates");
-    if (existsSync(candidate)) return candidate;
-  } catch {
-  }
-  const candidate2 = resolve(__dirname, "../../templates");
-  if (existsSync(candidate2)) return candidate2;
-  throw new Error("Cannot locate templates directory");
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const fromSource = resolve(thisDir, "../../templates");
+  if (existsSync(fromSource)) return fromSource;
+  const fromDist = resolve(thisDir, "../templates");
+  if (existsSync(fromDist)) return fromDist;
+  throw new Error(`Cannot locate templates directory (checked ${fromSource} and ${fromDist})`);
 }
 var TEMPLATES_DIR = getTemplatesDir();
 function readTemplate(name) {
@@ -81,8 +78,57 @@ function scaffold(projectDir, config = {}, force = false) {
     writeFileSync(specKeep, "");
     result.created.push(`${SPEC_DIR}/.gitkeep`);
   }
+  if (config.opencode) {
+    scaffoldOpenCode(projectDir, result, force);
+  }
   return result;
 }
+function scaffoldOpenCode(projectDir, result, force) {
+  const PACKAGE_NAME = "@vuau/agent-memory";
+  const opencodePkgPath = join(projectDir, ".opencode", "package.json");
+  const opencodeDir = join(projectDir, ".opencode");
+  if (!existsSync(opencodeDir)) {
+    mkdirSync(opencodeDir, { recursive: true });
+  }
+  if (!existsSync(opencodePkgPath)) {
+    writeFileSync(
+      opencodePkgPath,
+      JSON.stringify({ dependencies: { [PACKAGE_NAME]: "latest" } }, null, 2) + "\n"
+    );
+    result.created.push(".opencode/package.json");
+  } else {
+    const pkg = JSON.parse(readFileSync(opencodePkgPath, "utf-8"));
+    const deps = pkg.dependencies || {};
+    if (!deps[PACKAGE_NAME] || force) {
+      deps[PACKAGE_NAME] = "latest";
+      pkg.dependencies = deps;
+      writeFileSync(opencodePkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      if (!deps[PACKAGE_NAME]) {
+        result.created.push(".opencode/package.json");
+      }
+    } else {
+      result.skipped.push(".opencode/package.json");
+    }
+  }
+  const opencodeJsonPath = join(projectDir, "opencode.json");
+  if (!existsSync(opencodeJsonPath)) {
+    writeFileSync(
+      opencodeJsonPath,
+      JSON.stringify({ plugin: [PACKAGE_NAME] }, null, 2) + "\n"
+    );
+    result.created.push("opencode.json");
+  } else {
+    const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+    const plugins = config.plugin || [];
+    if (!plugins.includes(PACKAGE_NAME)) {
+      config.plugin = [...plugins, PACKAGE_NAME];
+      writeFileSync(opencodeJsonPath, JSON.stringify(config, null, 2) + "\n");
+      result.created.push("opencode.json (merged plugin)");
+    } else {
+      result.skipped.push("opencode.json");
+    }
+  }
+}
 function guessProjectName(dir) {
   const pkgPath = join(dir, "package.json");
   if (existsSync(pkgPath)) {
@@ -102,67 +148,91 @@ var MemoryLifecyclePlugin = async ({ client, directory }) => {
   const agentsFile = resolve2(directory, AGENTS_MD);
   let editCount = 0;
   let specFilesEdited = [];
+  let sessionStartTime = null;
+  const showToast = async (message, variant = "info") => {
+    try {
+      await client.tui.showToast({
+        body: { message, variant }
+      });
+    } catch {
+      await log("info", message);
+    }
+  };
+  const log = async (level, message, extra) => {
+    try {
+      await client.app.log({
+        body: {
+          service: "agent-memory",
+          level,
+          message,
+          extra
+        }
+      });
+    } catch {
+    }
+  };
   return {
     event: async ({ event }) => {
       if (event.type === "session.created") {
+        sessionStartTime = Date.now();
+        editCount = 0;
+        specFilesEdited = [];
         const hasAgentsMd = existsSync2(agentsFile);
         const hasMemory = existsSync2(memoryFile);
+        const hasTasks = existsSync2(tasksFile);
         if (!hasMemory && hasAgentsMd) {
           try {
             const result = scaffold(directory, { copilotInstructions: false });
             if (result.created.length > 0) {
-              await client.tui.showToast({
-                body: {
-                  message: `Agent memory initialized: ${result.created.join(", ")}`,
-                  variant: "success"
-                }
-              });
+              await showToast(`Agent memory initialized: ${result.created.join(", ")}`, "success");
+              await log("info", "Auto-scaffolded .agents/ structure", { created: result.created });
             }
           } catch (err) {
-            await client.app.log({
-              body: {
-                service: "agent-memory",
-                level: "warn",
-                message: `Auto-scaffold failed: ${err}`
-              }
-            });
+            await log("warn", `Auto-scaffold failed: ${err}`);
           }
         }
-        editCount = 0;
-        specFilesEdited = [];
-        await client.app.log({
-          body: {
-            service: "agent-memory",
-            level: "info",
-            message: `Memory: ${hasMemory}, Tasks: ${existsSync2(tasksFile)}`
-          }
+        await log("debug", "Session started", {
+          hasAgentsMd,
+          hasMemory,
+          hasTasks,
+          directory
         });
       }
-      if (event.type === "session.idle" && editCount >= 3) {
-        if (existsSync2(tasksFile)) {
-          const content = readFileSync2(tasksFile, "utf-8");
-          const inProgressSection = content.split("## In Progress")[1];
-          if (inProgressSection?.trim()) {
-            await client.tui.showToast({
-              body: {
-                message: `${editCount} edits this session. Update .agents/TASKS.md before ending.`,
-                variant: "info"
-              }
-            });
-          }
+      if (event.type === "session.idle") {
+        if (editCount >= 3 && existsSync2(tasksFile)) {
+          const sessionDuration = sessionStartTime ? Math.round((Date.now() - sessionStartTime) / 1e3 / 60) : 0;
+          await showToast(
+            `${editCount} file edits (${sessionDuration}m). Consider updating .agents/TASKS.md`,
+            "info"
+          );
+          await log("info", "Session idle with significant edits", {
+            editCount,
+            specFilesEdited,
+            sessionDurationMinutes: sessionDuration
+          });
         }
       }
     },
-    "tool.execute.after": async (input) => {
-      if (input.tool === "edit" || input.tool === "write") {
+    // ─────────────────────────────────────────────────────────────
+    // TOOL EXECUTE AFTER — track edits
+    // ─────────────────────────────────────────────────────────────
+    "tool.execute.after": async (input, _output) => {
+      const toolName = input.tool;
+      const filePath = input.args?.filePath || "";
+      if (toolName === "edit" || toolName === "write") {
         editCount++;
-        const filePath = input.args?.filePath || "";
         if (filePath.includes(SPEC_DIR)) {
           const shortPath = filePath.split(SPEC_DIR + "/").pop() || filePath;
           if (!specFilesEdited.includes(shortPath)) {
             specFilesEdited.push(shortPath);
           }
         }
+        if (editCount % 5 === 0) {
+          await log("debug", `Edit milestone: ${editCount} files modified`, {
+            latestFile: filePath,
+            specFilesEdited
+          });
+        }
       }
     }
   };
@@ -329,6 +399,53 @@ function doctor(projectDir) {
       });
     }
   }
+  const opencodePkgPath = join4(projectDir, ".opencode", "package.json");
+  const opencodeJsonPath = join4(projectDir, "opencode.json");
+  const opencodeExists = existsSync5(join4(projectDir, ".opencode"));
+  if (opencodeExists) {
+    if (!existsSync5(opencodePkgPath)) {
+      issues.push({
+        level: "warning",
+        file: ".opencode/package.json",
+        message: "Missing \u2014 run 'agent-memory init --opencode' to wire up the plugin"
+      });
+    } else {
+      try {
+        const pkg = JSON.parse(readFileSync5(opencodePkgPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (!deps["@vuau/agent-memory"]) {
+          issues.push({
+            level: "warning",
+            file: ".opencode/package.json",
+            message: "@vuau/agent-memory not in dependencies \u2014 run 'agent-memory init --opencode'"
+          });
+        }
+      } catch {
+        issues.push({ level: "warning", file: ".opencode/package.json", message: "Invalid JSON" });
+      }
+    }
+    if (!existsSync5(opencodeJsonPath)) {
+      issues.push({
+        level: "warning",
+        file: "opencode.json",
+        message: "Missing \u2014 run 'agent-memory init --opencode' to wire up the plugin"
+      });
+    } else {
+      try {
+        const config = JSON.parse(readFileSync5(opencodeJsonPath, "utf-8"));
+        const plugins = config.plugin || [];
+        if (!plugins.includes("@vuau/agent-memory")) {
+          issues.push({
+            level: "warning",
+            file: "opencode.json",
+            message: "@vuau/agent-memory not in plugin array \u2014 run 'agent-memory init --opencode'"
+          });
+        }
+      } catch {
+        issues.push({ level: "warning", file: "opencode.json", message: "Invalid JSON" });
+      }
+    }
+  }
   return { ok: issues.filter((i) => i.level === "error").length === 0, issues };
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuau/agent-memory",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Structured AI memory for codebases — OpenCode plugin + scaffolding CLI",
   "type": "module",
   "main": "./dist/index.js",