copilot-liku-cli 0.0.3 → 0.0.8

package/src/main/agents/builder.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');
 
@@ -38,6 +39,9 @@ class BuilderAgent extends BaseAgent {
     this.blockers = [];
     this.attemptCount = 0;
     this.maxAttempts = 3;
+
+    // PythonBridge for music generation (lazy init via shared singleton)
+    this.pythonBridge = null;
   }
 
   getSystemPrompt() {
@@ -479,6 +483,213 @@ Provide the change in unified diff format:
     this.blockers = [];
     this.attemptCount = 0;
   }
+
+  // ===== Music Generation Methods (Sprint 3 — Task 3.2) =====
+
+  /**
+   * 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 generation');
+        await this.pythonBridge.start();
+      } else {
+        this.log('info', 'PythonBridge connected to existing server');
+      }
+    }
+    return this.pythonBridge;
+  }
+
+  /**
+   * Generate music synchronously via the Python engine.
+   *
+   * @param {string} prompt  Natural-language music prompt.
+   * @param {object} [options]  Extra params forwarded to generate_sync.
+   * @returns {Promise<object>}  Full GenerationResult dict from the server.
+   */
+  async generateMusic(prompt, options = {}) {
+    await this.ensurePythonBridge();
+    if (options.trackProgress === undefined) {
+      options.trackProgress = true;
+    }
+    this.log('info', 'Generating music', { prompt, options });
+
+    const result = await this.pythonBridge.call('generate_sync', {
+      prompt,
+      ...options,
+    });
+
+    if (options.trackProgress && result && result.task_id) {
+      await this.pollProgress(result.task_id, options.progressIntervalMs, options.progressTimeoutMs);
+    }
+
+    this.log('info', 'Music generation complete', {
+      taskId: result.task_id,
+      success: result.success,
+    });
+
+    this.addStructuredProof({
+      type: 'music-generation',
+      prompt,
+      taskId: result.task_id,
+      success: result.success,
+      midiPath: result.midi_path || null,
+    });
+
+    return result;
+  }
+
+  /**
+   * Generate music from a Score Plan (Copilot orchestration).
+   *
+   * @param {object} scorePlan  Score Plan dict with at least a prompt.
+   * @param {object} [options]  Extra params forwarded to generate_sync.
+   * @returns {Promise<object>}  Full GenerationResult dict from the server.
+   */
+  async generateMusicFromScorePlan(scorePlan, options = {}) {
+    await this.ensurePythonBridge();
+    if (options.trackProgress === undefined) {
+      options.trackProgress = true;
+    }
+    const planPrompt = (scorePlan && scorePlan.prompt) ? String(scorePlan.prompt) : '';
+    const prompt = planPrompt || options.prompt || 'Score plan generation';
+    this.log('info', 'Generating music from score plan', { prompt, options });
+
+    const rpcTimeoutMs = Number(options.rpcTimeoutMs || 900000);
+    const watchdogIntervalMs = Number(options.watchdogIntervalMs || 15000);
+    const callStartedAt = Date.now();
+    const watchdog = setInterval(() => {
+      const elapsedSec = Math.floor((Date.now() - callStartedAt) / 1000);
+      this.log('info', 'Waiting on generate_sync...', {
+        elapsedSec,
+        rpcTimeoutMs,
+        prompt: prompt.slice(0, 80)
+      });
+    }, watchdogIntervalMs);
+
+    let result;
+    try {
+      result = await this.pythonBridge.call('generate_sync', {
+        prompt,
+        score_plan: scorePlan,
+        ...options,
+      }, rpcTimeoutMs);
+    } finally {
+      clearInterval(watchdog);
+    }
+
+    if (options.trackProgress && result && result.task_id) {
+      await this.pollProgress(result.task_id, options.progressIntervalMs, options.progressTimeoutMs);
+    }
+
+    this.log('info', 'Score plan generation complete', {
+      taskId: result.task_id,
+      success: result.success,
+    });
+
+    this.addStructuredProof({
+      type: 'music-generation',
+      prompt,
+      taskId: result.task_id,
+      success: result.success,
+      midiPath: result.midi_path || null,
+      scorePlan: true,
+    });
+
+    return result;
+  }
+
+  /**
+   * Kick off an async generation with a section override.
+   *
+   * @param {string} taskId   Original task to reference.
+   * @param {string} section  Section identifier to regenerate.
+   * @param {object} [options]
+   * @returns {Promise<object>}  { task_id, request_id }
+   */
+  async regenerateSection(taskId, section, options = {}) {
+    await this.ensurePythonBridge();
+    this.log('info', 'Regenerating section', { taskId, section });
+
+    const result = await this.pythonBridge.call('generate', {
+      prompt: options.prompt || `Regenerate section ${section}`,
+      section,
+      original_task_id: taskId,
+      ...options,
+    });
+
+    return result;
+  }
+
+  /**
+   * Poll the status of a running generation task.
+   *
+   * @param {string} taskId
+   * @returns {Promise<object>}
+   */
+  async getGenerationStatus(taskId) {
+    await this.ensurePythonBridge();
+    return this.pythonBridge.call('get_status', { task_id: taskId });
+  }
+
+  /**
+   * Poll progress for a task and log status for visibility.
+   *
+   * @param {string} taskId
+   * @param {number} [intervalMs=1000]
+   * @param {number} [maxMs=600000]  // 10 minutes default
+   * @returns {Promise<object>}
+   */
+  async pollProgress(taskId, intervalMs = 1000, maxMs = 600000) {
+    await this.ensurePythonBridge();
+    const start = Date.now();
+    while (true) {
+      const status = await this.getGenerationStatus(taskId);
+      if (status && status.progress) {
+        const { step, percent, message } = status.progress;
+        this.log('info', 'Progress', { taskId, step, percent, message });
+      }
+      const done = status && (status.status === 'completed' || status.status === 'failed' || status.status === 'cancelled');
+      if (done) {
+        return status;
+      }
+      if (Date.now() - start > maxMs) {
+        this.log('warn', 'Progress polling timed out', { taskId });
+        return status;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+
+  /**
+   * Cancel a running generation task.
+   *
+   * @param {string} taskId
+   * @returns {Promise<object>}
+   */
+  async cancelGeneration(taskId) {
+    await this.ensurePythonBridge();
+    this.log('info', 'Cancelling generation', { taskId });
+    return this.pythonBridge.call('cancel', { task_id: taskId });
+  }
+
+  /**
+   * 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 = { BuilderAgent };

package/src/main/agents/index.js

@@ -15,6 +15,7 @@ const { AgentOrchestrator } = require('./orchestrator');
 const { SupervisorAgent } = require('./supervisor');
 const { BuilderAgent } = require('./builder');
 const { VerifierAgent } = require('./verifier');
+const { ProducerAgent } = require('./producer');
 const { ResearcherAgent } = require('./researcher');
 const { AgentStateManager } = require('./state-manager');
 
@@ -23,14 +24,15 @@ module.exports = {
   SupervisorAgent,
   BuilderAgent,
   VerifierAgent,
+  ProducerAgent,
   ResearcherAgent,
   AgentStateManager,
   
   // Factory function for creating configured orchestrator
-  createAgentSystem: (options = {}) => {
+  createAgentSystem: (aiService, options = {}) => {
     const stateManager = new AgentStateManager(options.statePath);
     
-    const modelMetadata = options.aiService?.getModelMetadata?.() || null;
+    const modelMetadata = aiService?.getModelMetadata?.() || null;
     
     if (modelMetadata) {
       stateManager.setModelMetadata(modelMetadata);
@@ -38,14 +40,15 @@ module.exports = {
     
     const orchestrator = new AgentOrchestrator({
       stateManager,
-      aiService: options.aiService,
+      aiService: aiService,
       maxRecursionDepth: options.maxRecursionDepth || 3,
       maxSubCalls: options.maxSubCalls || 10,
       enableLongContext: options.enableLongContext !== false,
       modelMetadata
     });
     
-    return orchestrator;
+    // Return object with both orchestrator and stateManager
+    return { orchestrator, stateManager };
   },
   
   // Recovery function for checkpoint restoration

package/src/main/agents/orchestrator.js

@@ -15,6 +15,7 @@ const EventEmitter = require('events');
 const { SupervisorAgent } = require('./supervisor');
 const { BuilderAgent } = require('./builder');
 const { VerifierAgent } = require('./verifier');
+const { ProducerAgent } = require('./producer');
 const { ResearcherAgent } = require('./researcher');
 const { AgentStateManager } = require('./state-manager');
 const { AgentRole } = require('./base-agent');
@@ -64,6 +65,7 @@ class AgentOrchestrator extends EventEmitter {
     this.agents.set(AgentRole.BUILDER, new BuilderAgent(commonOptions));
     this.agents.set(AgentRole.VERIFIER, new VerifierAgent(commonOptions));
     this.agents.set(AgentRole.RESEARCHER, new ResearcherAgent(commonOptions));
+    this.agents.set(AgentRole.PRODUCER, new ProducerAgent(commonOptions));
     
     // Register agents with state manager
     for (const [role, agent] of this.agents) {
@@ -270,6 +272,10 @@ class AgentOrchestrator extends EventEmitter {
     return this.agents.get(AgentRole.RESEARCHER);
   }
 
+  getProducer() {
+    return this.agents.get(AgentRole.PRODUCER);
+  }
+
   // ===== Convenience Methods =====
 
   async research(query, options = {}) {
@@ -302,6 +308,13 @@ class AgentOrchestrator extends EventEmitter {
     });
   }
 
+  async produce(task, options = {}) {
+    return this.execute(task, {
+      ...options,
+      startAgent: AgentRole.PRODUCER
+    });
+  }
+
   // ===== State & Diagnostics =====
 
   getState() {