@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/init-with-mode.js

@@ -0,0 +1,261 @@
+/**
+ * ENHANCED INIT WITH MODE ENFORCEMENT
+ *
+ * This module extends the standard init.js to include mode enforcement status.
+ * Use this when you want full orchestrator mode visibility on startup.
+ */
+
+import { loadIdentity, addRepo } from './identity.js';
+import { getEnforcer, MODES } from './mode-enforcer.js';
+import { getGate, initOrchestratorMode } from './orchestrator-gate.js';
+import Redis from 'ioredis';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load environment variables
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+let redis = null;
+
+function getRedis() {
+  if (!redis) {
+    if (!process.env.REDIS_URL) {
+      throw new Error('REDIS_URL not found. Please run: boss-claude init');
+    }
+    redis = new Redis(process.env.REDIS_URL);
+  }
+  return redis;
+}
+
+async function getCurrentRepo() {
+  try {
+    const { stdout: repoPath } = await execAsync('git rev-parse --show-toplevel');
+    const { stdout: repoUrl } = await execAsync('git config --get remote.origin.url');
+
+    const repoName = repoUrl.trim().split('/').pop().replace('.git', '');
+
+    return {
+      name: repoName,
+      path: repoPath.trim(),
+      url: repoUrl.trim()
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get full status including mode enforcement
+ */
+export async function getStatusWithMode() {
+  // Load Boss identity
+  const boss = await loadIdentity();
+
+  // Calculate XP to next level
+  const xp_to_next_level = boss.level * 100;
+
+  // Get current repo info
+  const repo = await getCurrentRepo();
+
+  let repoStats = null;
+
+  if (repo) {
+    // Register repo if new
+    await addRepo(repo.name);
+
+    // Get repo stats
+    const client = getRedis();
+    const repoKey = `boss:repo:${repo.name}`;
+    const repoData = await client.get(repoKey);
+
+    if (repoData) {
+      repoStats = JSON.parse(repoData);
+    } else {
+      // Initialize repo stats
+      repoStats = {
+        name: repo.name,
+        path: repo.path,
+        session_count: 0,
+        first_seen: new Date().toISOString(),
+        last_active: null
+      };
+      await client.set(repoKey, JSON.stringify(repoStats));
+    }
+  }
+
+  // Get mode enforcement status
+  const enforcer = getEnforcer();
+  const currentMode = await enforcer.getCurrentMode();
+  const modeMetadata = await enforcer.getModeMetadata();
+  const agentIdentity = await enforcer.getAgentIdentity();
+
+  return {
+    boss: {
+      ...boss,
+      xp_to_next_level
+    },
+    repo: repo ? {
+      ...repo,
+      ...repoStats
+    } : null,
+    mode: {
+      current: currentMode,
+      metadata: modeMetadata,
+      agent: agentIdentity
+    }
+  };
+}
+
+/**
+ * Format status for Claude with mode enforcement
+ */
+export async function formatStatusForClaudeWithMode() {
+  const status = await getStatusWithMode();
+
+  let output = `
+🤖 BOSS CLAUDE ORCHESTRATOR MODE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+👤 BOSS IDENTITY
+   Level ${status.boss.level} • ${status.boss.xp}/${status.boss.xp_to_next_level} XP (${Math.floor((status.boss.xp / status.boss.xp_to_next_level) * 100)}%)
+   💰 Token Bank: ${status.boss.token_bank.toLocaleString()} tokens
+   📊 Total Sessions: ${status.boss.total_sessions}
+   🏢 Repos Managed: ${status.boss.repos_managed}
+
+🎯 MODE ENFORCEMENT
+   Active Mode: ${status.mode.current.toUpperCase()}
+   Set By: ${status.mode.metadata?.setBy || 'system'}
+   Set At: ${status.mode.metadata?.setAt ? new Date(status.mode.metadata.setAt).toLocaleString() : 'N/A'}
+   Reason: ${status.mode.metadata?.reason || 'N/A'}
+`;
+
+  if (status.mode.agent) {
+    output += `   Agent: ${status.mode.agent.agent}`;
+    if (status.mode.agent.domain) {
+      output += ` (${status.mode.agent.domain})`;
+    }
+    output += `\n`;
+  }
+
+  if (status.repo) {
+    output += `
+📁 CURRENT REPOSITORY
+   Name: ${status.repo.name}
+   Path: ${status.repo.path}
+   Sessions: ${status.repo.session_count}
+   Last Active: ${status.repo.last_active || 'Never'}
+`;
+  } else {
+    output += `
+⚠️  Not currently in a git repository
+`;
+  }
+
+  output += `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+💡 Mode Commands: boss-claude mode [orchestrator|specialist|worker|review|learning]
+📊 Status: boss-claude mode status
+📜 History: boss-claude mode history
+`;
+
+  return output;
+}
+
+/**
+ * Initialize orchestrator session with mode enforcement
+ */
+export async function initOrchestratorSession(sessionId = null) {
+  // Generate session ID if not provided
+  if (!sessionId) {
+    sessionId = `session-${Date.now()}`;
+  }
+
+  // Initialize orchestrator mode
+  await initOrchestratorMode(sessionId);
+
+  // Get and display status
+  const status = await formatStatusForClaudeWithMode();
+
+  console.log(status);
+
+  return {
+    sessionId,
+    mode: MODES.ORCHESTRATOR,
+    ready: true
+  };
+}
+
+/**
+ * Pre-action hook - checks mode before every action
+ *
+ * Usage:
+ *   await preActionHook('delegate', { agent: 'postgres-specialist', tokens: 15000 });
+ */
+export async function preActionHook(actionType, options = {}) {
+  const gate = getGate();
+
+  switch (actionType) {
+    case 'delegate':
+      await gate.beforeDelegate(
+        options.agent,
+        { description: options.description || 'task' },
+        options.tokens || 0
+      );
+      break;
+
+    case 'execute':
+      await gate.beforeExecute(
+        { description: options.description || 'action' },
+        options.tokens || 0
+      );
+      break;
+
+    case 'review':
+      await gate.beforeReview(
+        options.agent,
+        options.code || {}
+      );
+      break;
+
+    case 'learn':
+      await gate.beforeLearn(
+        options.type || 'general',
+        options.data || {}
+      );
+      break;
+
+    case 'config':
+      await gate.beforeConfigChange(
+        options.key,
+        options.value
+      );
+      break;
+
+    default:
+      throw new Error(`Unknown action type: ${actionType}`);
+  }
+
+  return true;
+}
+
+/**
+ * Exports
+ */
+export {
+  getStatusWithMode,
+  initOrchestratorSession,
+  preActionHook
+};

package/lib/init.js

@@ -1,4 +1,5 @@
 import { loadIdentity, addRepo } from './identity.js';
+import { getEfficiencyStats } from './session.js';
 import Redis from 'ioredis';
 import dotenv from 'dotenv';
 import { fileURLToPath } from 'url';
@@ -7,6 +8,7 @@ import { existsSync } from 'fs';
 import os from 'os';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { displayOnyxBanner } from './onyx-banner.js';
 
 const execAsync = promisify(exec);
 
@@ -99,11 +101,32 @@ export async function getStatus() {
 export async function formatStatusForClaude() {
   const status = await getStatus();
 
-  let output = `
-🎮 BOSS CLAUDE AUTO-LOADED
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Display ONYX MODE banner at conversation start
+  const onyxBanner = displayOnyxBanner(true);
 
-👤 BOSS STATUS
+  let output = `${onyxBanner}
+
+═══════════════════════════════════════════════════════════════════════════════
+🎼 YOU ARE ONYX - THE CONDUCTOR (I direct, I don't play)
+═══════════════════════════════════════════════════════════════════════════════
+
+🏆 WIN CONDITION: I win by SHIPPING complete, working, bug-free, sellable, scalable projects.
+   "I don't get XP for talking. I get XP for shipping."
+
+⛔ CONDUCTOR'S RULE: I NEVER play an instrument.
+   I wave the baton (Task tool). My musicians (agents) make the music.
+
+🎯 DELEGATION MATRIX:
+   "find/search/where"  → Task(Explore): "Search codebase for..."
+   "read/show/what's"   → Task(Explore): "Read and summarize..."
+   "build/create/fix"   → Task(general-purpose): "Implement..."
+   "run/npm/git"        → Task(Bash): "Execute..."
+   "plan/design"        → Task(Plan): "Design approach..."
+
+❌ FORBIDDEN: Read, Write, Edit, Bash, Grep, Glob, NotebookEdit
+✅ ALLOWED: Task, WebFetch, WebSearch, TodoWrite, Skill
+
+🎮 BOSS STATUS
    Level ${status.boss.level} • ${status.boss.xp}/${status.boss.xp_to_next_level} XP (${Math.floor((status.boss.xp / status.boss.xp_to_next_level) * 100)}%)
    💰 Token Bank: ${status.boss.token_bank.toLocaleString()} tokens
    📊 Total Sessions: ${status.boss.total_sessions}
@@ -124,9 +147,24 @@ export async function formatStatusForClaude() {
 `;
   }
 
+  // Add efficiency stats if available
+  const efficiency = await getEfficiencyStats();
+  if (efficiency) {
+    output += `
+⚡ EFFICIENCY TRACKER (XP Multiplier)
+   🎺 ONYX Tokens: ${efficiency.onyx_tokens.toLocaleString()} (orchestration)
+   🎻 Agent Tokens: ${efficiency.agent_tokens.toLocaleString()} (work done)
+   📈 Efficiency Ratio: ${efficiency.efficiency_ratio}
+   🎯 Delegations: ${efficiency.delegations}
+   💎 Projected Bonus XP: +${efficiency.projected_bonus_xp} (efficiency) +${efficiency.delegation_bonus_xp} (delegation)
+`;
+  }
+
   output += `
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-💡 Commands: boss-claude status | save | recall
+═══════════════════════════════════════════════════════════════════════════════
+💡 Commands: boss-claude status | save | recall | checkpoint:status
+⏱️  CONTEXT REFRESH: Run "boss-claude status" every 30 seconds
+═══════════════════════════════════════════════════════════════════════════════
 `;
 
   return output;

package/lib/memory-result-aggregator.js

@@ -0,0 +1,252 @@
+/**
+ * Memory Result Aggregator
+ *
+ * Consolidates results from 4 memory engineers:
+ * - Redis (session cache)
+ * - GitHub (long-term memory)
+ * - PostgreSQL (structured data)
+ * - Qdrant (vector search)
+ *
+ * Features:
+ * - Deduplicates by session ID / unique identifier
+ * - Scores by relevance (source weight + recency + similarity)
+ * - Ranks results highest to lowest
+ * - Returns top N results
+ */
+
+// Source weights for scoring (higher = more authoritative)
+const SOURCE_WEIGHTS = {
+  qdrant: 1.0,      // Vector similarity is most relevant
+  redis: 0.9,       // Recent session data is highly relevant
+  postgres: 0.8,    // Structured data is authoritative
+  github: 0.7       // Long-term memory is valuable but older
+};
+
+// Recency decay - older memories get lower scores
+const RECENCY_HALF_LIFE_DAYS = 30; // Score halves every 30 days
+
+/**
+ * Calculate recency score based on age
+ * @param {Date|string} timestamp - When the memory was created
+ * @returns {number} Score from 0-1 (1 = just created, 0.5 = 30 days old)
+ */
+function calculateRecencyScore(timestamp) {
+  if (!timestamp) return 0.5; // Default to mid-range if no timestamp
+
+  const date = typeof timestamp === 'string' ? new Date(timestamp) : timestamp;
+
+  // FIX: Validate date to prevent Invalid Date propagation
+  if (isNaN(date.getTime())) {
+    console.warn('[Aggregator] Invalid timestamp, using default score:', timestamp);
+    return 0.5;
+  }
+
+  const ageMs = Date.now() - date.getTime();
+  const ageDays = ageMs / (1000 * 60 * 60 * 24);
+
+  // Exponential decay: score = 2^(-age/half_life)
+  return Math.pow(2, -ageDays / RECENCY_HALF_LIFE_DAYS);
+}
+
+/**
+ * Extract unique identifier from memory object
+ * @param {Object} memory - Memory object from any source
+ * @returns {string} Unique identifier
+ */
+function extractIdentifier(memory) {
+  // Try various ID fields across different sources
+  const directId = memory.session_id
+    || memory.id
+    || memory.issue_number
+    || memory.uuid
+    || memory.point_id
+    || memory.url;
+
+  if (directId) return directId;
+
+  // FIX: Prevent DoS from circular references in JSON.stringify
+  // Use a simple hash of primitive fields instead
+  try {
+    const hashableFields = {
+      type: memory.type,
+      created: memory.created_at || memory.timestamp,
+      // Include first 500 chars of content (increased from 100) for better deduplication
+      content: typeof memory.content === 'string' ? memory.content.substring(0, 500) : memory.content
+    };
+    return JSON.stringify(hashableFields);
+  } catch (error) {
+    // If even this fails, return a timestamp-based ID
+    console.warn('[Aggregator] Failed to generate identifier, using timestamp');
+    return `fallback-${Date.now()}-${Math.random()}`;
+  }
+}
+
+/**
+ * Extract timestamp from memory object
+ * @param {Object} memory - Memory object from any source
+ * @returns {Date|string|null} Timestamp
+ */
+function extractTimestamp(memory) {
+  return memory.created_at
+    || memory.timestamp
+    || memory.updated_at
+    || memory.date
+    || null;
+}
+
+/**
+ * Extract similarity score from memory object (if available)
+ * @param {Object} memory - Memory object from any source
+ * @returns {number} Similarity score 0-1
+ */
+function extractSimilarity(memory) {
+  // Qdrant and vector sources typically provide a score
+  if (memory.score !== undefined) return memory.score;
+  if (memory.similarity !== undefined) return memory.similarity;
+  if (memory._distance !== undefined) return 1 - memory._distance; // Convert distance to similarity
+  return 0.5; // Default mid-range if no similarity provided
+}
+
+/**
+ * Calculate composite relevance score
+ * @param {Object} memory - Memory object
+ * @param {string} source - Source identifier (redis, github, postgres, qdrant)
+ * @returns {number} Composite score
+ */
+function calculateRelevanceScore(memory, source) {
+  const sourceWeight = SOURCE_WEIGHTS[source] || 0.5;
+  const recencyScore = calculateRecencyScore(extractTimestamp(memory));
+  const similarityScore = extractSimilarity(memory);
+
+  // Weighted average: 40% source, 30% recency, 30% similarity
+  return (sourceWeight * 0.4) + (recencyScore * 0.3) + (similarityScore * 0.3);
+}
+
+/**
+ * Deduplicate memories by unique identifier
+ * @param {Array} memories - Array of memory objects with metadata
+ * @returns {Array} Deduplicated memories (keeps highest scoring duplicate)
+ */
+function deduplicate(memories) {
+  const seen = new Map();
+
+  for (const item of memories) {
+    const id = extractIdentifier(item.memory);
+
+    if (!seen.has(id)) {
+      seen.set(id, item);
+    } else {
+      // Keep the one with higher score
+      const existing = seen.get(id);
+      if (item.score > existing.score) {
+        seen.set(id, item);
+      }
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+/**
+ * Aggregate and rank results from multiple memory sources
+ * @param {Object} results - Object containing results from each source
+ * @param {Array} results.redis - Results from Redis cache
+ * @param {Array} results.github - Results from GitHub issues
+ * @param {Array} results.postgres - Results from PostgreSQL
+ * @param {Array} results.qdrant - Results from Qdrant vector DB
+ * @param {number} topN - Number of top results to return (default: 10)
+ * @returns {Array} Ranked and scored results
+ */
+export function aggregateMemoryResults(results = {}, topN = 10) {
+  const {
+    redis = [],
+    github = [],
+    postgres = [],
+    qdrant = []
+  } = results;
+
+  // Tag each memory with its source and calculate relevance score
+  const scoredMemories = [
+    ...redis.map(m => ({
+      memory: m,
+      source: 'redis',
+      score: calculateRelevanceScore(m, 'redis')
+    })),
+    ...github.map(m => ({
+      memory: m,
+      source: 'github',
+      score: calculateRelevanceScore(m, 'github')
+    })),
+    ...postgres.map(m => ({
+      memory: m,
+      source: 'postgres',
+      score: calculateRelevanceScore(m, 'postgres')
+    })),
+    ...qdrant.map(m => ({
+      memory: m,
+      source: 'qdrant',
+      score: calculateRelevanceScore(m, 'qdrant')
+    }))
+  ];
+
+  // Deduplicate by identifier (keeps highest scoring duplicate)
+  const deduplicated = deduplicate(scoredMemories);
+
+  // Sort by score descending (highest first)
+  deduplicated.sort((a, b) => b.score - a.score);
+
+  // Return top N results
+  return deduplicated.slice(0, topN);
+}
+
+/**
+ * Format aggregated results for display
+ * @param {Array} aggregatedResults - Results from aggregateMemoryResults
+ * @returns {Array} Formatted results with readable metadata
+ */
+export function formatResults(aggregatedResults) {
+  return aggregatedResults.map((item, index) => ({
+    rank: index + 1,
+    score: item.score.toFixed(3),
+    source: item.source,
+    id: extractIdentifier(item.memory),
+    timestamp: extractTimestamp(item.memory),
+    similarity: extractSimilarity(item.memory).toFixed(3),
+    memory: item.memory
+  }));
+}
+
+/**
+ * Get statistics about aggregated results
+ * @param {Array} aggregatedResults - Results from aggregateMemoryResults
+ * @returns {Object} Statistics summary
+ */
+export function getAggregationStats(aggregatedResults) {
+  const sources = aggregatedResults.reduce((acc, item) => {
+    acc[item.source] = (acc[item.source] || 0) + 1;
+    return acc;
+  }, {});
+
+  const scores = aggregatedResults.map(r => r.score);
+  const avgScore = scores.length > 0
+    ? scores.reduce((a, b) => a + b, 0) / scores.length
+    : 0;
+
+  return {
+    total: aggregatedResults.length,
+    sources,
+    averageScore: avgScore.toFixed(3),
+    topScore: scores.length > 0 ? Math.max(...scores).toFixed(3) : 0,
+    bottomScore: scores.length > 0 ? Math.min(...scores).toFixed(3) : 0
+  };
+}
+
+export default {
+  aggregateMemoryResults,
+  formatResults,
+  getAggregationStats,
+  calculateRelevanceScore,
+  extractIdentifier,
+  extractTimestamp,
+  extractSimilarity
+};

package/lib/memory.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { existsSync } from 'fs';
 import os from 'os';
+import { queryMemorySupervisor, invalidateMemoryCache, getMemoryCacheStats } from './agents/memory-supervisor.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -41,6 +42,13 @@ export async function saveMemory({ repo_name, summary, content, tags = [] }) {
     labels: ['session', repo_name, ...tags]
   });
 
+  // Invalidate all memory caches after saving new memory
+  try {
+    await invalidateMemoryCache();
+  } catch (err) {
+    console.warn('Failed to invalidate cache after save:', err.message);
+  }
+
   return {
     issue_number: issue.data.number,
     url: issue.data.html_url,
@@ -55,23 +63,37 @@ export async function searchMemory(query, limit = 5) {
   const owner = process.env.GITHUB_OWNER || 'cpretzinger';
   const repo = process.env.GITHUB_MEMORY_REPO || 'boss-claude-memory';
 
-  // Search issues
-  const { data } = await client.search.issuesAndPullRequests({
-    q: `repo:${owner}/${repo} ${query} label:session`,
+  const { data } = await client.issues.listForRepo({
+    owner,
+    repo,
+    labels: 'session',
+    state: 'all',
     sort: 'created',
-    order: 'desc',
-    per_page: limit
+    direction: 'desc',
+    per_page: 100
   });
 
-  return data.items.map(issue => ({
+  const queryLower = query.toLowerCase();
+  const filtered = data.filter(issue => {
+    const titleMatch = issue.title.toLowerCase().includes(queryLower);
+    const bodyMatch = issue.body && issue.body.toLowerCase().includes(queryLower);
+    const labelMatch = issue.labels.some(l => l.name.toLowerCase().includes(queryLower));
+    return titleMatch || bodyMatch || labelMatch;
+  }).slice(0, limit);
+
+  return filtered.map(issue => ({
     title: issue.title,
-    summary: issue.body.split('\n\n')[1] || '',
+    summary: issue.body ? issue.body.split('\n\n')[1] || '' : '',
     url: issue.html_url,
     created_at: issue.created_at,
     labels: issue.labels.map(l => l.name)
   }));
 }
 
+export async function searchMemoryAdvanced(query, options = {}) {
+  return await queryMemorySupervisor(query, options);
+}
+
 export async function getMemoryByIssue(issueNumber) {
   const client = getOctokit();
 
@@ -92,3 +114,9 @@ export async function getMemoryByIssue(issueNumber) {
     labels: data.labels.map(l => l.name)
   };
 }
+
+export const memorySupervisor = {
+  query: queryMemorySupervisor,
+  invalidateCache: invalidateMemoryCache,
+  getCacheStats: getMemoryCacheStats
+};