opencode-viking-memory 0.1.5

package/dist/cli.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+
+// 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";
+
+// src/services/jsonc.ts
+function stripJsoncComments(content) {
+  let result = "";
+  let i = 0;
+  let inString = false;
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+  while (i < content.length) {
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (!inSingleLineComment && !inMultiLineComment) {
+      if (char === '"') {
+        let backslashCount = 0;
+        let j = i - 1;
+        while (j >= 0 && content[j] === "\\") {
+          backslashCount++;
+          j--;
+        }
+        if (backslashCount % 2 === 0) {
+          inString = !inString;
+        }
+        result += char;
+        i++;
+        continue;
+      }
+    }
+    if (inString) {
+      result += char;
+      i++;
+      continue;
+    }
+    if (!inSingleLineComment && !inMultiLineComment) {
+      if (char === "/" && nextChar === "/") {
+        inSingleLineComment = true;
+        i += 2;
+        continue;
+      }
+      if (char === "/" && nextChar === "*") {
+        inMultiLineComment = true;
+        i += 2;
+        continue;
+      }
+    }
+    if (inSingleLineComment) {
+      if (char === `
+`) {
+        inSingleLineComment = false;
+        result += char;
+      }
+      i++;
+      continue;
+    }
+    if (inMultiLineComment) {
+      if (char === "*" && nextChar === "/") {
+        inMultiLineComment = false;
+        i += 2;
+        continue;
+      }
+      if (char === `
+`) {
+        result += char;
+      }
+      i++;
+      continue;
+    }
+    result += char;
+    i++;
+  }
+  return result.replace(/,\s*([}\]])/g, "$1");
+}
+
+// src/cli.ts
+var OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
+var OPENCODE_COMMAND_DIR = join(OPENCODE_CONFIG_DIR, "command");
+var OH_MY_OPENCODE_CONFIG = join(OPENCODE_CONFIG_DIR, "oh-my-opencode.json");
+var PLUGIN_NAME = "opencode-viking-memory@latest";
+var SUPERMEMORY_INIT_COMMAND = `---
+description: Initialize Supermemory with comprehensive codebase knowledge
+---
+
+# Initializing VikingMemory
+
+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 \`viking_memory\` tool for each distinct insight:
+
+\`\`\`
+viking_memory(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: \`viking_memory(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");
+    });
+  });
+}
+function findOpencodeConfig() {
+  const candidates = [
+    join(OPENCODE_CONFIG_DIR, "opencode.jsonc"),
+    join(OPENCODE_CONFIG_DIR, "opencode.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-viking-memory")) {
+      console.log("✓ Plugin already registered in config");
+      return true;
+    }
+    const jsonContent = stripJsoncComments(content);
+    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 to ${configPath}`);
+    return true;
+  } catch (err) {
+    console.error("✗ Failed to update config:", err);
+    return false;
+  }
+}
+function createNewConfig() {
+  const configPath = join(OPENCODE_CONFIG_DIR, "opencode.jsonc");
+  mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+  const config = `{
+  "plugin": ["${PLUGIN_NAME}"]
+}
+`;
+  writeFileSync(configPath, config);
+  console.log(`✓ Created ${configPath}`);
+  return true;
+}
+function createCommand() {
+  mkdirSync(OPENCODE_COMMAND_DIR, { recursive: true });
+  const commandPath = join(OPENCODE_COMMAND_DIR, "viking_memory-init.md");
+  writeFileSync(commandPath, SUPERMEMORY_INIT_COMMAND);
+  console.log(`✓ Created /viking_memory-init command`);
+  return true;
+}
+function isOhMyOpencodeInstalled() {
+  const configPath = findOpencodeConfig();
+  if (!configPath)
+    return false;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return content.includes("oh-my-opencode");
+  } catch {
+    return false;
+  }
+}
+function isAutoCompactAlreadyDisabled() {
+  if (!existsSync(OH_MY_OPENCODE_CONFIG))
+    return false;
+  try {
+    const content = readFileSync(OH_MY_OPENCODE_CONFIG, "utf-8");
+    const config = JSON.parse(content);
+    const disabledHooks = config.disabled_hooks;
+    return disabledHooks?.includes("anthropic-context-window-limit-recovery") ?? false;
+  } catch {
+    return false;
+  }
+}
+function disableAutoCompactHook() {
+  try {
+    let config = {};
+    if (existsSync(OH_MY_OPENCODE_CONFIG)) {
+      const content = readFileSync(OH_MY_OPENCODE_CONFIG, "utf-8");
+      config = JSON.parse(content);
+    }
+    const disabledHooks = config.disabled_hooks || [];
+    if (!disabledHooks.includes("anthropic-context-window-limit-recovery")) {
+      disabledHooks.push("anthropic-context-window-limit-recovery");
+    }
+    config.disabled_hooks = disabledHooks;
+    writeFileSync(OH_MY_OPENCODE_CONFIG, JSON.stringify(config, null, 2));
+    console.log(`✓ Disabled anthropic-context-window-limit-recovery hook in oh-my-opencode.json`);
+    return true;
+  } catch (err) {
+    console.error("✗ Failed to update oh-my-opencode.json:", err);
+    return false;
+  }
+}
+async function install(options) {
+  console.log(`
+\uD83E\uDDE0 opencode-viking-memory installer
+`);
+  const rl = options.tui ? createReadline() : null;
+  console.log("Step 1: Register plugin in OpenCode config");
+  const configPath = findOpencodeConfig();
+  if (configPath) {
+    if (options.tui) {
+      const shouldModify = await confirm(rl, `Add plugin to ${configPath}?`);
+      if (!shouldModify) {
+        console.log("Skipped.");
+      } else {
+        addPluginToConfig(configPath);
+      }
+    } else {
+      addPluginToConfig(configPath);
+    }
+  } else {
+    if (options.tui) {
+      const shouldCreate = await confirm(rl, "No OpenCode config found. Create one?");
+      if (!shouldCreate) {
+        console.log("Skipped.");
+      } else {
+        createNewConfig();
+      }
+    } else {
+      createNewConfig();
+    }
+  }
+  console.log(`
+Step 2: Create /viking_memory-init command`);
+  if (options.tui) {
+    const shouldCreate = await confirm(rl, "Add /viking_memory-init command?");
+    if (!shouldCreate) {
+      console.log("Skipped.");
+    } else {
+      createCommand();
+    }
+  } else {
+    createCommand();
+  }
+  if (isOhMyOpencodeInstalled()) {
+    console.log(`
+Step 3: Configure Oh My OpenCode`);
+    console.log("Detected Oh My OpenCode plugin.");
+    console.log("VikingMemory handles context compaction, so the built-in context-window-limit-recovery hook should be disabled.");
+    if (isAutoCompactAlreadyDisabled()) {
+      console.log("✓ anthropic-context-window-limit-recovery hook already disabled");
+    } else {
+      if (options.tui) {
+        const shouldDisable = await confirm(rl, "Disable anthropic-context-window-limit-recovery hook to let VikingMemory handle context?");
+        if (!shouldDisable) {
+          console.log("Skipped.");
+        } else {
+          disableAutoCompactHook();
+        }
+      } else if (options.disableAutoCompact) {
+        disableAutoCompactHook();
+      } else {
+        console.log("Skipped. Use --disable-context-recovery to disable the hook in non-interactive mode.");
+      }
+    }
+  }
+  console.log(`
+` + "─".repeat(50));
+  console.log(`
+\uD83D\uDD11 Final step: Set your API key
+`);
+  console.log("Get your API key from: https://console.volcengine.com/knowledgebase/");
+  console.log(`
+Then add to your shell profile:
+`);
+  console.log('  export VIKING_MEMORY_API_KEY="..."');
+  console.log(`
+Or create ~/.config/opencode/viking_memory.jsonc:
+`);
+  console.log('  { "apiKey": "..." }');
+  console.log(`
+` + "─".repeat(50));
+  console.log(`
+✓ Setup complete! Restart OpenCode to activate.
+`);
+  if (rl)
+    rl.close();
+  return 0;
+}
+function printHelp() {
+  console.log(`
+opencode-viking-memory - Persistent memory for OpenCode agents
+
+Commands:
+  install                    Install and configure the plugin
+    --no-tui                 Run in non-interactive mode (for LLM agents)
+    --disable-context-recovery   Disable Oh My OpenCode's context-window-limit-recovery hook (use with --no-tui)
+
+Examples:
+  bunx opencode-viking-memory@latest install
+  bunx opencode-viking-memory@latest install --no-tui
+  bunx opencode-viking-memory@latest install --no-tui --disable-context-recovery
+`);
+}
+var args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+  printHelp();
+  process.exit(0);
+}
+if (args[0] === "install") {
+  const noTui = args.includes("--no-tui");
+  const disableAutoCompact = args.includes("--disable-context-recovery");
+  install({ tui: !noTui, disableAutoCompact }).then((code) => process.exit(code));
+} else if (args[0] === "setup") {
+  console.log(`Note: 'setup' is deprecated. Use 'install' instead.
+`);
+  const noTui = args.includes("--no-tui");
+  const disableAutoCompact = args.includes("--disable-context-recovery");
+  install({ tui: !noTui, disableAutoCompact }).then((code) => process.exit(code));
+} else {
+  console.error(`Unknown command: ${args[0]}`);
+  printHelp();
+  process.exit(1);
+}

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export declare const VIKING_MEMORY_API_KEY: string | undefined;
+export declare const VIKING_MEMORY_RESOURCE_ID: string | undefined;
+export declare const CONFIG: {
+    similarityThreshold: number;
+    maxMemories: number;
+    maxProjectMemories: number;
+    maxProfileItems: number;
+    injectProfile: boolean;
+    containerTagPrefix: string;
+    filterPrompt: string;
+    keywordPatterns: 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":"AAgFA,eAAO,MAAM,qBAAqB,oBAAyD,CAAC;AAC5F,eAAO,MAAM,yBAAyB,oBAAiE,CAAA;AAEvG,eAAO,MAAM,MAAM;;;;;;;;;CAYlB,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 VikingMemoryPlugin: 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;AAsC/D,eAAO,MAAM,kBAAkB,EAAE,MAwahC,CAAC"}