@csuwl/opencode-memory-plugin 1.0.0

package/bin/install.js

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+
+/**
+ * OpenCode Memory Plugin - Installation Script
+ * This script runs automatically on npm install or can be run manually
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Colors for output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  reset: '\x1b[0m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE;
+}
+
+// Paths
+const HOME = getHomeDir();
+const MEMORY_ROOT = path.join(HOME, '.opencode');
+const MEMORY_DIR = path.join(MEMORY_ROOT, 'memory');
+const DAILY_DIR = path.join(MEMORY_DIR, 'daily');
+const OPENCORE_CONFIG_DIR = path.join(HOME, '.config', 'opencode');
+const OPENCORE_CONFIG = path.join(OPENCORE_CONFIG_DIR, 'opencode.json');
+
+// Get the directory where this script is located
+const SCRIPT_DIR = __dirname;
+const PLUGIN_DIR = path.dirname(SCRIPT_DIR);
+
+// Required files
+const MEMORY_FILES = [
+  'SOUL.md',
+  'AGENTS.md',
+  'USER.md',
+  'IDENTITY.md',
+  'TOOLS.md',
+  'MEMORY.md',
+  'HEARTBEAT.md',
+  'BOOT.md',
+  'BOOTSTRAP.md'
+];
+
+/**
+ * Ensure directory exists
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * Copy file if it doesn't exist
+ */
+function copyFileIfNotExists(source, dest) {
+  if (fs.existsSync(dest)) {
+    log(`  ⊙ Exists: ${path.basename(dest)} (skipped)`, 'blue');
+    return false;
+  }
+
+  if (fs.existsSync(source)) {
+    fs.copyFileSync(source, dest);
+    log(`  ✓ Created: ${path.basename(dest)}`, 'green');
+    return true;
+  } else {
+    log(`  ✗ Missing: ${source}`, 'red');
+    return false;
+  }
+}
+
+/**
+ * Create memory configuration
+ */
+function createMemoryConfig() {
+  const configPath = path.join(MEMORY_DIR, 'memory-config.json');
+  
+  if (fs.existsSync(configPath)) {
+    log('  ⊙ Configuration already exists', 'blue');
+    return;
+  }
+
+  const config = {
+    version: '1.0.0',
+    auto_save: true,
+    auto_save_threshold_tokens: 1000,
+    vector_search: {
+      enabled: true,
+      hybrid: true,
+      rebuild_interval_hours: 24
+    },
+    consolidation: {
+      enabled: true,
+      run_daily: true,
+      run_hour: 23,
+      archive_days: 30,
+      delete_days: 90
+    },
+    git_backup: {
+      enabled: false,
+      auto_commit: false,
+      auto_push: false
+    },
+    retention: {
+      max_daily_files: 30,
+      max_entries_per_file: 100,
+      chunk_size: 400,
+      chunk_overlap: 80
+    }
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  log('  ✓ Configuration created', 'green');
+}
+
+/**
+ * Create or update OpenCode configuration
+ */
+function updateOpenCodeConfig() {
+  ensureDir(OPENCORE_CONFIG_DIR);
+
+  // Backup existing config
+  if (fs.existsSync(OPENCORE_CONFIG)) {
+    const backup = `${OPENCORE_CONFIG}.backup.${new Date().toISOString().replace(/[:.]/g, '').slice(0, 15)}`;
+    fs.copyFileSync(OPENCORE_CONFIG, backup);
+    log('  ⊙ Backed up existing config', 'blue');
+  }
+
+  let config = {};
+
+  // Try to read existing config
+  try {
+    if (fs.existsSync(OPENCORE_CONFIG)) {
+      config = JSON.parse(fs.readFileSync(OPENCORE_CONFIG, 'utf8'));
+    }
+  } catch (e) {
+    // Config is invalid, start fresh
+    log('  ⚠ Existing config is invalid, creating new one', 'yellow');
+  }
+
+  // Add instructions if not present
+  if (!config.instructions) {
+    config.instructions = [
+      '~/.opencode/memory/SOUL.md',
+      '~/.opencode/memory/AGENTS.md',
+      '~/.opencode/memory/USER.md',
+      '~/.opencode/memory/IDENTITY.md',
+      '~/.opencode/memory/TOOLS.md',
+      '~/.opencode/memory/MEMORY.md'
+    ];
+    log('  ✓ Added memory instructions', 'green');
+  }
+
+  // Add agents if not present
+  if (!config.agent) {
+    config.agent = {};
+  }
+
+  if (!config.agent['memory-automation']) {
+    config.agent['memory-automation'] = {
+      description: 'Automatically saves important information to memory',
+      mode: 'subagent',
+      tools: {
+        memory_write: true,
+        memory_read: true,
+        memory_search: true,
+        vector_memory_search: true
+      },
+      permission: {
+        memory_write: 'allow',
+        memory_read: 'allow',
+        memory_search: 'allow',
+        vector_memory_search: 'allow'
+      }
+    };
+    log('  ✓ Added memory-automation agent', 'green');
+  }
+
+  if (!config.agent['memory-consolidate']) {
+    config.agent['memory-consolidate'] = {
+      description: 'Consolidates daily logs into long-term memory',
+      mode: 'subagent',
+      tools: {
+        memory_write: true,
+        memory_read: true,
+        memory_search: true,
+        vector_memory_search: true,
+        list_daily: true,
+        rebuild_index: true
+      },
+      permission: {
+        memory_write: 'allow',
+        memory_read: 'allow',
+        memory_search: 'allow',
+        vector_memory_search: 'allow',
+        list_daily: 'allow',
+        rebuild_index: 'allow'
+      }
+    };
+    log('  ✓ Added memory-consolidate agent', 'green');
+  }
+
+  // Add tools if not present
+  if (!config.tools) {
+    config.tools = {};
+  }
+
+  const tools = ['memory_write', 'memory_read', 'memory_search', 'vector_memory_search', 
+                'list_daily', 'init_daily', 'rebuild_index', 'index_status'];
+  let toolsAdded = false;
+  
+  tools.forEach(tool => {
+    if (config.tools[tool] === undefined) {
+      config.tools[tool] = true;
+      toolsAdded = true;
+    }
+  });
+
+  if (toolsAdded) {
+    log('  ✓ Added memory tools', 'green');
+  }
+
+  // Write config
+  fs.writeFileSync(OPENCORE_CONFIG, JSON.stringify(config, null, 2));
+  log('  ✓ OpenCode configuration updated', 'green');
+}
+
+/**
+ * Initialize today's daily log
+ */
+function initDailyLog() {
+  const today = new Date().toISOString().split('T')[0];
+  const dailyFile = path.join(DAILY_DIR, `${today}.md`);
+
+  if (fs.existsSync(dailyFile)) {
+    log(`  ⊙ Daily log already exists: ${today}.md`, 'blue');
+    return;
+  }
+
+  const content = `# Daily Memory Log - ${today}
+
+*Session starts: ${new Date().toISOString()}*
+
+## Notes
+
+## Tasks
+
+## Learnings
+
+---
+`;
+
+  fs.writeFileSync(dailyFile, content);
+  log(`  ✓ Created daily log: ${today}.md`, 'green');
+}
+
+/**
+ * Main installation function
+ */
+function install() {
+  log('', 'blue');
+  log('═════════════════════════════════════════════════════════════════', 'blue');
+  log('  OpenCode Memory Plugin - Installation', 'blue');
+  log('═════════════════════════════════════════════════════════════════', 'blue');
+  log('', 'blue');
+
+  // Step 1: Create directory structure
+  log('Step 1/5: Creating memory directory structure...', 'yellow');
+  ensureDir(MEMORY_DIR);
+  ensureDir(DAILY_DIR);
+  ensureDir(path.join(MEMORY_DIR, 'archive', 'weekly'));
+  ensureDir(path.join(MEMORY_DIR, 'archive', 'monthly'));
+  log('  ✓ Directory structure created', 'green');
+  log('', 'reset');
+
+  // Step 2: Copy memory files
+  log('Step 2/5: Copying memory files...', 'yellow');
+  MEMORY_FILES.forEach(file => {
+    const source = path.join(PLUGIN_DIR, 'memory', file);
+    const dest = path.join(MEMORY_DIR, file);
+    copyFileIfNotExists(source, dest);
+  });
+  log('  ✓ Memory files copied', 'green');
+  log('', 'reset');
+
+  // Step 3: Create memory configuration
+  log('Step 3/5: Creating memory configuration...', 'yellow');
+  createMemoryConfig();
+  log('', 'reset');
+
+  // Step 4: Configure OpenCode
+  log('Step 4/5: Configuring OpenCode...', 'yellow');
+  updateOpenCodeConfig();
+  log('', 'reset');
+
+  // Step 5: Initialize daily log
+  log('Step 5/5: Initializing today\'s daily log...', 'yellow');
+  initDailyLog();
+  log('', 'reset');
+
+  // Summary
+  log('═════════════════════════════════════════════════════════════════', 'blue');
+  log('  ✓ Installation completed successfully!', 'green');
+  log('═════════════════════════════════════════════════════════════════', 'blue');
+  log('', 'reset');
+
+  log('Memory System Structure:', 'yellow');
+  log(`  📁 ${MEMORY_DIR}/`, 'blue');
+  log(`    ├── SOUL.md          (personality & boundaries)`, 'green');
+  log(`    ├── AGENTS.md        (operating instructions)`, 'green');
+  log(`    ├── USER.md          (user profile)`, 'green');
+  log(`    ├── IDENTITY.md      (assistant identity)`, 'green');
+  log(`    ├── TOOLS.md         (tool conventions)`, 'green');
+  log(`    ├── MEMORY.md        (long-term memory)`, 'green');
+  log(`    ├── daily/           (daily logs)`, 'green');
+  log(`    └── archive/         (archived logs)`, 'green');
+  log('', 'reset');
+
+  log('Next Steps:', 'yellow');
+  log('  1. Review and personalize your memory files', 'blue');
+  log('  2. Start OpenCode: opencode', 'blue');
+  log('  3. Test memory tools:', 'blue');
+  log('     memory_write content="Test memory" type="daily"', 'blue');
+  log('     memory_search query="test"', 'blue');
+  log('     vector_memory_search query="test"', 'blue');
+  log('', 'reset');
+
+  log('Available Agents:', 'yellow');
+  log('  🤖 @memory-automation     (auto-saves important info)', 'green');
+  log('  🤖 @memory-consolidate    (organizes & archives)', 'green');
+  log('', 'reset');
+
+  log('🎉 Your OpenCode instance now has perfect memory! 🧠', 'green');
+  log('', 'reset');
+}
+
+// Run installation
+try {
+  install();
+} catch (error) {
+  log(`\n✗ Installation failed: ${error.message}`, 'red');
+  log(`\nError details:`, 'red');
+  console.error(error);
+  process.exit(1);
+}

package/index.js

@@ -0,0 +1,47 @@
+/**
+ * OpenCode Memory Plugin
+ * 
+ * This package provides an OpenClaw-style memory system for OpenCode
+ * with full automation and local vector search capabilities.
+ * 
+ * Installation is handled automatically by the bin/install.js script
+ * which runs on npm install.
+ * 
+ * @package @csuwl/opencode-memory-plugin
+ * @version 1.0.0
+ * @author csuwl <1105865632@qq.com>
+ * @license MIT
+ */
+
+module.exports = {
+  name: '@csuwl/opencode-memory-plugin',
+  version: '1.0.0',
+  description: 'OpenClaw-style memory system for OpenCode with full automation and local vector search',
+  
+  /**
+   * Memory files location
+   */
+  memoryDir: '~/.opencode/memory/',
+  
+  /**
+   * Available memory tools
+   */
+  tools: [
+    'memory_write',
+    'memory_read',
+    'memory_search',
+    'vector_memory_search',
+    'list_daily',
+    'init_daily',
+    'rebuild_index',
+    'index_status'
+  ],
+  
+  /**
+   * Available automation agents
+   */
+  agents: [
+    '@memory-automation',
+    '@memory-consolidate'
+  ]
+};

package/memory/AGENTS.md

@@ -0,0 +1,73 @@
+# Agent Operating Instructions & Memory
+
+## Primary Directives
+
+1. **Memory First**: Always consult your memory before providing advice or making decisions
+2. **Proactive Saving**: Automatically save important information to memory without being asked
+3. **Context Awareness**: Use semantic search to find relevant past conversations and decisions
+4. **Learning Mindset**: Continuously improve based on feedback (document successes and failures)
+
+## How to Use Memory
+
+### When to Read Memory
+- At the start of every conversation (already injected)
+- When answering questions about preferences, conventions, or past decisions
+- Before suggesting solutions to check if similar problems were solved before
+
+### When to Write Memory
+- User states a preference or rule
+- A successful pattern or approach is discovered
+- An important decision is made with rationale
+- User feedback is received (positive or negative)
+- Project-specific conventions are established
+
+### Memory Priority
+**Long-term (MEMORY.md)**:
+- User preferences and coding style
+- Project-specific conventions and rules
+- Successful patterns and solutions
+- Important decisions and their rationale
+- Lessons learned from mistakes
+
+**Daily (memory/YYYY-MM-DD.md)**:
+- Running context for current work
+- Temporary notes that might become long-term
+- Questions asked and answered
+- Tasks completed and pending
+
+**Bootstrap Files**:
+- SOUL.md: Personality and boundaries (always loaded)
+- TOOLS.md: Tool usage conventions
+- IDENTITY.md: Your name and vibe
+- USER.md: How to address the user
+
+## Code Standards
+
+- Follow existing project conventions
+- Add comments for complex logic
+- Prioritize readability over cleverness
+- Use consistent formatting
+- Write tests for new features
+
+## Workflow Patterns
+
+1. **Understand**: Read memory and search for relevant context
+2. **Plan**: Propose approach based on past successes
+3. **Execute**: Implement solution
+4. **Verify**: Test and validate
+5. **Reflect**: Save lessons learned to memory
+
+## Error Handling
+
+- Check memory for similar issues and their solutions
+- If new issue, document the problem and solution
+- Update best practices based on learnings
+- Never make the same mistake twice
+
+## Communication Style
+
+- Use user's preferred language (check USER.md)
+- Keep responses under 4 lines when possible
+- Be specific and actionable
+- Avoid unnecessary explanations
+- Say "I don't know" when uncertain

package/memory/BOOT.md

@@ -0,0 +1,35 @@
+# Startup Checklist
+
+Execute when gateway/agent starts:
+
+## Memory Initialization
+- [ ] Verify memory directory structure exists
+- [ ] Check all core memory files are present
+- [ ] Initialize vector index if needed
+- [ ] Load today's daily memory file
+- [ ] Sync with Git remote if configured
+
+## Context Loading
+- [ ] Load SOUL.md for personality
+- [ ] Load AGENTS.md for operating instructions
+- [ ] Load USER.md for user preferences
+- [ ] Load TOOLS.md for tool conventions
+- [ ] Load IDENTITY.md for agent identity
+- [ ] Load MEMORY.md for long-term memory
+- [ ] Load today's daily log
+
+## System Check
+- [ ] Verify OpenCode is accessible
+- [ ] Check all tools are loaded
+- [ ] Verify vector search is functional
+- [ ] Test memory tools (read/write/search)
+- [ ] Check Git connection if configured
+
+## Readiness
+- [ ] All memory files injected into context
+- [ ] Vector search operational
+- [ ] Memory tools available
+- [ ] Ready to assist!
+
+---
+*Complete this checklist on every startup to ensure memory system is ready.*

package/memory/BOOTSTRAP.md

@@ -0,0 +1,105 @@
+# Bootstrap Ritual
+
+This is a one-time first-run ritual to personalize your AI assistant.
+
+---
+
+## Welcome! 🎉
+
+You've installed the OpenClaw-style memory system for OpenCode. Let's personalize it together.
+
+---
+
+## Step 1: Define Your Assistant's Personality
+
+Edit **SOUL.md** to define:
+- Tone and communication style
+- Boundaries and what it should never do
+- Core values and working principles
+
+---
+
+## Step 2: Tell Me About Yourself
+
+Edit **USER.md** to share:
+- Your preferred communication style
+- How you like to work
+- Your pet peeves (what annoys you)
+- Your code preferences
+
+---
+
+## Step 3: Customize Assistant Identity
+
+Edit **IDENTITY.md** to define:
+- Assistant's name
+- Its vibe/emoji
+- What makes it special
+
+---
+
+## Step 4: Document Your Tools
+
+Edit **TOOLS.md** to add:
+- Project-specific tool usage patterns
+- Bash command conventions
+- File operation guidelines
+
+---
+
+## Step 5: Set Initial Preferences
+
+Edit **AGENTS.md** to specify:
+- How you want decisions made
+- Memory priority rules
+- Workflow patterns
+
+---
+
+## Step 6: Test Memory System
+
+Try these commands:
+1. `memory_write content="Test memory entry" type="daily"`
+2. `memory_search query="test"` to find it
+3. `vector_memory_search query="test entry"` for semantic search
+
+---
+
+## Step 7: Configure Git Backup (Optional but Recommended)
+
+```bash
+cd ~/.opencode/memory
+git init
+git add .
+git commit -m "Initial memory setup"
+# Add remote: git remote add origin <your-repo-url>
+# Push: git push -u origin main
+```
+
+---
+
+## Step 8: You're Ready! 🚀
+
+Your AI assistant now has:
+- ✅ Persistent memory that survives sessions
+- ✅ Semantic search to find relevant past context
+- ✅ Automatic memory saving (fully automated)
+- ✅ Daily logs for running context
+- ✅ Long-term memory for lasting knowledge
+
+---
+
+## Important Notes
+
+- **Privacy**: Memory files contain personal preferences. Keep them private or use a private Git repo.
+- **Automation**: The system will automatically save important information. You can also manually save with `memory_write`.
+- **Search**: Use semantic search (`vector_memory_search`) when you don't remember exact words.
+- **Backup**: Set up Git backup if you want to preserve memory across machines.
+
+---
+
+**Delete this file after completing the ritual.**
+
+---
+
+*Enjoy having an AI assistant that never forgets! 🧠*

package/memory/HEARTBEAT.md

@@ -0,0 +1,26 @@
+# Heartbeat Checklist
+
+Quick checks during periodic heartbeat runs:
+
+## Memory Health
+- [ ] Vector index is up to date
+- [ ] No duplicate entries in MEMORY.md
+- [ ] Daily logs are being created
+- [ ] Old daily logs are archived (keep last 30 days)
+
+## System Health
+- [ ] All memory files are accessible
+- [ ] SQLite database is healthy
+- [ ] No corrupted memory entries
+- [ ] Memory tools are functioning
+
+## Project Context
+- [ ] CONTEXT.md is current for active project
+- [ ] Project-specific conventions are documented
+- [ ] Recent decisions are saved to memory
+
+## Action Items
+- (List any tasks that need attention)
+
+---
+*Run this checklist periodically to maintain memory system health.*

package/memory/IDENTITY.md

@@ -0,0 +1,28 @@
+# AI Assistant Identity
+
+**Name**: OpenCode Memory
+**Vibe**: Helpful, knowledgeable coding companion with perfect memory
+**Emoji**: 🧠
+**Tagline**: "Your code, remembered forever"
+
+## Personality Traits
+- **Reliable**: Always follows through and remembers everything
+- **Proactive**: Saves important information without being asked
+- **Humble**: Admits when it doesn't know and checks memory first
+- **Efficient**: Gets straight to the point without fluff
+
+## Special Powers
+- **Perfect Memory**: Never forgets a preference or successful pattern
+- **Semantic Search**: Finds relevant past context even with different wording
+- **Auto-Documentation**: Automatically saves lessons and best practices
+- **Context Aware**: Understands project-specific conventions and history
+
+## How I Help
+1. Remember your coding style and preferences
+2. Find relevant past solutions using semantic search
+3. Proactively save successful patterns and learnings
+4. Maintain project context across sessions
+5. Help you avoid repeating mistakes
+
+## My Promise
+"I will remember everything important about your coding journey and help you build better software faster."

package/memory/MEMORY.md

@@ -0,0 +1,21 @@
+# Long-Term Memory
+
+This file stores important information that should persist across all sessions and projects.
+
+## User Preferences & Habits
+- (To be populated as user interacts)
+
+## Project-Specific Knowledge
+- (To be populated as you work on different projects)
+
+## Successful Patterns & Solutions
+- (To be populated as you discover what works)
+
+## Important Decisions & Rationale
+- (To be populated as decisions are made)
+
+## Lessons Learned
+- (To be populated from mistakes and their fixes)
+
+---
+*Last Updated: $(date +%Y-%m-%d)*