opencode-supermemory 0.1.0

package/README.md

@@ -0,0 +1,162 @@
+# opencode-supermemory
+
+OpenCode plugin for persistent memory using [Supermemory](https://supermemory.ai).
+
+## Installation
+
+```bash
+npx opencode-supermemory setup
+```
+
+Interactive wizard that:
+1. Installs plugin globally
+2. Creates `/supermemory-init` command
+3. Adds plugin to OpenCode config
+
+Then set your API key:
+
+```bash
+export SUPERMEMORY_API_KEY="your-api-key"  # from console.supermemory.ai
+```
+
+## Features
+
+### Context Injection
+
+On first message, injects:
+- User profile (cross-project preferences)
+- Project memories (all project knowledge)
+- Relevant user memories (semantic search)
+
+```
+[SUPERMEMORY]
+
+User Profile:
+- Prefers concise responses
+- Expert in TypeScript
+
+Project Knowledge:
+- [100%] Uses Bun, not Node.js
+- [100%] Build: bun run build
+
+Relevant Memories:
+- [82%] Build fails if .env.local missing
+```
+
+### Keyword Detection
+
+Say "remember", "save this", "don't forget" etc. and the agent auto-saves to memory.
+
+```
+You: "Remember that this project uses bun"
+Agent: [saves to project memory]
+```
+
+### Codebase Indexing
+
+Run `/supermemory-init` to explore and memorize your codebase structure, patterns, and conventions.
+
+### Preemptive Compaction
+
+When context hits 80% capacity:
+1. Triggers OpenCode's summarization
+2. Injects project memories into summary context
+3. Saves session summary as a memory
+
+This preserves conversation context across compaction events.
+
+### Privacy
+
+```
+API key is <private>sk-abc123</private>
+```
+
+Content in `<private>` tags is never stored.
+
+## Tool Usage
+
+The `supermemory` tool is available to the agent:
+
+| Mode | Args | Description |
+|------|------|-------------|
+| `add` | `content`, `type?`, `scope?` | Store memory |
+| `search` | `query`, `scope?` | Search memories |
+| `profile` | `query?` | View user profile |
+| `list` | `scope?`, `limit?` | List memories |
+| `forget` | `memoryId`, `scope?` | Delete memory |
+
+**Scopes:** `user` (cross-project), `project` (default)
+
+**Types:** `project-config`, `architecture`, `error-solution`, `preference`, `learned-pattern`, `conversation`
+
+## Memory Scoping
+
+| Scope | Tag | Persists |
+|-------|-----|----------|
+| User | `opencode_user_{sha256(git email)}` | All projects |
+| Project | `opencode_project_{sha256(directory)}` | This project |
+
+## Configuration
+
+Create `~/.config/opencode/supermemory.jsonc`:
+
+```jsonc
+{
+  // API key (can also use SUPERMEMORY_API_KEY env var)
+  "apiKey": "sm_...",
+  
+  // Min similarity for memory retrieval (0-1)
+  "similarityThreshold": 0.6,
+  
+  // Max memories injected per request
+  "maxMemories": 5,
+  
+  // Max project memories listed
+  "maxProjectMemories": 10,
+  
+  // Max profile facts injected
+  "maxProfileItems": 5,
+  
+  // Include user profile in context
+  "injectProfile": true,
+  
+  // Prefix for container tags
+  "containerTagPrefix": "opencode"
+}
+```
+
+All fields optional. Env var `SUPERMEMORY_API_KEY` takes precedence over config file.
+
+API timeout: 5s
+
+## Hooks
+
+Registered in `package.json`:
+- `chat.message` - Context injection on first message, keyword detection
+- `event` - Compaction monitoring and summary capture
+
+## Development
+
+```bash
+bun install
+bun run build
+bun run typecheck
+```
+
+Local install:
+
+```jsonc
+{
+  "plugin": ["file:///path/to/opencode-supermemory"]
+}
+```
+
+## Logs
+
+```bash
+tail -f ~/.opencode-supermemory.log
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.ts
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import * as readline from "node:readline";
+var OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
+var OPENCODE_COMMAND_DIR = join(OPENCODE_CONFIG_DIR, "command");
+var PLUGIN_NAME = "opencode-supermemory@latest";
+var SUPERMEMORY_INIT_COMMAND = `---
+description: Initialize Supermemory with comprehensive codebase knowledge
+---
+
+# Initializing Supermemory
+
+You are initializing persistent memory for this codebase. This is not just data collection - you're building context that will make you significantly more effective across all future sessions.
+
+## Understanding Context
+
+You are a **stateful** coding agent. Users expect to work with you over extended periods - potentially the entire lifecycle of a project. Your memory is how you get better over time and maintain continuity.
+
+## What to Remember
+
+### 1. Procedures (Rules & Workflows)
+Explicit rules that should always be followed:
+- "Never commit directly to main - always use feature branches"
+- "Always run lint before tests"
+- "Use conventional commits format"
+
+### 2. Preferences (Style & Conventions)  
+Project and user coding style:
+- "Prefer functional components over class components"
+- "Use early returns instead of nested conditionals"
+- "Always add JSDoc to exported functions"
+
+### 3. Architecture & Context
+How the codebase works and why:
+- "Auth system was refactored in v2.0 - old patterns deprecated"
+- "The monorepo used to have 3 modules before consolidation"
+- "This pagination bug was fixed before - similar to PR #234"
+
+## Memory Scopes
+
+**Project-scoped** (\`scope: "project"\`):
+- Build/test/lint commands
+- Architecture and key directories
+- Team conventions specific to this codebase
+- Technology stack and framework choices
+- Known issues and their solutions
+
+**User-scoped** (\`scope: "user"\`):
+- Personal coding preferences across all projects
+- Communication style preferences
+- General workflow habits
+
+## Research Approach
+
+This is a **deep research** initialization. Take your time and be thorough (~50+ tool calls). The goal is to genuinely understand the project, not just collect surface-level facts.
+
+**What to uncover:**
+- Tech stack and dependencies (explicit and implicit)
+- Project structure and architecture
+- Build/test/deploy commands and workflows
+- Contributors & team dynamics (who works on what?)
+- Commit conventions and branching strategy
+- Code evolution (major refactors, architecture changes)
+- Pain points (areas with lots of bug fixes)
+- Implicit conventions not documented anywhere
+
+## Research Techniques
+
+### File-based
+- README.md, CONTRIBUTING.md, AGENTS.md, CLAUDE.md
+- Package manifests (package.json, Cargo.toml, pyproject.toml, go.mod)
+- Config files (.eslintrc, tsconfig.json, .prettierrc)
+- CI/CD configs (.github/workflows/)
+
+### Git-based
+- \`git log --oneline -20\` - Recent history
+- \`git branch -a\` - Branching strategy  
+- \`git log --format="%s" -50\` - Commit conventions
+- \`git shortlog -sn --all | head -10\` - Main contributors
+
+### Explore Agent
+Fire parallel explore queries for broad understanding:
+\`\`\`
+Task(explore, "What is the tech stack and key dependencies?")
+Task(explore, "What is the project structure? Key directories?")
+Task(explore, "How do you build, test, and run this project?")
+Task(explore, "What are the main architectural patterns?")
+Task(explore, "What conventions or patterns are used?")
+\`\`\`
+
+## How to Do Thorough Research
+
+**Don't just collect data - analyze and cross-reference.**
+
+Bad (shallow):
+- Run commands, copy output
+- List facts without understanding
+
+Good (thorough):
+- Cross-reference findings (if inconsistent, dig deeper)
+- Resolve ambiguities (don't leave questions unanswered)
+- Read actual file content, not just names
+- Look for patterns (what do commits tell you about workflow?)
+- Think like a new team member - what would you want to know?
+
+## Saving Memories
+
+Use the \`supermemory\` tool for each distinct insight:
+
+\`\`\`
+supermemory(mode: "add", content: "...", type: "...", scope: "project")
+\`\`\`
+
+**Types:**
+- \`project-config\` - tech stack, commands, tooling
+- \`architecture\` - codebase structure, key components, data flow
+- \`learned-pattern\` - conventions specific to this codebase
+- \`error-solution\` - known issues and their fixes
+- \`preference\` - coding style preferences (use with user scope)
+
+**Guidelines:**
+- Save each distinct insight as a separate memory
+- Be concise but include enough context to be useful
+- Include the "why" not just the "what" when relevant
+- Update memories incrementally as you research (don't wait until the end)
+
+**Good memories:**
+- "Uses Bun runtime and package manager. Commands: bun install, bun run dev, bun test"
+- "API routes in src/routes/, handlers in src/handlers/. Hono framework."
+- "Auth uses Redis sessions, not JWT. Implementation in src/lib/auth.ts"
+- "Never use \`any\` type - strict TypeScript. Use \`unknown\` and narrow."
+- "Database migrations must be backward compatible - we do rolling deploys"
+
+## Upfront Questions
+
+Before diving in, ask:
+1. "Any specific rules I should always follow?"
+2. "Preferences for how I communicate? (terse/detailed)"
+
+## Reflection Phase
+
+Before finishing, reflect:
+1. **Completeness**: Did you cover commands, architecture, conventions, gotchas?
+2. **Quality**: Are memories concise and searchable?
+3. **Scope**: Did you correctly separate project vs user knowledge?
+
+Then ask: "I've initialized memory with X insights. Want me to continue refining, or is this good?"
+
+## Your Task
+
+1. Ask upfront questions (research depth, rules, preferences)
+2. Check existing memories: \`supermemory(mode: "list", scope: "project")\`
+3. Research based on chosen depth
+4. Save memories incrementally as you discover insights
+5. Reflect and verify completeness
+6. Summarize what was learned and ask if user wants refinement
+`;
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function confirm(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n) `, (answer) => {
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function installPlugin() {
+  const { execSync } = await import("node:child_process");
+  let pm = "npm";
+  try {
+    execSync("bun --version", { stdio: "ignore" });
+    pm = "bun";
+  } catch {
+    try {
+      execSync("pnpm --version", { stdio: "ignore" });
+      pm = "pnpm";
+    } catch {}
+  }
+  console.log(`Installing ${PLUGIN_NAME} with ${pm}...`);
+  try {
+    execSync(`${pm} install -g ${PLUGIN_NAME}`, { stdio: "inherit" });
+    return true;
+  } catch {
+    console.error("Failed to install plugin globally.");
+    return false;
+  }
+}
+function createCommand() {
+  mkdirSync(OPENCODE_COMMAND_DIR, { recursive: true });
+  const commandPath = join(OPENCODE_COMMAND_DIR, "supermemory-init.md");
+  if (existsSync(commandPath)) {
+    console.log(`Command already exists at ${commandPath}`);
+    return true;
+  }
+  writeFileSync(commandPath, SUPERMEMORY_INIT_COMMAND);
+  console.log(`Created /supermemory-init command`);
+  return true;
+}
+function findOpencodeConfig() {
+  const candidates = [
+    join(OPENCODE_CONFIG_DIR, "config.jsonc"),
+    join(OPENCODE_CONFIG_DIR, "config.json")
+  ];
+  for (const path of candidates) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function addPluginToConfig(configPath) {
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    if (content.includes("opencode-supermemory")) {
+      console.log("Plugin already in config");
+      return true;
+    }
+    const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    let config;
+    try {
+      config = JSON.parse(jsonContent);
+    } catch {
+      console.error("Failed to parse config file");
+      return false;
+    }
+    const plugins = config.plugin || [];
+    plugins.push(PLUGIN_NAME);
+    config.plugin = plugins;
+    if (configPath.endsWith(".jsonc")) {
+      if (content.includes('"plugin"')) {
+        const newContent = content.replace(/("plugin"\s*:\s*\[)([^\]]*?)(\])/, (_match, start, middle, end) => {
+          const trimmed = middle.trim();
+          if (trimmed === "") {
+            return `${start}
+    "${PLUGIN_NAME}"
+  ${end}`;
+          }
+          return `${start}${middle.trimEnd()},
+    "${PLUGIN_NAME}"
+  ${end}`;
+        });
+        writeFileSync(configPath, newContent);
+      } else {
+        const newContent = content.replace(/^(\s*\{)/, `$1
+  "plugin": ["${PLUGIN_NAME}"],`);
+        writeFileSync(configPath, newContent);
+      }
+    } else {
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    console.log(`Added ${PLUGIN_NAME} to ${configPath}`);
+    return true;
+  } catch (err) {
+    console.error("Failed to update config:", err);
+    return false;
+  }
+}
+function createNewConfig() {
+  const configPath = join(OPENCODE_CONFIG_DIR, "config.jsonc");
+  mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+  const config = {
+    plugin: [PLUGIN_NAME]
+  };
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`Created ${configPath} with plugin registered`);
+  return true;
+}
+async function setup() {
+  const rl = createReadline();
+  console.log(`
+opencode-supermemory setup
+`);
+  const shouldInstall = await confirm(rl, "Install opencode-supermemory globally?");
+  if (!shouldInstall) {
+    console.log("Aborted.");
+    rl.close();
+    process.exit(0);
+  }
+  const installed = await installPlugin();
+  if (!installed) {
+    console.log("Aborted.");
+    rl.close();
+    process.exit(1);
+  }
+  const shouldCreateCommand = await confirm(rl, "Add /supermemory-init command?");
+  if (!shouldCreateCommand) {
+    console.log("Aborted.");
+    rl.close();
+    process.exit(0);
+  }
+  createCommand();
+  const configPath = findOpencodeConfig();
+  if (configPath) {
+    const shouldModifyConfig = await confirm(rl, `Add plugin to ${configPath}?`);
+    if (!shouldModifyConfig) {
+      console.log("Aborted.");
+      rl.close();
+      process.exit(0);
+    }
+    addPluginToConfig(configPath);
+  } else {
+    const shouldCreateConfig = await confirm(rl, "No OpenCode config found. Create one?");
+    if (!shouldCreateConfig) {
+      console.log("Aborted.");
+      rl.close();
+      process.exit(0);
+    }
+    createNewConfig();
+  }
+  console.log(`
+Setup complete!`);
+  console.log("Set SUPERMEMORY_API_KEY and restart OpenCode.");
+  rl.close();
+}
+function printHelp() {
+  console.log(`
+opencode-supermemory CLI
+
+Commands:
+  setup    Interactive setup wizard
+
+Examples:
+  npx opencode-supermemory setup
+  bunx opencode-supermemory setup
+`);
+}
+var args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "help" || args[0] === "--help") {
+  printHelp();
+  process.exit(0);
+}
+if (args[0] === "setup") {
+  setup();
+} else {
+  console.error(`Unknown command: ${args.join(" ")}`);
+  printHelp();
+  process.exit(1);
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export declare const SUPERMEMORY_API_KEY: string | undefined;
+export declare const CONFIG: {
+    similarityThreshold: number;
+    maxMemories: number;
+    maxProjectMemories: number;
+    maxProfileItems: number;
+    injectProfile: boolean;
+    containerTagPrefix: string;
+};
+export declare function isConfigured(): boolean;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAiDA,eAAO,MAAM,mBAAmB,oBAAuD,CAAC;AAExF,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const SupermemoryPlugin: Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAuC/D,eAAO,MAAM,iBAAiB,EAAE,MA6Y/B,CAAC"}