@vuau/agent-memory 0.1.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,444 @@
+// 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`);
+  }
+  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)) {
+    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`
+      });
+    }
+  }
+  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 {
+  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.2.0",
   "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"