copilot-liku-cli 0.0.4 → 0.0.8

package/src/main/agents/researcher.js

@@ -12,6 +12,7 @@
  */
 
 const { BaseAgent, AgentRole, AgentCapabilities } = require('./base-agent');
+const { PythonBridge } = require('../python-bridge');
 const fs = require('fs');
 const path = require('path');
 
@@ -41,6 +42,9 @@ class ResearcherAgent extends BaseAgent {
     this.researchCache = new Map();
     this.cacheMaxAge = options.cacheMaxAge || 3600000; // 1 hour
     this.sourceCredibility = new Map();
+
+    // PythonBridge for genre intelligence (lazy init via shared singleton)
+    this.pythonBridge = null;
   }
 
   getSystemPrompt() {
@@ -506,6 +510,80 @@ Provide comprehensive findings with:
     this.researchCache.clear();
     this.sourceCredibility.clear();
   }
+
+  // ===== Genre Intelligence Methods (Sprint 3 — Task 3.4) =====
+
+  /**
+   * Lazily initialise and start the shared PythonBridge.
+   * @returns {Promise<PythonBridge>}
+   */
+  async ensurePythonBridge() {
+    if (!this.pythonBridge) {
+      this.pythonBridge = PythonBridge.getShared();
+    }
+    if (!this.pythonBridge.isRunning) {
+      this.log('info', 'Starting PythonBridge for genre intelligence');
+      await this.pythonBridge.start();
+    }
+    return this.pythonBridge;
+  }
+
+  /**
+   * Look up the 10-dimensional DNA vector for a given genre.
+   *
+   * Results are cached in ``researchCache`` to avoid repeated RPCs.
+   *
+   * @param {string} genre  Genre identifier (e.g. "trap_soul").
+   * @returns {Promise<object>}  { genre, found, vector, dimensions }
+   */
+  async queryGenreDNA(genre) {
+    // Check cache first
+    const cacheKey = `genre_dna::${genre}`;
+    const cached = this.researchCache.get(cacheKey);
+    if (cached && (Date.now() - cached.timestamp) < this.cacheMaxAge) {
+      this.log('info', 'Returning cached genre DNA', { genre });
+      return { ...cached.result, fromCache: true };
+    }
+
+    await this.ensurePythonBridge();
+    this.log('info', 'Querying genre DNA', { genre });
+
+    const result = await this.pythonBridge.call('genre_dna_lookup', { genre });
+
+    // Cache the result
+    this.researchCache.set(cacheKey, {
+      result,
+      timestamp: Date.now(),
+    });
+
+    return result;
+  }
+
+  /**
+   * Blend multiple genre DNA vectors with weights.
+   *
+   * @param {Array<{genre: string, weight: number}>} genres
+   * @returns {Promise<object>}  { vector, sources, description, suggested_tempo, dimensions }
+   */
+  async blendGenres(genres) {
+    await this.ensurePythonBridge();
+    this.log('info', 'Blending genres', { count: genres.length });
+
+    const result = await this.pythonBridge.call('genre_blend', { genres });
+    return result;
+  }
+
+  /**
+   * Stop and release the PythonBridge.
+   * @returns {Promise<void>}
+   */
+  async disposePythonBridge() {
+    if (this.pythonBridge) {
+      this.log('info', 'Disposing PythonBridge');
+      await this.pythonBridge.stop();
+      this.pythonBridge = null;
+    }
+  }
 }
 
 module.exports = { ResearcherAgent };

package/src/main/agents/state-manager.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { nowIso, nowFilenameSafe } = require('../utils/time');
+const { PythonBridge } = require('../python-bridge');
 
 class AgentStateManager {
   constructor(statePath = null) {
@@ -48,7 +49,10 @@ class AgentStateManager {
         purpose: null,
         parentSessionId: null
       },
-      checkpoints: []
+      checkpoints: [],
+      sessionGraph: null,
+      generations: [],
+      lastSync: null
     };
   }
 
@@ -69,6 +73,13 @@ class AgentStateManager {
       state.schemaVersion = 2;
       state.version = '1.1.0';
     }
+    if (!state.schemaVersion || state.schemaVersion < 3) {
+      state.sessionGraph = state.sessionGraph || null;
+      state.generations = state.generations || [];
+      state.lastSync = state.lastSync || null;
+      state.schemaVersion = 3;
+      state.version = '1.2.0';
+    }
     return state;
   }
 
@@ -335,10 +346,131 @@ class AgentStateManager {
         purpose: null,
         parentSessionId: null
       },
-      checkpoints: []
+      checkpoints: [],
+      sessionGraph: null,
+      generations: [],
+      lastSync: null
     };
     this._saveState();
   }
+
+  // ===== SessionGraph Integration =====
+
+  /**
+   * Fetch the current SessionGraph from the Python backend.
+   * Caches locally in state for offline access.
+   * @returns {Promise<object|null>} The SessionGraph dict or null
+   */
+  async fetchSessionGraph() {
+    try {
+      const bridge = PythonBridge.getShared();
+      const graph = await bridge.call('session_state', {});
+      this.state.sessionGraph = graph;
+      this.state.lastSync = nowIso();
+      this._saveState();
+      return graph;
+    } catch (error) {
+      console.warn(`[StateManager] Failed to fetch SessionGraph: ${error.message}`);
+      return this.state.sessionGraph || null;
+    }
+  }
+
+  /**
+   * Get the cached SessionGraph (no network call).
+   * @returns {object|null}
+   */
+  getCachedSessionGraph() {
+    return this.state.sessionGraph || null;
+  }
+
+  /**
+   * Get summary of the session graph (track count, section count, etc.)
+   * @returns {object} Summary stats
+   */
+  getSessionSummary() {
+    const graph = this.state.sessionGraph;
+    if (!graph) {
+      return { available: false };
+    }
+
+    const tracks = graph.tracks || [];
+    const sections = graph.sections || [];
+    const totalBars = sections.reduce((sum, s) => sum + (s.bars || s.length_bars || 0), 0);
+    const hasMidi = tracks.some(t => (t.clips || []).some(c => c.midi_path || c.midi));
+    const hasAudio = tracks.some(t => (t.clips || []).some(c => c.audio_path || c.audio));
+
+    return {
+      available: true,
+      session_id: graph.session_id || null,
+      bpm: graph.bpm || null,
+      key: graph.key || null,
+      genre: graph.genre || null,
+      trackCount: tracks.length,
+      sectionCount: sections.length,
+      totalBars,
+      hasMidi,
+      hasAudio
+    };
+  }
+
+  /**
+   * Record a generation event in state with the resulting SessionGraph.
+   * @param {string} prompt - The original user prompt
+   * @param {object} result - The GenerationResult from generate_sync
+   * @param {object} sessionGraph - The SessionGraph from session_state
+   */
+  recordGeneration(prompt, result, sessionGraph) {
+    if (!this.state.generations) {
+      this.state.generations = [];
+    }
+
+    this.state.generations.push({
+      timestamp: nowIso(),
+      prompt,
+      result: {
+        success: result?.success ?? null,
+        session_id: result?.session_id ?? null,
+        tracks: result?.tracks ?? [],
+        error: result?.error ?? null
+      },
+      sessionGraph: sessionGraph || null
+    });
+
+    // Keep only last 10 generations
+    if (this.state.generations.length > 10) {
+      this.state.generations = this.state.generations.slice(-10);
+    }
+
+    this._saveState();
+  }
+
+  /**
+   * Get history of past generations.
+   * @param {number} [limit=5]
+   * @returns {Array}
+   */
+  getGenerationHistory(limit = 5) {
+    return (this.state.generations || []).slice(-limit);
+  }
+
+  /**
+   * Sync session state between Python and Electron.
+   * Fetches graph, records in state, returns summary.
+   * @returns {Promise<object>} { synced: true/false, summary, timestamp }
+   */
+  async syncSessionState() {
+    const timestamp = nowIso();
+    try {
+      const graph = await this.fetchSessionGraph();
+      if (!graph) {
+        return { synced: false, summary: null, timestamp, error: 'No graph returned' };
+      }
+      const summary = this.getSessionSummary();
+      return { synced: true, summary, timestamp };
+    } catch (error) {
+      return { synced: false, summary: null, timestamp, error: error.message };
+    }
+  }
 }
 
 module.exports = { AgentStateManager };

package/src/main/agents/verifier.js

@@ -11,6 +11,7 @@
  */
 
 const { BaseAgent, AgentRole, AgentCapabilities } = require('./base-agent');
+const { PythonBridge } = require('../python-bridge');
 
 class VerifierAgent extends BaseAgent {
   constructor(options = {}) {
@@ -33,6 +34,9 @@ class VerifierAgent extends BaseAgent {
     this.verificationResults = [];
     this.currentPhase = null;
     this.verdict = null;
+
+    // PythonBridge for music quality critics (lazy init via shared singleton)
+    this.pythonBridge = null;
   }
 
   getSystemPrompt() {
@@ -447,6 +451,203 @@ Always structure your response as:
     this.currentPhase = null;
     this.verdict = null;
   }
+
+  // ===== Music Quality Verification (Sprint 3 — Task 3.3) =====
+
+  /**
+   * Lazily initialise and start the shared PythonBridge.
+   * @returns {Promise<PythonBridge>}
+   */
+  async ensurePythonBridge() {
+    if (!this.pythonBridge) {
+      this.pythonBridge = PythonBridge.getShared();
+    }
+    if (!this.pythonBridge.isRunning) {
+      const alive = await this.pythonBridge.isAlive();
+      if (!alive) {
+        this.log('info', 'Starting PythonBridge for music critics');
+        await this.pythonBridge.start();
+      } else {
+        this.log('info', 'PythonBridge connected to existing server');
+      }
+    }
+    return this.pythonBridge;
+  }
+
+  /**
+   * Run VLC / BKAS / ADC quality-gate critics on a MIDI file.
+   *
+   * @param {string} midiPath       Path to the MIDI file.
+   * @param {string} [genre]        Genre identifier for context-aware eval.
+   * @param {object} [analysisData] Pre-extracted analysis data (voicings, bass_notes, etc.)
+   * @returns {Promise<{passed: boolean, metrics: Array, report: object}>}
+   */
+  async runMusicCritics(midiPath, genre, analysisData = {}) {
+    await this.ensurePythonBridge();
+    this.log('info', 'Running music critics', { midiPath, genre });
+
+    const hasAnalysisData = analysisData && Object.keys(analysisData).length > 0;
+    const method = hasAnalysisData ? 'run_critics' : 'run_critics_midi';
+    const report = await this.pythonBridge.call(method, {
+      midi_path: midiPath,
+      genre,
+      ...analysisData,
+    });
+
+    // Record proof entries for each metric
+    if (report && Array.isArray(report.metrics)) {
+      for (const metric of report.metrics) {
+        this.addStructuredProof({
+          type: 'music-critic',
+          criticName: metric.name,
+          value: metric.value,
+          threshold: metric.threshold,
+          passed: metric.passed,
+          midiPath,
+        });
+      }
+    }
+
+    this.addProof(
+      'music-critics-overall',
+      report.overall_passed ? 'PASS' : 'FAIL',
+      midiPath
+    );
+
+    return {
+      passed: report.overall_passed,
+      metrics: report.metrics,
+      report,
+    };
+  }
+
+  /**
+   * Preflight gate for score plans before generation.
+   *
+   * Combines deterministic checks with a premium-model verifier pass.
+   * Returns pass/fail plus issues and recommendations.
+   */
+  async preflightScorePlanGate(scorePlan, context = {}) {
+    const issues = [];
+    const recommendations = [];
+
+    const required = ['schema_version', 'prompt', 'bpm', 'key', 'mode', 'sections', 'tracks'];
+    for (const key of required) {
+      if (scorePlan?.[key] === undefined || scorePlan?.[key] === null) {
+        issues.push(`Missing required field: ${key}`);
+      }
+    }
+
+    if (scorePlan?.schema_version !== 'score_plan_v1') {
+      issues.push('schema_version must be score_plan_v1');
+    }
+
+    if (typeof scorePlan?.bpm !== 'number' || Number.isNaN(scorePlan.bpm) || scorePlan.bpm < 30 || scorePlan.bpm > 220) {
+      issues.push('bpm out of valid range [30,220]');
+    }
+
+    if (!Array.isArray(scorePlan?.sections) || scorePlan.sections.length < 1) {
+      issues.push('sections must be a non-empty array');
+    }
+
+    if (!Array.isArray(scorePlan?.tracks) || scorePlan.tracks.length < 1) {
+      issues.push('tracks must be a non-empty array');
+    }
+
+    if (issues.length > 0) {
+      recommendations.push('Fix schema/shape issues before generation');
+    }
+
+    let modelReview = null;
+    const verifierModel = context.model || 'claude-sonnet-4.5';
+    try {
+      const reviewPrompt = `You are a strict music plan verifier. Evaluate this score plan for generation risk and musical coherence.
+
+Return JSON only with fields:
+{
+  "passed": boolean,
+  "issues": string[],
+  "recommendations": string[]
+}
+
+Prompt context:
+${context.prompt || ''}
+
+Score plan:
+${JSON.stringify(scorePlan, null, 2)}`;
+
+      const review = await this.chat(reviewPrompt, { model: verifierModel });
+      const text = (review?.text || '').trim();
+      const jsonText = text.startsWith('{') ? text : (text.match(/\{[\s\S]*\}/)?.[0] || '{}');
+      modelReview = JSON.parse(jsonText);
+    } catch (error) {
+      modelReview = {
+        passed: true,
+        issues: [],
+        recommendations: [`Model verifier unavailable: ${error.message}`]
+      };
+    }
+
+    if (Array.isArray(modelReview?.issues)) {
+      issues.push(...modelReview.issues);
+    }
+    if (Array.isArray(modelReview?.recommendations)) {
+      recommendations.push(...modelReview.recommendations);
+    }
+
+    const passed = issues.length === 0 && modelReview?.passed !== false;
+
+    this.addStructuredProof({
+      type: 'score-plan-preflight',
+      passed,
+      verifierModel,
+      issuesCount: issues.length,
+      recommendationsCount: recommendations.length
+    });
+
+    return {
+      passed,
+      verifierModel,
+      issues,
+      recommendations,
+      modelReview
+    };
+  }
+
+  /**
+   * Analyze rendered audio against target genre expectations.
+   */
+  async analyzeRenderedOutput(audioPath, genre = 'pop') {
+    await this.ensurePythonBridge();
+    this.log('info', 'Analyzing rendered output', { audioPath, genre });
+
+    const report = await this.pythonBridge.call('analyze_output', {
+      audio_path: audioPath,
+      genre,
+    });
+
+    this.addStructuredProof({
+      type: 'output-analysis',
+      audioPath,
+      genre,
+      passed: !!report?.passed,
+      genreMatchScore: report?.genre_match_score,
+    });
+
+    return report;
+  }
+
+  /**
+   * Stop and release the PythonBridge.
+   * @returns {Promise<void>}
+   */
+  async disposePythonBridge() {
+    if (this.pythonBridge) {
+      this.log('info', 'Disposing PythonBridge');
+      await this.pythonBridge.stop();
+      this.pythonBridge = null;
+    }
+  }
 }
 
 module.exports = { VerifierAgent };