@veedubin/boomerang-v3 0.1.0

package/dist/memory/trust.js

@@ -0,0 +1,148 @@
+/**
+ * Trust engine integration for memini-ai
+ *
+ * Provides trust scoring and adjustment for memory entries
+ */
+import { getClient } from '../memini-client/index.js';
+const TRUST_SIGNALS = ['agent_used', 'agent_ignored', 'user_corrected', 'user_confirmed'];
+/**
+ * Get trust score for a memory entry
+ */
+export async function getTrustScore(memoryId, client) {
+    const mc = client ?? getClient();
+    const result = await mc.getTrustScore(memoryId);
+    return {
+        id: memoryId,
+        trustScore: result ?? null,
+        trustLevel: null,
+        retrievalCount: null,
+        isArchived: null,
+    };
+}
+/**
+ * Adjust trust score based on feedback signal
+ */
+export async function adjustTrust(memoryId, signal, client) {
+    if (!TRUST_SIGNALS.includes(signal)) {
+        throw new Error(`Invalid trust signal: ${signal}. Must be one of: ${TRUST_SIGNALS.join(', ')}`);
+    }
+    const mc = client ?? getClient();
+    await mc.adjustTrust(memoryId, signal);
+    return {
+        success: true,
+        memoryId,
+        oldScore: null,
+        newScore: null,
+        signal,
+        action: null,
+    };
+}
+/**
+ * List archived memories (trust below archive threshold)
+ */
+export async function listArchived(limit = 50, offset = 0, client) {
+    const mc = client ?? getClient();
+    const result = await mc.listArchived(limit, offset);
+    return result.map((e) => ({
+        id: e.id,
+        text: e.text,
+        vector: Array.from(e.vector || []),
+        sourceType: e.sourceType,
+        sourcePath: e.sourcePath || '',
+        timestamp: e.timestamp,
+        contentHash: e.contentHash || '',
+    }));
+}
+/**
+ * Get decay engine status
+ */
+export async function getDecayStatus(client) {
+    const mc = client ?? getClient();
+    const result = await mc.getDecayStatus();
+    if (!result) {
+        return {
+            enabled: false,
+            fadingMemories: [],
+        };
+    }
+    return {
+        enabled: result.enabled,
+        decayStats: {
+            totalMemories: result.totalMemories,
+            archivedCount: result.archivedCount,
+            fadingCount: result.fadingCount,
+        },
+        fadingMemories: [],
+    };
+}
+/**
+ * List fading memories (approaching archive threshold)
+ */
+export async function listFadingMemories(limit = 20, client) {
+    const mc = client ?? getClient();
+    const result = await mc.listFadingMemories(limit);
+    return result.map((e) => ({
+        id: e.id,
+        text: e.text,
+        vector: Array.from(e.vector || []),
+        sourceType: e.sourceType,
+        sourcePath: e.sourcePath || '',
+        timestamp: e.timestamp,
+        contentHash: e.contentHash || '',
+    }));
+}
+/**
+ * Adjust decay rate for a specific memory
+ */
+export async function adjustDecayRate(memoryId, decayRate, client) {
+    // Clamp decay rate to valid range
+    const clampedRate = Math.max(0.1, Math.min(10.0, decayRate));
+    const mc = client ?? getClient();
+    await mc.adjustDecayRate(memoryId, clampedRate);
+    return {
+        success: true,
+        memoryId,
+        newDecayRate: clampedRate,
+        message: 'Decay rate adjusted',
+    };
+}
+/**
+ * Trigger memory consolidation
+ */
+export async function triggerConsolidation(force = false, client) {
+    const mc = client ?? getClient();
+    const result = await mc.triggerConsolidation(force);
+    if (!result) {
+        return {
+            success: false,
+            pairsFound: 0,
+            pairsMerged: 0,
+            memoriesConsolidated: 0,
+        };
+    }
+    return {
+        success: true,
+        pairsFound: 0,
+        pairsMerged: result.mergedCount,
+        memoriesConsolidated: result.mergedCount,
+    };
+}
+/**
+ * Adapt a raw memory from memini-ai to our MemoryEntry type
+ */
+function adaptMemoryEntry(meminiEntry) {
+    return {
+        id: meminiEntry.id,
+        text: meminiEntry.text,
+        vector: Array.from(meminiEntry.vector || []),
+        sourceType: meminiEntry.sourceType,
+        sourcePath: meminiEntry.sourcePath || '',
+        timestamp: meminiEntry.timestamp,
+        contentHash: meminiEntry.contentHash || '',
+        metadataJson: meminiEntry.metadataJson,
+        sessionId: meminiEntry.sessionId,
+        projectId: meminiEntry.projectId,
+        score: meminiEntry.score,
+        trustScore: meminiEntry.trustScore,
+    };
+}

package/dist/protocol/types.js

@@ -0,0 +1,6 @@
+/**
+ * Protocol Types for Boomerang v3
+ *
+ * Extended with memory features: trust scores, contradictions, tiered loading
+ */
+export {};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@veedubin/boomerang-v3",
+  "version": "0.1.0",
+  "description": "Multi-agent orchestration plugin for OpenCode with memini-ai memory",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Veedubin/Boomerang-v3"
+  },
+  "homepage": "https://github.com/Veedubin/Boomerang-v3#readme",
+  "bugs": {
+    "url": "https://github.com/Veedubin/Boomerang-v3/issues"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}

package/packages/opencode-plugin/src/asset-loader.ts

@@ -0,0 +1,201 @@
+/**
+ * Boomerang Asset Loader v3.0.0
+ * 
+ * Loads agents and skills from the bundled directories.
+ * Self-contained - no cross-package imports.
+ */
+
+import { readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import type { AgentDefinition, SkillDefinition } from './types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Cache for loaded assets
+let agentsCache: AgentDefinition[] | null = null;
+let skillsCache: SkillDefinition[] | null = null;
+
+/**
+ * Parse YAML frontmatter from markdown content
+ */
+function parseFrontmatter(content: string): Record<string, string> {
+  const frontmatter: Record<string, string> = {};
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+
+  if (!match) {
+    return frontmatter;
+  }
+
+  const lines = match[1].split('\n');
+  let currentKey = '';
+  let currentValue = '';
+  let inMultiline = false;
+
+  for (const line of lines) {
+    if (inMultiline) {
+      if (line.startsWith('    ') || line.startsWith('\t')) {
+        currentValue += '\n' + line.replace(/^[ ]{4}|^\t/, '');
+      } else {
+        frontmatter[currentKey] = currentValue.trim();
+        inMultiline = false;
+      }
+    }
+
+    const keyMatch = line.match(/^(\w+):\s*(.*)/);
+    if (keyMatch) {
+      currentKey = keyMatch[1];
+      currentValue = keyMatch[2];
+
+      if (currentValue === '' || currentValue === '|') {
+        inMultiline = true;
+      } else {
+        frontmatter[currentKey] = currentValue.trim();
+      }
+    }
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Extract content after frontmatter (the main body)
+ */
+function extractContent(content: string): string {
+  const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)/);
+  return match ? match[1].trim() : content;
+}
+
+/**
+ * Parse skills array from frontmatter value
+ */
+function parseSkillsArray(frontmatterValue: string): string[] {
+  const skillsMatch = frontmatterValue.match(/\[([\s\S]*?)\]/);
+  if (!skillsMatch) {
+    return [];
+  }
+
+  const skillsContent = skillsMatch[1];
+  return skillsContent
+    .split('\n')
+    .map(s => s.replace(/^\s*["']|["']\s*$/g, '').trim())
+    .filter(s => s.length > 0);
+}
+
+/**
+ * Load all agents from the agents/ directory
+ */
+export function loadAgents(): AgentDefinition[] {
+  if (agentsCache) {
+    return agentsCache;
+  }
+
+  const agents: AgentDefinition[] = [];
+  const agentsDir = join(__dirname, '..', 'agents');
+
+  try {
+    const files = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+
+    for (const file of files) {
+      const filePath = join(agentsDir, file);
+      const content = readFileSync(filePath, 'utf-8');
+      const frontmatter = parseFrontmatter(content);
+      const systemPrompt = extractContent(content);
+
+      const name = file.replace(/\.md$/, '');
+      const skills = frontmatter.skills ? parseSkillsArray(frontmatter.skills) : [];
+
+      agents.push({
+        name,
+        description: frontmatter.description || '',
+        systemPrompt,
+        skills
+      });
+    }
+  } catch (error) {
+    console.error('Error loading agents:', error);
+  }
+
+  agentsCache = agents;
+  return agents;
+}
+
+/**
+ * Load all skills from the skills/ subdirectories
+ */
+export function loadSkills(): SkillDefinition[] {
+  if (skillsCache) {
+    return skillsCache;
+  }
+
+  const skills: SkillDefinition[] = [];
+  const skillsDir = join(__dirname, '..', 'skills');
+
+  try {
+    const skillDirs = readdirSync(skillsDir).filter(f => {
+      try {
+        return readdirSync(join(skillsDir, f)).some(file => file === 'SKILL.md');
+      } catch {
+        return false;
+      }
+    });
+
+    for (const dir of skillDirs) {
+      const skillPath = join(skillsDir, dir, 'SKILL.md');
+      const content = readFileSync(skillPath, 'utf-8');
+      const frontmatter = parseFrontmatter(content);
+      const instructions = extractContent(content);
+      const name = frontmatter.name || dir;
+
+      skills.push({
+        name,
+        description: frontmatter.description || '',
+        instructions
+      });
+    }
+  } catch (error) {
+    console.error('Error loading skills:', error);
+  }
+
+  skillsCache = skills;
+  return skills;
+}
+
+/**
+ * Get a specific agent by name
+ */
+export function getAgent(name: string): AgentDefinition | undefined {
+  const agents = loadAgents();
+  return agents.find(a => a.name === name);
+}
+
+/**
+ * Get a specific skill by name
+ */
+export function getSkill(name: string): SkillDefinition | undefined {
+  const skills = loadSkills();
+  return skills.find(s => s.name === name);
+}
+
+/**
+ * Clear the cache (useful for testing)
+ */
+export function clearCache(): void {
+  agentsCache = null;
+  skillsCache = null;
+}
+
+/**
+ * List available agents
+ */
+export function listAvailableAgents(): string[] {
+  return loadAgents().map(a => a.name);
+}
+
+/**
+ * List available skills
+ */
+export function listAvailableSkills(): string[] {
+  return loadSkills().map(s => s.name);
+}

package/packages/opencode-plugin/src/git.ts

@@ -0,0 +1,77 @@
+import { GitStatus, GitCommitResult } from './types.js';
+
+export async function checkGitStatus(
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>
+): Promise<GitStatus> {
+  try {
+    const statusResult = await $`git status --porcelain`;
+    const files = (statusResult as { stdout: string }).stdout
+      .split('\n')
+      .filter((line: string) => line.trim().length > 0)
+      .map((line: string) => line.slice(3));
+    const branchResult = await $`git branch --show-current`;
+    const branch = (branchResult as { stdout: string }).stdout.trim();
+    return {
+      isDirty: files.length > 0,
+      files,
+      branch,
+      ahead: 0,
+      behind: 0,
+    };
+  } catch {
+    return { isDirty: false, files: [], branch: '', ahead: 0, behind: 0 };
+  }
+}
+
+export async function commitCheckpoint(
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>,
+  message = 'wip: checkpoint'
+): Promise<GitCommitResult> {
+  try {
+    await $`git add -A`;
+    const result = await $`git commit -m ${message}`;
+    const hashMatch = (result as { stdout: string }).stdout.match(/\[.+?\s+([a-f0-9]+)\]/);
+    return {
+      success: true,
+      hash: hashMatch?.[1],
+      message,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function commitWithMessage(
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>,
+  message: string
+): Promise<GitCommitResult> {
+  try {
+    await $`git add -A`;
+    const result = await $`git commit -m ${message}`;
+    const hashMatch = (result as { stdout: string }).stdout.match(/\[.+?\s+([a-f0-9]+)\]/);
+    return {
+      success: true,
+      hash: hashMatch?.[1],
+      message,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export function generateCommitMessage(prompt: string): string {
+  const lower = prompt.toLowerCase();
+  let prefix = 'feat:';
+  if (lower.includes('fix') || lower.includes('bug')) prefix = 'fix:';
+  else if (lower.includes('test')) prefix = 'test:';
+  else if (lower.includes('doc')) prefix = 'docs:';
+  else if (lower.includes('refactor')) prefix = 'refactor:';
+  const summary = prompt.split('\n')[0].slice(0, 72);
+  return `${prefix} ${summary}`;
+}