copilot-liku-cli 0.0.1

package/TESTING.md

@@ -0,0 +1,274 @@
+# Testing Guide
+
+## Manual Testing Checklist
+
+### Initial Launch
+- [ ] Application starts without errors
+- [ ] Tray icon appears in system tray/menu bar
+- [ ] Overlay window is invisible and click-through
+- [ ] Chat window is hidden by default
+
+### Tray Icon Functionality
+- [ ] Right-click tray icon shows context menu
+- [ ] "Open Chat" menu item works
+- [ ] "Toggle Overlay" menu item works
+- [ ] "Quit" menu item closes application
+- [ ] Click tray icon toggles chat (macOS)
+
+### Global Hotkeys
+- [ ] `Ctrl+Alt+Space` (Cmd+Alt+Space on macOS) toggles chat window
+- [ ] `Ctrl+Shift+O` (Cmd+Shift+O on macOS) toggles overlay visibility
+- [ ] Hotkeys work from any application
+
+### Chat Window
+- [ ] Window appears at bottom-right corner
+- [ ] Window is resizable
+- [ ] Window can be dragged
+- [ ] Closing window hides it (doesn't quit app)
+- [ ] Window shows welcome message on first open
+- [ ] Mode buttons are visible and functional
+
+### Passive Mode
+- [ ] Overlay is completely click-through
+- [ ] Can interact with applications normally
+- [ ] No dots visible on overlay
+- [ ] Mode indicator not visible
+
+### Selection Mode
+- [ ] Click "Selection" button activates mode
+- [ ] Dots appear on overlay (coarse grid, ~100px spacing)
+- [ ] Mode indicator appears in top-right
+- [ ] Dots are clickable
+- [ ] Clicking dot shows message in chat
+- [ ] Automatically returns to passive mode after dot click
+- [ ] Cannot interact with applications behind overlay
+
+### Chat Functionality
+- [ ] Can type message in input field
+- [ ] Enter key sends message
+- [ ] Send button works
+- [ ] Messages appear in chat history with timestamp
+- [ ] User messages appear on right (blue)
+- [ ] Agent messages appear on left (gray)
+- [ ] System messages appear in center (italic)
+- [ ] Chat history scrolls automatically
+- [ ] Scrollbar works correctly
+
+### IPC Communication
+- [ ] Dot selection in overlay appears in chat
+- [ ] Mode changes from chat affect overlay
+- [ ] Messages from chat get echoed back (stub agent)
+
+### Window Management
+- [ ] Overlay stays on top of all windows
+- [ ] Chat window can go behind other windows
+- [ ] Minimizing chat window works
+- [ ] Reopening chat restores position and size
+- [ ] Chat window persists messages between hide/show
+
+### Platform-Specific (macOS)
+- [ ] App hidden from Dock
+- [ ] Overlay floats above fullscreen apps
+- [ ] Tray icon visible in menu bar
+- [ ] Mission Control doesn't show overlay as separate space
+- [ ] Works correctly with multiple displays
+
+### Platform-Specific (Windows)
+- [ ] Tray icon visible in system tray
+- [ ] Overlay stays above most windows
+- [ ] Works with fullscreen windows
+- [ ] Alt+Tab doesn't show overlay
+- [ ] Works correctly with multiple displays
+
+### Performance
+- [ ] Application starts quickly (< 3 seconds)
+- [ ] Memory usage stays reasonable (< 300MB)
+- [ ] CPU usage low when idle (< 1%)
+- [ ] No lag when switching modes
+- [ ] Smooth animations and transitions
+- [ ] No memory leaks after extended use
+
+### Edge Cases
+- [ ] Changing screen resolution updates overlay
+- [ ] Disconnecting/reconnecting displays works
+- [ ] Switching between fullscreen apps works
+- [ ] Overlay works on secondary displays
+- [ ] System sleep/wake preserves state
+- [ ] Rapid mode switching doesn't cause issues
+- [ ] Many dots can be clicked in sequence
+
+## Automated Testing
+
+### Unit Tests (Future)
+```javascript
+// Example test structure
+describe('Overlay Window', () => {
+  it('should create overlay window', () => {
+    // Test window creation
+  });
+  
+  it('should set click-through mode', () => {
+    // Test ignore mouse events
+  });
+  
+  it('should generate dot grid', () => {
+    // Test dot generation
+  });
+});
+
+describe('IPC Communication', () => {
+  it('should send dot selection', () => {
+    // Test IPC message
+  });
+  
+  it('should handle mode changes', () => {
+    // Test mode switching
+  });
+});
+```
+
+### Integration Tests (Future)
+```javascript
+const { Application } = require('spectron');
+
+describe('Application Launch', () => {
+  let app;
+  
+  beforeEach(async () => {
+    app = new Application({
+      path: electron,
+      args: [path.join(__dirname, '..')]
+    });
+    await app.start();
+  });
+  
+  afterEach(async () => {
+    if (app && app.isRunning()) {
+      await app.stop();
+    }
+  });
+  
+  it('should show tray icon', async () => {
+    // Test tray presence
+  });
+});
+```
+
+## Performance Testing
+
+### Memory Profiling
+1. Open Chrome DevTools (Cmd+Alt+I / Ctrl+Shift+I)
+2. Go to Memory tab
+3. Take heap snapshot
+4. Use application for 5-10 minutes
+5. Take another snapshot
+6. Compare for memory leaks
+
+### CPU Profiling
+1. Open Performance tab in DevTools
+2. Record while using application
+3. Look for long tasks (> 50ms)
+4. Identify optimization opportunities
+
+### Startup Time
+```bash
+# Measure startup time
+time npm start
+# Target: < 3 seconds to first window
+```
+
+## Security Testing
+
+### CSP Validation
+1. Open DevTools Console
+2. Look for CSP violations
+3. Should see no errors
+
+### IPC Security
+1. Verify context isolation is enabled
+2. Verify node integration is disabled
+3. Check preload scripts expose only necessary APIs
+
+### Dependency Audit
+```bash
+npm audit
+# Should show 0 vulnerabilities
+```
+
+## Browser Testing
+
+### Overlay Rendering
+- [ ] Transparent background works
+- [ ] Dots render correctly
+- [ ] Labels visible and positioned correctly
+- [ ] Hover effects work smoothly
+- [ ] CSS transforms work correctly
+
+### Chat Rendering
+- [ ] Dark theme displays correctly
+- [ ] Fonts load properly
+- [ ] Scrolling is smooth
+- [ ] Input field responsive
+- [ ] Buttons work correctly
+
+## Debugging Tips
+
+### Enable DevTools
+
+```javascript
+// In main process
+overlayWindow.webContents.openDevTools({ mode: 'detach' });
+chatWindow.webContents.openDevTools({ mode: 'detach' });
+```
+
+### Console Logging
+
+```javascript
+// Main process logs
+console.log('Main process:', data);
+
+// Renderer process logs appear in DevTools console
+console.log('Renderer:', data);
+```
+
+### IPC Debugging
+
+```javascript
+// Log all IPC messages
+ipcMain.on('*', (event, ...args) => {
+  console.log('IPC:', event.channel, args);
+});
+```
+
+### Network Monitoring
+
+Use DevTools Network tab to check:
+- No unexpected network requests
+- All local resources load correctly
+
+## Known Issues
+
+### macOS
+- Mission Control may show overlay briefly when switching spaces
+- Some fullscreen games might not be covered by overlay
+- Accessibility permissions required for synthetic input
+
+### Windows
+- Exclusive fullscreen games not covered
+- Some UWP apps may be above overlay
+- Windows Defender SmartScreen may flag first run
+
+### General
+- High DPI displays may need scaling adjustments
+- Multiple displays require per-display dot generation
+- Very large screens (> 4K) may need coarser grid
+
+## Reporting Issues
+
+When reporting issues, include:
+1. Operating system and version
+2. Electron version (`npm list electron`)
+3. Steps to reproduce
+4. Expected vs actual behavior
+5. Console logs (DevTools + terminal)
+6. Screenshots if applicable

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "copilot-liku-cli",
+  "version": "0.0.1",
+  "description": "GitHub Copilot CLI with headless agent + ultra-thin overlay architecture",
+  "main": "src/main/index.js",
+  "bin": {
+    "liku": "./src/cli/liku.js"
+  },
+  "scripts": {
+    "start": "node scripts/start.js",
+    "test": "node scripts/test-grid.js",
+    "test:ui": "node scripts/test-ui-automation-baseline.js",
+    "liku": "node src/cli/liku.js"
+  },
+  "keywords": [
+    "copilot",
+    "electron",
+    "overlay",
+    "agent",
+    "cli",
+    "automation",
+    "ui-automation",
+    "ai"
+  ],
+  "author": "GitHub",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TayDa64/copilot-Liku-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TayDa64/copilot-Liku-cli/issues"
+  },
+  "homepage": "https://github.com/TayDa64/copilot-Liku-cli#readme",
+  "engines": {
+    "node": ">=22.0.0",
+    "npm": ">=10.0.0"
+  },
+  "os": [
+    "darwin",
+    "win32",
+    "linux"
+  ],
+  "files": [
+    "src/",
+    "scripts/start.js",
+    "README.md",
+    "LICENSE.md",
+    "QUICKSTART.md",
+    "INSTALLATION.md",
+    "CONTRIBUTING.md",
+    "ARCHITECTURE.md",
+    "CONFIGURATION.md",
+    "TESTING.md",
+    "ELECTRON_README.md",
+    "PROJECT_STATUS.md"
+  ],
+  "dependencies": {
+    "electron": "^35.7.5"
+  }
+}

package/scripts/start.js

@@ -0,0 +1,30 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Copy environment and force Electron to run with its GUI
+const env = { ...process.env };
+
+if (env.ELECTRON_RUN_AS_NODE) {
+  console.warn('Clearing ELECTRON_RUN_AS_NODE before launching Electron GUI.');
+  delete env.ELECTRON_RUN_AS_NODE;
+}
+
+// The electron package exports the path to the binary when required from Node
+const electronPath = require('electron');
+const appDir = path.resolve(__dirname, '..');
+
+const child = spawn(electronPath, ['.'], {
+  cwd: appDir,
+  env,
+  stdio: 'inherit',
+  windowsHide: false
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    console.log(`Electron exited via signal ${signal}`);
+    process.exit(0);
+  } else {
+    process.exit(code ?? 0);
+  }
+});

package/src/cli/commands/agent.js

@@ -0,0 +1,327 @@
+/**
+ * Agent CLI Command
+ * 
+ * CLI interface for the multi-agent system.
+ * Supports spawning agents, running tasks, and managing state.
+ * 
+ * Usage:
+ *   agent spawn supervisor   - Spawn supervisor agent
+ *   agent run <task>         - Run task through orchestrator
+ *   agent status             - Show agent system status
+ *   agent reset              - Reset all agents
+ */
+
+const path = require('path');
+
+// Lazy load to avoid circular dependencies
+let agentSystem = null;
+let orchestrator = null;
+
+/**
+ * Create an AI service adapter that wraps the existing ai-service.js
+ * to provide the interface expected by the agent system
+ */
+function createAIServiceAdapter() {
+  try {
+    const aiServiceModule = require('../../main/ai-service');
+    
+    return {
+      // Adapter method: agents call chat(), we call sendMessage()
+      chat: async (message, options = {}) => {
+        const result = await aiServiceModule.sendMessage(message, {
+          includeVisualContext: options.includeVisual || false
+        });
+        
+        if (!result.success) {
+          throw new Error(result.error || 'AI service call failed');
+        }
+        
+        return {
+          text: result.message,
+          provider: result.provider,
+          success: true
+        };
+      },
+      
+      // Pass through other methods
+      getStatus: aiServiceModule.getStatus,
+      setProvider: aiServiceModule.setProvider,
+      getCurrentCopilotModel: aiServiceModule.getCurrentCopilotModel,
+      addVisualContext: aiServiceModule.addVisualContext
+    };
+  } catch (e) {
+    console.warn('AI service not available:', e.message);
+    return null;
+  }
+}
+
+function getOrchestrator() {
+  if (!orchestrator) {
+    const { createAgentSystem } = require('../../main/agents');
+    
+    // Create AI service adapter
+    const aiService = createAIServiceAdapter();
+    
+    if (!aiService) {
+      console.warn('AI service adapter not available, agents will have limited capability');
+    }
+    
+    orchestrator = createAgentSystem({
+      aiService,
+      statePath: path.join(process.cwd(), '.github', 'agent_state.json'),
+      maxRecursionDepth: 3,
+      maxSubCalls: 10,
+      enableLongContext: true
+    });
+    
+    // Setup event listeners
+    orchestrator.on('agent:log', (entry) => {
+      console.log(`[${entry.role}] ${entry.message}`);
+    });
+    
+    orchestrator.on('handoff:execute', (handoff) => {
+      console.log(`→ Handoff: ${handoff.from} → ${handoff.to}`);
+    });
+    
+    orchestrator.on('task:complete', ({ task, result }) => {
+      console.log(`✓ Task completed: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+    });
+  }
+  
+  return orchestrator;
+}
+
+// ===== CLI Commands =====
+
+async function handleSpawn(args) {
+  const [agentType] = args;
+  const validTypes = ['supervisor', 'builder', 'verifier', 'researcher'];
+  
+  if (!agentType || !validTypes.includes(agentType.toLowerCase())) {
+    console.log('Usage: agent spawn <supervisor|builder|verifier|researcher>');
+    console.log('\nAvailable agents:');
+    console.log('  supervisor  - Orchestrates tasks, decomposes plans');
+    console.log('  builder     - Implements code changes');
+    console.log('  verifier    - Validates changes');
+    console.log('  researcher  - Gathers context and information');
+    return;
+  }
+  
+  const orch = getOrchestrator();
+  const agent = orch.getAgent(agentType.toLowerCase());
+  
+  if (agent) {
+    console.log(`✓ ${agentType} agent ready`);
+    console.log(`  ID: ${agent.id}`);
+    console.log(`  Capabilities: ${agent.capabilities.join(', ')}`);
+  } else {
+    console.error(`✗ Failed to spawn ${agentType} agent`);
+  }
+}
+
+async function handleRun(args) {
+  const task = args.join(' ');
+  
+  if (!task) {
+    console.log('Usage: agent run <task description>');
+    console.log('\nExample:');
+    console.log('  agent run "Add error handling to the login function"');
+    console.log('  agent run "Research how authentication is implemented"');
+    return;
+  }
+  
+  console.log(`\n🤖 Starting multi-agent task...`);
+  console.log(`Task: ${task}\n`);
+  
+  const orch = getOrchestrator();
+  
+  try {
+    const result = await orch.orchestrate(task);
+    
+    console.log('\n' + '='.repeat(50));
+    console.log('RESULT');
+    console.log('='.repeat(50));
+    
+    if (result.success) {
+      console.log('✓ Task completed successfully');
+      
+      if (result.result?.summary) {
+        console.log('\nSummary:');
+        console.log(JSON.stringify(result.result.summary, null, 2));
+      }
+      
+      if (result.result?.diffs?.length > 0) {
+        console.log(`\nChanges: ${result.result.diffs.length} files modified`);
+      }
+    } else {
+      console.log('✗ Task failed');
+      console.log(`Error: ${result.error || result.result?.error || 'Unknown error'}`);
+    }
+    
+    console.log(`\nHandoffs: ${result.handoffs?.length || 0}`);
+    console.log(`Session: ${result.session}`);
+    
+  } catch (error) {
+    console.error(`✗ Error: ${error.message}`);
+  }
+}
+
+async function handleStatus() {
+  const orch = getOrchestrator();
+  const state = orch.getState();
+  const stats = orch.getStats();
+  
+  console.log('\n🤖 Multi-Agent System Status\n');
+  
+  console.log('Session:');
+  if (state.session) {
+    console.log(`  ID: ${state.session.id}`);
+    console.log(`  Started: ${state.session.startedAt}`);
+    console.log(`  Tasks: ${state.session.tasks?.length || 0}`);
+    console.log(`  Handoffs: ${state.session.handoffs?.length || 0}`);
+  } else {
+    console.log('  No active session');
+  }
+  
+  console.log('\nAgents:');
+  for (const { role, state: agentState } of state.agents) {
+    console.log(`  ${role}:`);
+    console.log(`    Depth: ${agentState.currentDepth}/${agentState.maxRecursionDepth || 3}`);
+    console.log(`    Sub-calls: ${agentState.subCallCount}`);
+  }
+  
+  console.log('\nStatistics:');
+  console.log(`  Sessions: ${stats.sessions}`);
+  console.log(`  Completed: ${stats.tasksCompleted}`);
+  console.log(`  Failed: ${stats.tasksFailed}`);
+  console.log(`  In Progress: ${stats.tasksInProgress}`);
+  console.log(`  Queued: ${stats.tasksQueued}`);
+}
+
+async function handleReset() {
+  const orch = getOrchestrator();
+  orch.reset();
+  console.log('✓ Agent system reset');
+}
+
+async function handleResearch(args) {
+  const query = args.join(' ');
+  
+  if (!query) {
+    console.log('Usage: agent research <query>');
+    return;
+  }
+  
+  console.log(`\n🔍 Researching: ${query}\n`);
+  
+  const orch = getOrchestrator();
+  
+  try {
+    const result = await orch.research(query);
+    
+    if (result.success && result.result?.findings) {
+      console.log('\nFindings:');
+      console.log(result.result.findings);
+      
+      if (result.result.sources?.length > 0) {
+        console.log('\nSources:');
+        result.result.sources.forEach(s => console.log(`  - ${s}`));
+      }
+    } else {
+      console.log('✗ Research failed');
+      console.log(result.error || 'No findings');
+    }
+  } catch (error) {
+    console.error(`✗ Error: ${error.message}`);
+  }
+}
+
+async function handleVerify(args) {
+  console.log('\n✓ Running verification pipeline...\n');
+  
+  const orch = getOrchestrator();
+  
+  try {
+    const result = await orch.verify([], {
+      includeE2E: args.includes('--e2e'),
+      continueOnFailure: args.includes('--continue')
+    });
+    
+    if (result.success) {
+      console.log('✓ All verifications passed');
+    } else {
+      console.log('✗ Verification failed');
+      
+      if (result.result?.verdict?.suggestions) {
+        console.log('\nSuggestions:');
+        result.result.verdict.suggestions.forEach(s => console.log(`  - ${s}`));
+      }
+    }
+    
+    if (result.result?.results) {
+      console.log('\nPhase Results:');
+      result.result.results.forEach(r => {
+        const status = r.passed ? '✓' : (r.skipped ? '-' : '✗');
+        console.log(`  ${status} ${r.phase}`);
+      });
+    }
+  } catch (error) {
+    console.error(`✗ Error: ${error.message}`);
+  }
+}
+
+// ===== Main Entry Point =====
+
+async function main(args = []) {
+  const [command, ...rest] = args;
+  
+  if (!command) {
+    console.log('Copilot-Liku Multi-Agent System');
+    console.log('================================\n');
+    console.log('Commands:');
+    console.log('  spawn <type>     - Spawn an agent (supervisor/builder/verifier/researcher)');
+    console.log('  run <task>       - Run a task through the orchestrator');
+    console.log('  research <query> - Research a topic');
+    console.log('  verify           - Run verification pipeline');
+    console.log('  status           - Show system status');
+    console.log('  reset            - Reset all agents');
+    console.log('\nExamples:');
+    console.log('  agent spawn supervisor');
+    console.log('  agent run "Add input validation to user form"');
+    console.log('  agent research "How is authentication handled?"');
+    console.log('  agent verify --e2e');
+    return;
+  }
+  
+  switch (command.toLowerCase()) {
+    case 'spawn':
+      await handleSpawn(rest);
+      break;
+    case 'run':
+      await handleRun(rest);
+      break;
+    case 'research':
+      await handleResearch(rest);
+      break;
+    case 'verify':
+      await handleVerify(rest);
+      break;
+    case 'status':
+      await handleStatus();
+      break;
+    case 'reset':
+      await handleReset();
+      break;
+    default:
+      console.log(`Unknown command: ${command}`);
+      console.log('Run "agent" without arguments for help');
+  }
+}
+
+// Export for use as module
+module.exports = { main, getOrchestrator };
+
+// Run if called directly
+if (require.main === module) {
+  main(process.argv.slice(2));
+}