@vuau/agent-memory 0.1.0 → 0.1.1

package/dist/bin/cli.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+// src/core/scaffold.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/types.ts
+var AGENTS_DIR = ".agents";
+var SPEC_DIR = ".agents/spec";
+var MEMORY_FILE = ".agents/MEMORY.md";
+var TASKS_FILE = ".agents/TASKS.md";
+var AGENTS_MD = "AGENTS.md";
+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");
+}
+var TEMPLATES_DIR = getTemplatesDir();
+function readTemplate(name) {
+  const templatePath = join(TEMPLATES_DIR, name);
+  return readFileSync(templatePath, "utf-8");
+}
+function applyVars(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function scaffold(projectDir, config = {}, force = false) {
+  const result = { created: [], skipped: [] };
+  const projectName = config.projectName || guessProjectName(projectDir);
+  const vars = { PROJECT_NAME: projectName };
+  const dirs = [
+    join(projectDir, AGENTS_DIR),
+    join(projectDir, SPEC_DIR)
+  ];
+  if (config.copilotInstructions !== false) {
+    dirs.push(join(projectDir, ".github"));
+  }
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  const files = [
+    { target: AGENTS_MD, template: "AGENTS.md" },
+    { target: MEMORY_FILE, template: "MEMORY.md" },
+    { target: TASKS_FILE, template: "TASKS.md" }
+  ];
+  if (config.copilotInstructions !== false) {
+    files.push({
+      target: COPILOT_INSTRUCTIONS,
+      template: "copilot-instructions.md"
+    });
+  }
+  for (const { target, template } of files) {
+    const targetPath = join(projectDir, target);
+    if (existsSync(targetPath) && !force) {
+      result.skipped.push(target);
+      continue;
+    }
+    const content = applyVars(readTemplate(template), vars);
+    writeFileSync(targetPath, content);
+    result.created.push(target);
+  }
+  const specKeep = join(projectDir, SPEC_DIR, ".gitkeep");
+  if (!existsSync(specKeep)) {
+    writeFileSync(specKeep, "");
+    result.created.push(`${SPEC_DIR}/.gitkeep`);
+  }
+  return result;
+}
+function guessProjectName(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) return pkg.name;
+    } catch {
+    }
+  }
+  return dir.split("/").pop() || "Project";
+}
+
+// src/core/doctor.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function doctor(projectDir) {
+  const issues = [];
+  const required = [
+    { file: AGENTS_MD, desc: "Root router file" },
+    { file: MEMORY_FILE, desc: "Long-term memory" },
+    { file: TASKS_FILE, desc: "Working memory" }
+  ];
+  for (const { file, desc } of required) {
+    const filePath = join2(projectDir, file);
+    if (!existsSync2(filePath)) {
+      issues.push({ level: "error", file, message: `Missing ${desc}` });
+    }
+  }
+  for (const dir of [AGENTS_DIR, SPEC_DIR]) {
+    if (!existsSync2(join2(projectDir, dir))) {
+      issues.push({ level: "error", file: dir, message: "Directory missing" });
+    }
+  }
+  const copilotPath = join2(projectDir, COPILOT_INSTRUCTIONS);
+  if (!existsSync2(copilotPath)) {
+    issues.push({
+      level: "warning",
+      file: COPILOT_INSTRUCTIONS,
+      message: "Copilot instructions missing \u2014 VSCode/GitHub Copilot won't have context"
+    });
+  }
+  const agentsPath = join2(projectDir, AGENTS_MD);
+  if (existsSync2(agentsPath)) {
+    const content = readFileSync2(agentsPath, "utf-8");
+    if (!content.includes(".agents/")) {
+      issues.push({
+        level: "warning",
+        file: AGENTS_MD,
+        message: "No references to .agents/ \u2014 agents may not find memory files"
+      });
+    }
+    if (content.split("\n").length > 150) {
+      issues.push({
+        level: "warning",
+        file: AGENTS_MD,
+        message: "Over 150 lines \u2014 consider keeping it concise as a router"
+      });
+    }
+  }
+  const memoryPath = join2(projectDir, MEMORY_FILE);
+  if (existsSync2(memoryPath)) {
+    const lines = readFileSync2(memoryPath, "utf-8").split("\n").length;
+    if (lines > 150) {
+      issues.push({
+        level: "warning",
+        file: MEMORY_FILE,
+        message: `${lines} lines \u2014 consider compressing or archiving old entries`
+      });
+    }
+  }
+  return { ok: issues.filter((i) => i.level === "error").length === 0, issues };
+}
+
+// bin/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function printUsage() {
+  console.log(`
+@vuau/agent-memory \u2014 Structured AI memory for codebases
+
+Usage:
+  agent-memory init [options]    Scaffold .agents/ structure
+  agent-memory doctor            Validate .agents/ structure
+  agent-memory help              Show this help
+
+Options (init):
+  --force                        Overwrite existing files
+  --name <name>                  Project name (default: from package.json)
+  --no-copilot                   Skip .github/copilot-instructions.md
+`);
+}
+function runInit() {
+  const force = args.includes("--force");
+  const noCopilot = args.includes("--no-copilot");
+  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
+  }, force);
+  if (result.created.length > 0) {
+    console.log("\nCreated:");
+    for (const f of result.created) {
+      console.log(`  \u2713 ${f}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log("\nSkipped (already exist):");
+    for (const f of result.skipped) {
+      console.log(`  - ${f}`);
+    }
+  }
+  if (result.created.length === 0 && result.skipped.length > 0) {
+    console.log("\nAll files already exist. Use --force to overwrite.");
+  }
+  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"] }');
+  console.log("");
+}
+function runDoctor() {
+  const cwd = process.cwd();
+  const result = doctor(cwd);
+  if (result.issues.length === 0) {
+    console.log("\u2713 All checks passed!");
+    return;
+  }
+  for (const issue of result.issues) {
+    const icon = issue.level === "error" ? "\u2717" : issue.level === "warning" ? "\u26A0" : "\u2139";
+    console.log(`  ${icon} [${issue.level}] ${issue.file}: ${issue.message}`);
+  }
+  console.log("");
+  if (result.ok) {
+    console.log("\u26A0 Passed with warnings. Run 'agent-memory init' to fix missing files.");
+  } else {
+    console.log("\u2717 Failed. Run 'agent-memory init' to create missing files.");
+    process.exit(1);
+  }
+}
+switch (command) {
+  case "init":
+    runInit();
+    break;
+  case "doctor":
+    runDoctor();
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case void 0:
+    printUsage();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+}

package/dist/index.js

@@ -0,0 +1,348 @@
+// src/opencode/plugin.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/core/scaffold.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/types.ts
+var AGENTS_DIR = ".agents";
+var SPEC_DIR = ".agents/spec";
+var MEMORY_FILE = ".agents/MEMORY.md";
+var TASKS_FILE = ".agents/TASKS.md";
+var AGENTS_MD = "AGENTS.md";
+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");
+}
+var TEMPLATES_DIR = getTemplatesDir();
+function readTemplate(name) {
+  const templatePath = join(TEMPLATES_DIR, name);
+  return readFileSync(templatePath, "utf-8");
+}
+function applyVars(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function scaffold(projectDir, config = {}, force = false) {
+  const result = { created: [], skipped: [] };
+  const projectName = config.projectName || guessProjectName(projectDir);
+  const vars = { PROJECT_NAME: projectName };
+  const dirs = [
+    join(projectDir, AGENTS_DIR),
+    join(projectDir, SPEC_DIR)
+  ];
+  if (config.copilotInstructions !== false) {
+    dirs.push(join(projectDir, ".github"));
+  }
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  const files = [
+    { target: AGENTS_MD, template: "AGENTS.md" },
+    { target: MEMORY_FILE, template: "MEMORY.md" },
+    { target: TASKS_FILE, template: "TASKS.md" }
+  ];
+  if (config.copilotInstructions !== false) {
+    files.push({
+      target: COPILOT_INSTRUCTIONS,
+      template: "copilot-instructions.md"
+    });
+  }
+  for (const { target, template } of files) {
+    const targetPath = join(projectDir, target);
+    if (existsSync(targetPath) && !force) {
+      result.skipped.push(target);
+      continue;
+    }
+    const content = applyVars(readTemplate(template), vars);
+    writeFileSync(targetPath, content);
+    result.created.push(target);
+  }
+  const specKeep = join(projectDir, SPEC_DIR, ".gitkeep");
+  if (!existsSync(specKeep)) {
+    writeFileSync(specKeep, "");
+    result.created.push(`${SPEC_DIR}/.gitkeep`);
+  }
+  return result;
+}
+function guessProjectName(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) return pkg.name;
+    } catch {
+    }
+  }
+  return dir.split("/").pop() || "Project";
+}
+
+// src/opencode/plugin.ts
+var MemoryLifecyclePlugin = async ({ client, directory }) => {
+  const memoryFile = resolve2(directory, MEMORY_FILE);
+  const tasksFile = resolve2(directory, TASKS_FILE);
+  const agentsFile = resolve2(directory, AGENTS_MD);
+  let editCount = 0;
+  let specFilesEdited = [];
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        const hasAgentsMd = existsSync2(agentsFile);
+        const hasMemory = existsSync2(memoryFile);
+        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"
+                }
+              });
+            }
+          } catch (err) {
+            await client.app.log({
+              body: {
+                service: "agent-memory",
+                level: "warn",
+                message: `Auto-scaffold failed: ${err}`
+              }
+            });
+          }
+        }
+        editCount = 0;
+        specFilesEdited = [];
+        await client.app.log({
+          body: {
+            service: "agent-memory",
+            level: "info",
+            message: `Memory: ${hasMemory}, Tasks: ${existsSync2(tasksFile)}`
+          }
+        });
+      }
+      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"
+              }
+            });
+          }
+        }
+      }
+    },
+    "tool.execute.after": async (input) => {
+      if (input.tool === "edit" || input.tool === "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);
+          }
+        }
+      }
+    }
+  };
+};
+
+// src/core/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function appendMemory(projectDir, entry) {
+  const filePath = join2(projectDir, MEMORY_FILE);
+  if (!existsSync3(filePath)) {
+    throw new Error(`${MEMORY_FILE} not found. Run 'agent-memory init' first.`);
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  const category = entry.category || "Decisions";
+  const line = `- ${entry.date}: ${entry.content}`;
+  const categoryHeader = `## ${category}`;
+  const headerIndex = content.indexOf(categoryHeader);
+  let updated;
+  if (headerIndex === -1) {
+    updated = content.trimEnd() + `
+
+${categoryHeader}
+${line}
+`;
+  } else {
+    const afterHeader = headerIndex + categoryHeader.length;
+    const nextHeaderIndex = content.indexOf("\n## ", afterHeader);
+    const insertAt = nextHeaderIndex === -1 ? content.length : nextHeaderIndex;
+    const categoryContent = content.slice(afterHeader, insertAt);
+    const lastLineEnd = afterHeader + categoryContent.trimEnd().length;
+    updated = content.slice(0, lastLineEnd) + "\n" + line + content.slice(lastLineEnd);
+  }
+  writeFileSync2(filePath, updated);
+}
+function readMemory(projectDir) {
+  const filePath = join2(projectDir, MEMORY_FILE);
+  if (!existsSync3(filePath)) return {};
+  const content = readFileSync3(filePath, "utf-8");
+  const categories = {};
+  let currentCategory = "_uncategorized";
+  for (const line of content.split("\n")) {
+    const headerMatch = line.match(/^## (.+)/);
+    if (headerMatch) {
+      currentCategory = headerMatch[1];
+      categories[currentCategory] = categories[currentCategory] || [];
+      continue;
+    }
+    if (line.startsWith("- ") && currentCategory) {
+      categories[currentCategory] = categories[currentCategory] || [];
+      categories[currentCategory].push(line.slice(2));
+    }
+  }
+  return categories;
+}
+
+// src/core/tasks.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+function readTasks(projectDir) {
+  const filePath = join3(projectDir, TASKS_FILE);
+  const result = {
+    in_progress: [],
+    up_next: [],
+    completed: []
+  };
+  if (!existsSync4(filePath)) return result;
+  const content = readFileSync4(filePath, "utf-8");
+  let currentSection = null;
+  for (const line of content.split("\n")) {
+    if (line.startsWith("## In Progress")) {
+      currentSection = "in_progress";
+      continue;
+    }
+    if (line.startsWith("## Up Next")) {
+      currentSection = "up_next";
+      continue;
+    }
+    if (line.startsWith("## Completed")) {
+      currentSection = "completed";
+      continue;
+    }
+    if (currentSection && line.startsWith("- ")) {
+      result[currentSection].push(line.slice(2));
+    }
+  }
+  return result;
+}
+function writeTasks(projectDir, tasks) {
+  const filePath = join3(projectDir, TASKS_FILE);
+  const content = `# Current Tasks
+
+Working memory for cross-session continuity. Update before ending a session.
+
+---
+
+## In Progress
+${tasks.in_progress.map((t) => `- ${t}`).join("\n") || ""}
+
+## Up Next
+${tasks.up_next.map((t) => `- ${t}`).join("\n") || ""}
+
+## Completed
+${tasks.completed.map((t) => `- ${t}`).join("\n") || ""}
+`;
+  writeFileSync3(filePath, content);
+}
+
+// src/core/doctor.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function doctor(projectDir) {
+  const issues = [];
+  const required = [
+    { file: AGENTS_MD, desc: "Root router file" },
+    { file: MEMORY_FILE, desc: "Long-term memory" },
+    { file: TASKS_FILE, desc: "Working memory" }
+  ];
+  for (const { file, desc } of required) {
+    const filePath = join4(projectDir, file);
+    if (!existsSync5(filePath)) {
+      issues.push({ level: "error", file, message: `Missing ${desc}` });
+    }
+  }
+  for (const dir of [AGENTS_DIR, SPEC_DIR]) {
+    if (!existsSync5(join4(projectDir, dir))) {
+      issues.push({ level: "error", file: dir, message: "Directory missing" });
+    }
+  }
+  const copilotPath = join4(projectDir, COPILOT_INSTRUCTIONS);
+  if (!existsSync5(copilotPath)) {
+    issues.push({
+      level: "warning",
+      file: COPILOT_INSTRUCTIONS,
+      message: "Copilot instructions missing \u2014 VSCode/GitHub Copilot won't have context"
+    });
+  }
+  const agentsPath = join4(projectDir, AGENTS_MD);
+  if (existsSync5(agentsPath)) {
+    const content = readFileSync5(agentsPath, "utf-8");
+    if (!content.includes(".agents/")) {
+      issues.push({
+        level: "warning",
+        file: AGENTS_MD,
+        message: "No references to .agents/ \u2014 agents may not find memory files"
+      });
+    }
+    if (content.split("\n").length > 150) {
+      issues.push({
+        level: "warning",
+        file: AGENTS_MD,
+        message: "Over 150 lines \u2014 consider keeping it concise as a router"
+      });
+    }
+  }
+  const memoryPath = join4(projectDir, MEMORY_FILE);
+  if (existsSync5(memoryPath)) {
+    const lines = readFileSync5(memoryPath, "utf-8").split("\n").length;
+    if (lines > 150) {
+      issues.push({
+        level: "warning",
+        file: MEMORY_FILE,
+        message: `${lines} lines \u2014 consider compressing or archiving old entries`
+      });
+    }
+  }
+  return { ok: issues.filter((i) => i.level === "error").length === 0, issues };
+}
+export {
+  AGENTS_DIR,
+  AGENTS_MD,
+  MemoryLifecyclePlugin as AgentMemoryPlugin,
+  COPILOT_INSTRUCTIONS,
+  MEMORY_FILE,
+  SPEC_DIR,
+  TASKS_FILE,
+  appendMemory,
+  doctor,
+  readMemory,
+  readTasks,
+  scaffold,
+  writeTasks
+};

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "@vuau/agent-memory",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Structured AI memory for codebases — OpenCode plugin + scaffolding CLI",
   "type": "module",
-  "main": "index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./index.ts"
+    ".": "./dist/index.js"
   },
   "bin": {
-    "agent-memory": "./bin/cli.ts"
+    "agent-memory": "dist/bin/cli.js"
   },
   "files": [
-    "index.ts",
-    "src/",
+    "dist/",
     "templates/",
-    "bin/",
     "docs/",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.3"
+  },
   "keywords": [
     "opencode",
     "opencode-plugin",
@@ -32,7 +38,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/vuau/agent-memory"
+    "url": "git+https://github.com/vuau/agent-memory.git"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.0.0"

package/bin/cli.ts

@@ -1,111 +0,0 @@
-#!/usr/bin/env node --experimental-strip-types --no-warnings
-/**
- * CLI entry point for @vuau/agent-memory
- *
- * Usage:
- *   npx @vuau/agent-memory init [--force] [--name <project-name>]
- *   npx @vuau/agent-memory doctor
- */
-
-import { scaffold } from "../src/core/scaffold.ts"
-import { doctor } from "../src/core/doctor.ts"
-
-const args = process.argv.slice(2)
-const command = args[0]
-
-function printUsage() {
-  console.log(`
-@vuau/agent-memory — Structured AI memory for codebases
-
-Usage:
-  agent-memory init [options]    Scaffold .agents/ structure
-  agent-memory doctor            Validate .agents/ structure
-  agent-memory help              Show this help
-
-Options (init):
-  --force                        Overwrite existing files
-  --name <name>                  Project name (default: from package.json)
-  --no-copilot                   Skip .github/copilot-instructions.md
-`)
-}
-
-function runInit() {
-  const force = args.includes("--force")
-  const noCopilot = args.includes("--no-copilot")
-  const nameIdx = args.indexOf("--name")
-  const projectName = nameIdx !== -1 ? args[nameIdx + 1] : undefined
-
-  const cwd = process.cwd()
-  console.log(`Initializing agent memory in ${cwd}...`)
-
-  const result = scaffold(cwd, {
-    projectName,
-    copilotInstructions: !noCopilot,
-  }, force)
-
-  if (result.created.length > 0) {
-    console.log("\nCreated:")
-    for (const f of result.created) {
-      console.log(`  ✓ ${f}`)
-    }
-  }
-
-  if (result.skipped.length > 0) {
-    console.log("\nSkipped (already exist):")
-    for (const f of result.skipped) {
-      console.log(`  - ${f}`)
-    }
-  }
-
-  if (result.created.length === 0 && result.skipped.length > 0) {
-    console.log("\nAll files already exist. Use --force to overwrite.")
-  }
-
-  console.log("\nNext steps:")
-  console.log("  1. Edit AGENTS.md — 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 → { \"plugin\": [\"@vuau/agent-memory\"] }")
-  console.log("")
-}
-
-function runDoctor() {
-  const cwd = process.cwd()
-  const result = doctor(cwd)
-
-  if (result.issues.length === 0) {
-    console.log("✓ All checks passed!")
-    return
-  }
-
-  for (const issue of result.issues) {
-    const icon = issue.level === "error" ? "✗" : issue.level === "warning" ? "⚠" : "ℹ"
-    console.log(`  ${icon} [${issue.level}] ${issue.file}: ${issue.message}`)
-  }
-
-  console.log("")
-  if (result.ok) {
-    console.log("⚠ Passed with warnings. Run 'agent-memory init' to fix missing files.")
-  } else {
-    console.log("✗ Failed. Run 'agent-memory init' to create missing files.")
-    process.exit(1)
-  }
-}
-
-switch (command) {
-  case "init":
-    runInit()
-    break
-  case "doctor":
-    runDoctor()
-    break
-  case "help":
-  case "--help":
-  case "-h":
-  case undefined:
-    printUsage()
-    break
-  default:
-    console.error(`Unknown command: ${command}`)
-    printUsage()
-    process.exit(1)
-}

package/index.ts

@@ -1,11 +0,0 @@
-/**
- * @vuau/agent-memory
- *
- * Structured AI memory for codebases.
- * OpenCode plugin entry point.
- */
-
-export { MemoryLifecyclePlugin as AgentMemoryPlugin } from "./src/opencode/plugin.ts"
-
-// Re-export core for programmatic use
-export * from "./src/core/index.ts"

package/src/core/doctor.ts

@@ -1,86 +0,0 @@
-/**
- * Doctor — validate .agents/ structure integrity.
- */
-
-import { existsSync, readFileSync } from "fs"
-import { join } from "path"
-import {
-  AGENTS_DIR,
-  SPEC_DIR,
-  MEMORY_FILE,
-  TASKS_FILE,
-  AGENTS_MD,
-  COPILOT_INSTRUCTIONS,
-  type DoctorResult,
-  type DoctorIssue,
-} from "./types.ts"
-
-export function doctor(projectDir: string): DoctorResult {
-  const issues: DoctorIssue[] = []
-
-  // Check required files
-  const required = [
-    { file: AGENTS_MD, desc: "Root router file" },
-    { file: MEMORY_FILE, desc: "Long-term memory" },
-    { file: TASKS_FILE, desc: "Working memory" },
-  ]
-
-  for (const { file, desc } of required) {
-    const filePath = join(projectDir, file)
-    if (!existsSync(filePath)) {
-      issues.push({ level: "error", file, message: `Missing ${desc}` })
-    }
-  }
-
-  // Check directories
-  for (const dir of [AGENTS_DIR, SPEC_DIR]) {
-    if (!existsSync(join(projectDir, dir))) {
-      issues.push({ level: "error", file: dir, message: "Directory missing" })
-    }
-  }
-
-  // Check optional files
-  const copilotPath = join(projectDir, COPILOT_INSTRUCTIONS)
-  if (!existsSync(copilotPath)) {
-    issues.push({
-      level: "warning",
-      file: COPILOT_INSTRUCTIONS,
-      message: "Copilot instructions missing — VSCode/GitHub Copilot won't have context",
-    })
-  }
-
-  // Validate AGENTS.md has documentation map
-  const agentsPath = join(projectDir, AGENTS_MD)
-  if (existsSync(agentsPath)) {
-    const content = readFileSync(agentsPath, "utf-8")
-    if (!content.includes(".agents/")) {
-      issues.push({
-        level: "warning",
-        file: AGENTS_MD,
-        message: "No references to .agents/ — agents may not find memory files",
-      })
-    }
-    if (content.split("\n").length > 150) {
-      issues.push({
-        level: "warning",
-        file: AGENTS_MD,
-        message: "Over 150 lines — consider keeping it concise as a router",
-      })
-    }
-  }
-
-  // Validate MEMORY.md line count
-  const memoryPath = join(projectDir, MEMORY_FILE)
-  if (existsSync(memoryPath)) {
-    const lines = readFileSync(memoryPath, "utf-8").split("\n").length
-    if (lines > 150) {
-      issues.push({
-        level: "warning",
-        file: MEMORY_FILE,
-        message: `${lines} lines — consider compressing or archiving old entries`,
-      })
-    }
-  }
-
-  return { ok: issues.filter((i) => i.level === "error").length === 0, issues }
-}

package/src/core/index.ts

@@ -1,5 +0,0 @@
-export { scaffold, type ScaffoldResult } from "./scaffold.ts"
-export { appendMemory, readMemory, type MemoryEntry } from "./memory.ts"
-export { readTasks, writeTasks, type TaskItem, type TaskStatus } from "./tasks.ts"
-export { doctor } from "./doctor.ts"
-export * from "./types.ts"

package/src/core/memory.ts

@@ -1,86 +0,0 @@
-/**
- * Memory — read/append operations for MEMORY.md
- */
-
-import { existsSync, readFileSync, writeFileSync } from "fs"
-import { join } from "path"
-import { MEMORY_FILE } from "./types.ts"
-
-export interface MemoryEntry {
-  date: string
-  content: string
-  category?: string
-}
-
-/**
- * Append a 1-line entry to MEMORY.md under a category.
- * Creates category header if it doesn't exist.
- */
-export function appendMemory(
-  projectDir: string,
-  entry: MemoryEntry
-): void {
-  const filePath = join(projectDir, MEMORY_FILE)
-  if (!existsSync(filePath)) {
-    throw new Error(`${MEMORY_FILE} not found. Run 'agent-memory init' first.`)
-  }
-
-  const content = readFileSync(filePath, "utf-8")
-  const category = entry.category || "Decisions"
-  const line = `- ${entry.date}: ${entry.content}`
-
-  // Find category header
-  const categoryHeader = `## ${category}`
-  const headerIndex = content.indexOf(categoryHeader)
-
-  let updated: string
-  if (headerIndex === -1) {
-    // Append new category at end
-    updated = content.trimEnd() + `\n\n${categoryHeader}\n${line}\n`
-  } else {
-    // Find next ## header or end of file
-    const afterHeader = headerIndex + categoryHeader.length
-    const nextHeaderIndex = content.indexOf("\n## ", afterHeader)
-    const insertAt = nextHeaderIndex === -1 ? content.length : nextHeaderIndex
-
-    // Find last non-empty line in category
-    const categoryContent = content.slice(afterHeader, insertAt)
-    const lastLineEnd = afterHeader + categoryContent.trimEnd().length
-
-    updated =
-      content.slice(0, lastLineEnd) +
-      "\n" + line +
-      content.slice(lastLineEnd)
-  }
-
-  writeFileSync(filePath, updated)
-}
-
-/**
- * Read all entries from MEMORY.md, parsed by category.
- */
-export function readMemory(
-  projectDir: string
-): Record<string, string[]> {
-  const filePath = join(projectDir, MEMORY_FILE)
-  if (!existsSync(filePath)) return {}
-
-  const content = readFileSync(filePath, "utf-8")
-  const categories: Record<string, string[]> = {}
-  let currentCategory = "_uncategorized"
-
-  for (const line of content.split("\n")) {
-    const headerMatch = line.match(/^## (.+)/)
-    if (headerMatch) {
-      currentCategory = headerMatch[1]
-      categories[currentCategory] = categories[currentCategory] || []
-      continue
-    }
-    if (line.startsWith("- ") && currentCategory) {
-      categories[currentCategory] = categories[currentCategory] || []
-      categories[currentCategory].push(line.slice(2))
-    }
-  }
-
-  return categories
-}

package/src/core/scaffold.ts

@@ -1,124 +0,0 @@
-/**
- * Scaffold — create .agents/ directory structure in a project.
- *
- * Idempotent: skips existing files unless force=true.
- */
-
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs"
-import { join, resolve, dirname } from "path"
-import { fileURLToPath } from "url"
-import {
-  AGENTS_DIR,
-  SPEC_DIR,
-  MEMORY_FILE,
-  TASKS_FILE,
-  AGENTS_MD,
-  COPILOT_INSTRUCTIONS,
-  type AgentMemoryConfig,
-} from "./types.ts"
-
-// Resolve templates dir relative to this file (works in both Bun and Node)
-function getTemplatesDir(): string {
-  // Try import.meta based resolution
-  try {
-    const thisDir = dirname(fileURLToPath(import.meta.url))
-    const candidate = resolve(thisDir, "../../templates")
-    if (existsSync(candidate)) return candidate
-  } catch {}
-  // Fallback: walk up from __dirname if available
-  const candidate2 = resolve(__dirname, "../../templates")
-  if (existsSync(candidate2)) return candidate2
-  throw new Error("Cannot locate templates directory")
-}
-
-const TEMPLATES_DIR = getTemplatesDir()
-
-export interface ScaffoldResult {
-  created: string[]
-  skipped: string[]
-}
-
-function readTemplate(name: string): string {
-  const templatePath = join(TEMPLATES_DIR, name)
-  return readFileSync(templatePath, "utf-8")
-}
-
-function applyVars(content: string, vars: Record<string, string>): string {
-  let result = content
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replaceAll(`{{${key}}}`, value)
-  }
-  return result
-}
-
-export function scaffold(
-  projectDir: string,
-  config: AgentMemoryConfig = {},
-  force = false
-): ScaffoldResult {
-  const result: ScaffoldResult = { created: [], skipped: [] }
-  const projectName = config.projectName || guessProjectName(projectDir)
-  const vars = { PROJECT_NAME: projectName }
-
-  // Ensure directories exist
-  const dirs = [
-    join(projectDir, AGENTS_DIR),
-    join(projectDir, SPEC_DIR),
-  ]
-  if (config.copilotInstructions !== false) {
-    dirs.push(join(projectDir, ".github"))
-  }
-  for (const dir of dirs) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true })
-    }
-  }
-
-  // Files to scaffold
-  const files: Array<{ target: string; template: string }> = [
-    { target: AGENTS_MD, template: "AGENTS.md" },
-    { target: MEMORY_FILE, template: "MEMORY.md" },
-    { target: TASKS_FILE, template: "TASKS.md" },
-  ]
-
-  if (config.copilotInstructions !== false) {
-    files.push({
-      target: COPILOT_INSTRUCTIONS,
-      template: "copilot-instructions.md",
-    })
-  }
-
-  // Write files
-  for (const { target, template } of files) {
-    const targetPath = join(projectDir, target)
-    if (existsSync(targetPath) && !force) {
-      result.skipped.push(target)
-      continue
-    }
-    const content = applyVars(readTemplate(template), vars)
-    writeFileSync(targetPath, content)
-    result.created.push(target)
-  }
-
-  // Create .gitkeep in spec/ if empty
-  const specKeep = join(projectDir, SPEC_DIR, ".gitkeep")
-  if (!existsSync(specKeep)) {
-    writeFileSync(specKeep, "")
-    result.created.push(`${SPEC_DIR}/.gitkeep`)
-  }
-
-  return result
-}
-
-function guessProjectName(dir: string): string {
-  // Try package.json
-  const pkgPath = join(dir, "package.json")
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
-      if (pkg.name) return pkg.name
-    } catch {}
-  }
-  // Fallback to directory name
-  return dir.split("/").pop() || "Project"
-}

package/src/core/tasks.ts

@@ -1,77 +0,0 @@
-/**
- * Tasks — read/update operations for TASKS.md
- */
-
-import { existsSync, readFileSync, writeFileSync } from "fs"
-import { join } from "path"
-import { TASKS_FILE } from "./types.ts"
-
-export type TaskStatus = "in_progress" | "up_next" | "completed"
-
-export interface TaskItem {
-  content: string
-  status: TaskStatus
-}
-
-/**
- * Read tasks grouped by status section.
- */
-export function readTasks(projectDir: string): Record<TaskStatus, string[]> {
-  const filePath = join(projectDir, TASKS_FILE)
-  const result: Record<TaskStatus, string[]> = {
-    in_progress: [],
-    up_next: [],
-    completed: [],
-  }
-
-  if (!existsSync(filePath)) return result
-
-  const content = readFileSync(filePath, "utf-8")
-  let currentSection: TaskStatus | null = null
-
-  for (const line of content.split("\n")) {
-    if (line.startsWith("## In Progress")) {
-      currentSection = "in_progress"
-      continue
-    }
-    if (line.startsWith("## Up Next")) {
-      currentSection = "up_next"
-      continue
-    }
-    if (line.startsWith("## Completed")) {
-      currentSection = "completed"
-      continue
-    }
-    if (currentSection && line.startsWith("- ")) {
-      result[currentSection].push(line.slice(2))
-    }
-  }
-
-  return result
-}
-
-/**
- * Write tasks back to TASKS.md, preserving header structure.
- */
-export function writeTasks(
-  projectDir: string,
-  tasks: Record<TaskStatus, string[]>
-): void {
-  const filePath = join(projectDir, TASKS_FILE)
-  const content = `# Current Tasks
-
-Working memory for cross-session continuity. Update before ending a session.
-
----
-
-## In Progress
-${tasks.in_progress.map((t) => `- ${t}`).join("\n") || ""}
-
-## Up Next
-${tasks.up_next.map((t) => `- ${t}`).join("\n") || ""}
-
-## Completed
-${tasks.completed.map((t) => `- ${t}`).join("\n") || ""}
-`
-  writeFileSync(filePath, content)
-}

package/src/core/types.ts

@@ -1,30 +0,0 @@
-/**
- * Core constants and types shared across all entry points.
- */
-
-export const AGENTS_DIR = ".agents"
-export const SPEC_DIR = ".agents/spec"
-export const MEMORY_FILE = ".agents/MEMORY.md"
-export const TASKS_FILE = ".agents/TASKS.md"
-export const AGENTS_MD = "AGENTS.md"
-export const COPILOT_INSTRUCTIONS = ".github/copilot-instructions.md"
-
-export interface AgentMemoryConfig {
-  /** Project name used in templates */
-  projectName?: string
-  /** Custom spec categories to scaffold */
-  specFiles?: string[]
-  /** Whether to create .github/copilot-instructions.md */
-  copilotInstructions?: boolean
-}
-
-export interface DoctorResult {
-  ok: boolean
-  issues: DoctorIssue[]
-}
-
-export interface DoctorIssue {
-  level: "error" | "warning" | "info"
-  file: string
-  message: string
-}

package/src/opencode/plugin.ts

@@ -1,97 +0,0 @@
-/**
- * OpenCode Plugin — Memory Lifecycle
- *
- * Hooks into session events to manage .agents/ structure:
- * - session.created → auto-scaffold if missing, log status
- * - session.idle → remind to update TASKS.md
- * - tool.execute.after → track file edits
- */
-
-import type { Plugin } from "@opencode-ai/plugin"
-import { existsSync, readFileSync } from "fs"
-import { resolve } from "path"
-import { scaffold } from "../core/scaffold.ts"
-import { MEMORY_FILE, TASKS_FILE, AGENTS_MD, SPEC_DIR } from "../core/types.ts"
-
-export const MemoryLifecyclePlugin: Plugin = async ({ client, directory }) => {
-  const memoryFile = resolve(directory, MEMORY_FILE)
-  const tasksFile = resolve(directory, TASKS_FILE)
-  const agentsFile = resolve(directory, AGENTS_MD)
-
-  let editCount = 0
-  let specFilesEdited: string[] = []
-
-  return {
-    event: async ({ event }) => {
-      if (event.type === "session.created") {
-        // Auto-scaffold .agents/ if AGENTS.md exists but .agents/ doesn't
-        const hasAgentsMd = existsSync(agentsFile)
-        const hasMemory = existsSync(memoryFile)
-
-        if (!hasMemory && hasAgentsMd) {
-          // Project has AGENTS.md but no .agents/ — scaffold memory files only
-          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",
-                },
-              })
-            }
-          } catch (err) {
-            await client.app.log({
-              body: {
-                service: "agent-memory",
-                level: "warn",
-                message: `Auto-scaffold failed: ${err}`,
-              },
-            })
-          }
-        }
-
-        // Reset session counters
-        editCount = 0
-        specFilesEdited = []
-
-        await client.app.log({
-          body: {
-            service: "agent-memory",
-            level: "info",
-            message: `Memory: ${hasMemory}, Tasks: ${existsSync(tasksFile)}`,
-          },
-        })
-      }
-
-      // Remind about TASKS.md on session idle if significant work was done
-      if (event.type === "session.idle" && editCount >= 3) {
-        if (existsSync(tasksFile)) {
-          const content = readFileSync(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",
-              },
-            })
-          }
-        }
-      }
-    },
-
-    "tool.execute.after": async (input) => {
-      if (input.tool === "edit" || input.tool === "write") {
-        editCount++
-        const filePath = (input as any).args?.filePath || ""
-        if (filePath.includes(SPEC_DIR)) {
-          const shortPath = filePath.split(SPEC_DIR + "/").pop() || filePath
-          if (!specFilesEdited.includes(shortPath)) {
-            specFilesEdited.push(shortPath)
-          }
-        }
-      }
-    },
-  }
-}