Bump memory package version and enhance cleanup

Author: chriswritescode-dev

packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-manager/memory",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -38,6 +38,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@opencode-ai/plugin": "^1.2.16",
+    "@opencode-ai/sdk": "^1.2.26",
     "sqlite-vec": "0.1.7-alpha.2"
   },
   "optionalDependencies": {

packages/memory/src/cli/commands/cleanup.ts

@@ -1,4 +1,9 @@
 import { openDatabase, formatDate, truncate, confirm, resolveProjectNames, displayProjectId, MemoryScope } from '../utils'
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { homedir, platform } from 'os'
+import { execSync } from 'child_process'
+import { createConnection } from 'net'
 
 interface CleanupOptions {
   olderThan?: number
@@ -10,6 +15,7 @@ interface CleanupOptions {
   projectId?: string
   dbPath?: string
   help?: boolean
+  vecWorkers?: boolean
 }
 
 function parseArgs(args: string[]): CleanupOptions {
@@ -49,6 +55,8 @@ function parseArgs(args: string[]): CleanupOptions {
       options.projectId = args[++i]
     } else if (arg === '--db-path') {
       options.dbPath = args[++i]
+    } else if (arg === '--vec-workers') {
+      options.vecWorkers = true
     } else if (arg === '--help' || arg === '-h') {
       help()
       process.exit(0)
@@ -70,6 +78,7 @@ Delete memories by criteria
 
 Usage:
   ocm-mem cleanup [options]
+  ocm-mem cleanup --vec-workers
 
 Options:
   --older-than <days>   Delete memories older than N days
@@ -80,11 +89,12 @@ Options:
   --force               Skip confirmation prompt
   --project, -p <id>    Project ID (auto-detected from git if not provided)
   --db-path <path>      Path to memory database
+  --vec-workers         Clean up orphaned vec-worker processes
   --help, -h            Show this help message
   `.trim())
 }
 
-export function run(args: string[], globalOpts: { dbPath?: string; projectId?: string }): void {
+export async function run(args: string[], globalOpts: { dbPath?: string; projectId?: string }): Promise<void> {
   const options = parseArgs(args)
   options.projectId = options.projectId || globalOpts.projectId
 
@@ -93,6 +103,12 @@ export function run(args: string[], globalOpts: { dbPath?: string; projectId?: s
     process.exit(0)
   }
 
+  if (options.vecWorkers) {
+    const result = await cleanupVecWorkers()
+    console.log(result)
+    return
+  }
+
   if (!options.olderThan && !options.ids && !options.all) {
     console.error('At least one filter must be provided: --older-than, --ids, or --all')
     help()
@@ -198,3 +214,104 @@ async function runMemoryCleanup(db: ReturnType<typeof openDatabase>, options: Cl
   console.log(`Deleted ${rows.length} memories. ${remainingCount.count} remaining.`)
   console.log("Note: Run 'memory-health reindex' in OpenCode to clean up orphaned embeddings.")
 }
+
+export async function cleanupVecWorkers(): Promise<string> {
+  const workers = findVecWorkers()
+  const defaultDataDir = getDefaultDataDir()
+  
+  if (workers.length === 0) {
+    return 'No vec-worker processes found.'
+  }
+  
+  const results: string[] = []
+  let cleaned = 0
+  
+  for (const worker of workers) {
+    const isDefault = worker.dbPath.startsWith(defaultDataDir)
+    const isHealthy = await isWorkerHealthy(worker.pid, worker.socketPath)
+    
+    if (isHealthy) {
+      results.push(`✓ PID ${worker.pid} - healthy (data dir: ${isDefault ? 'global' : 'workspace'})`)
+    } else {
+      try {
+        process.kill(worker.pid, 'SIGTERM')
+        results.push(`✗ PID ${worker.pid} - terminated (was orphaned)`)
+        cleaned++
+      } catch (err) {
+        results.push(`✗ PID ${worker.pid} - failed to terminate`)
+      }
+    }
+  }
+  
+  return `Vec-worker cleanup complete:\n${results.join('\n')}\n\nTerminated ${cleaned} orphaned worker(s).`
+}
+
+function getDefaultDataDir(): string {
+  const defaultBase = join(homedir(), platform() === 'win32' ? 'AppData' : '.local', 'share')
+  const xdgDataHome = process.env['XDG_DATA_HOME'] || defaultBase
+  return join(xdgDataHome, 'opencode', 'memory')
+}
+
+function findVecWorkers(): Array<{ pid: number; dbPath: string; socketPath: string }> {
+  const workers: Array<{ pid: number; dbPath: string; socketPath: string }> = []
+  
+  try {
+    const output = execSync('ps aux | grep vec-worker | grep -v grep', { encoding: 'utf-8' })
+    const lines = output.split('\n').filter(line => line.trim())
+    
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/)
+      const pid = parseInt(parts[1], 10)
+      
+      const dbMatch = line.match(/--db\s+([^\s]+)/)
+      const socketMatch = line.match(/--socket\s+([^\s]+)/)
+      
+      if (dbMatch && socketMatch && !isNaN(pid)) {
+        workers.push({
+          pid,
+          dbPath: dbMatch[1],
+          socketPath: socketMatch[1],
+        })
+      }
+    }
+  } catch {
+  }
+  
+  return workers
+}
+
+async function isWorkerHealthy(pid: number, socketPath: string): Promise<boolean> {
+  if (!existsSync(socketPath)) return false
+  try {
+    process.kill(pid, 0)
+    return new Promise((resolve) => {
+      const client = createConnection({ path: socketPath })
+      const timeout = setTimeout(() => {
+        client.destroy()
+        resolve(false)
+      }, 2000)
+      
+      client.on('connect', () => {
+        client.write(JSON.stringify({ action: 'health' }) + '\n')
+      })
+      
+      client.on('data', (chunk) => {
+        clearTimeout(timeout)
+        client.destroy()
+        try {
+          const response = JSON.parse(chunk.toString())
+          resolve(response.status === 'ok')
+        } catch {
+          resolve(false)
+        }
+      })
+      
+      client.on('error', () => {
+        clearTimeout(timeout)
+        resolve(false)
+      })
+    })
+  } catch {
+    return false
+  }
+}

packages/memory/test/strip-promise-tags.test.ts

@@ -0,0 +1,56 @@
+import { describe, test, expect } from 'vitest'
+import { stripPromiseTags } from '../src/utils/strip-promise-tags'
+
+describe('stripPromiseTags', () => {
+  test('returns unchanged text when no promise tags present', () => {
+    const text = 'This is a normal plan without any special tags'
+    const { cleaned, stripped } = stripPromiseTags(text)
+    expect(cleaned).toBe(text)
+    expect(stripped).toBe(false)
+  })
+
+  test('strips bare promise tags', () => {
+    const text = 'Plan text here <promise>All phases of the plan have been completed successfully</promise>'
+    const { cleaned, stripped } = stripPromiseTags(text)
+    expect(cleaned).toBe('Plan text here')
+    expect(stripped).toBe(true)
+    expect(cleaned).not.toContain('<promise>')
+  })
+
+  test('strips full instruction block with promise tags', () => {
+    const text = `Plan text here
+
+---
+
+**IMPORTANT - Completion Signal:** When you have completed ALL phases of this plan successfully, you MUST output the following tag exactly: <promise>All phases of the plan have been completed successfully</promise>
+
+Do NOT output this tag until every phase is truly complete. The loop will continue until this signal is detected.`
+    const { cleaned, stripped } = stripPromiseTags(text)
+    expect(cleaned).toBe('Plan text here')
+    expect(stripped).toBe(true)
+    expect(cleaned).not.toContain('<promise>')
+    expect(cleaned).not.toContain('Completion Signal')
+  })
+
+  test('preserves plan content before promise tags', () => {
+    const plan = `## Phase 1
+Do something
+
+## Phase 2
+Do something else
+
+<promise>DONE</promise>`
+    const { cleaned, stripped } = stripPromiseTags(plan)
+    expect(cleaned).toContain('## Phase 1')
+    expect(cleaned).toContain('## Phase 2')
+    expect(cleaned).not.toContain('<promise>')
+    expect(stripped).toBe(true)
+  })
+
+  test('handles promise tags with multiline content', () => {
+    const text = 'Plan <promise>\nMulti\nLine\nContent\n</promise> end'
+    const { cleaned, stripped } = stripPromiseTags(text)
+    expect(cleaned).not.toContain('<promise>')
+    expect(stripped).toBe(true)
+  })
+})