copilot-liku-cli 0.0.1

package/src/cli/commands/window.js

@@ -0,0 +1,104 @@
+/**
+ * window command - Window management
+ * @module cli/commands/window
+ */
+
+const path = require('path');
+const { success, error, info, table, dim, highlight } = require('../util/output');
+
+const UI_MODULE = path.resolve(__dirname, '../../main/ui-automation');
+let ui;
+
+function loadUI() {
+  if (!ui) {
+    ui = require(UI_MODULE);
+  }
+  return ui;
+}
+
+/**
+ * Run the window command
+ * 
+ * Usage:
+ *   liku window                     # List all windows
+ *   liku window "Visual Studio"    # Focus window by title
+ *   liku window --active           # Show active window info
+ */
+async function run(args, options) {
+  loadUI();
+  
+  // Show active window info
+  if (options.active) {
+    const win = await ui.getActiveWindow();
+    if (!win) {
+      error('Could not get active window');
+      return { success: false };
+    }
+    
+    if (!options.quiet && !options.json) {
+      const bounds = win.bounds || { x: '?', y: '?', width: '?', height: '?' };
+      console.log(`
+${highlight('Active Window:')}
+  Title:    ${win.title || '(unknown)'}
+  Process:  ${win.processName || '(unknown)'}
+  Class:    ${win.className || '(unknown)'}
+  Handle:   ${win.hwnd}
+  Position: ${bounds.x}, ${bounds.y}
+  Size:     ${bounds.width} x ${bounds.height}
+`);
+    }
+    return { success: true, window: win };
+  }
+  
+  // Focus window by title
+  if (args.length > 0) {
+    const title = args.join(' ');
+    
+    if (!options.quiet) {
+      info(`Focusing window: "${title}"`);
+    }
+    
+    const result = await ui.focusWindow({ title });
+    
+    if (result.success) {
+      if (!options.quiet) {
+        success(`Focused: ${result.window?.title || title}`);
+      }
+      return { success: true, window: result.window };
+    } else {
+      error(`Window not found: "${title}"`);
+      return { success: false, error: 'Window not found' };
+    }
+  }
+  
+  // List all windows
+  if (!options.quiet) {
+    info('Listing windows...');
+  }
+  
+  const windows = await ui.findWindows({});
+  
+  if (windows.length === 0) {
+    if (!options.quiet) {
+      info('No windows found');
+    }
+    return { success: true, windows: [], count: 0 };
+  }
+  
+  if (!options.quiet && !options.json) {
+    console.log(`\n${highlight(`Found ${windows.length} windows:`)}\n`);
+    
+    const rows = windows.map((w, i) => [
+      i + 1,
+      w.title?.substring(0, 50) || dim('(untitled)'),
+      w.processName || '-',
+      `${w.bounds.width}x${w.bounds.height}`,
+    ]);
+    
+    table(rows, ['#', 'Title', 'Process', 'Size']);
+  }
+  
+  return { success: true, windows, count: windows.length };
+}
+
+module.exports = { run };

package/src/cli/liku.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * liku - Copilot-Liku CLI
+ * 
+ * A powerful command-line interface for UI automation and the Copilot-Liku agent.
+ * 
+ * Usage:
+ *   liku                    Start the Electron agent (visual mode)
+ *   liku start              Same as above
+ *   liku click <text>       Click element by text
+ *   liku find <text>        Find UI elements matching text
+ *   liku type <text>        Type text at cursor
+ *   liku keys <combo>       Send key combination (e.g., "ctrl+c")
+ *   liku screenshot [path]  Take screenshot
+ *   liku window <title>     Focus window by title
+ *   liku mouse <x> <y>      Move mouse to coordinates
+ *   liku repl               Interactive automation shell
+ *   liku --help             Show help
+ *   liku --version          Show version
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Resolve paths relative to CLI location
+const CLI_DIR = __dirname;
+const PROJECT_ROOT = path.resolve(CLI_DIR, '../..');
+const COMMANDS_DIR = path.join(CLI_DIR, 'commands');
+
+// Import output utilities
+const { log, success, error, warn, info, dim, highlight } = require('./util/output');
+
+// Package info
+const pkg = require(path.join(PROJECT_ROOT, 'package.json'));
+
+// Command registry
+const COMMANDS = {
+  start: { desc: 'Start the Electron agent with overlay', file: 'start' },
+  click: { desc: 'Click element by text or coordinates', file: 'click', args: '<text|x,y>' },
+  find: { desc: 'Find UI elements matching criteria', file: 'find', args: '<text>' },
+  type: { desc: 'Type text at current cursor position', file: 'type', args: '<text>' },
+  keys: { desc: 'Send keyboard shortcut', file: 'keys', args: '<combo>' },
+  screenshot: { desc: 'Capture screenshot', file: 'screenshot', args: '[path]' },
+  window: { desc: 'Focus or list windows', file: 'window', args: '[title]' },
+  mouse: { desc: 'Move mouse to coordinates', file: 'mouse', args: '<x> <y>' },
+  drag: { desc: 'Drag from one point to another', file: 'drag', args: '<x1> <y1> <x2> <y2>' },
+  scroll: { desc: 'Scroll up or down', file: 'scroll', args: '<up|down> [amount]' },
+  wait: { desc: 'Wait for element to appear', file: 'wait', args: '<text> [timeout]' },
+  repl: { desc: 'Interactive automation shell', file: 'repl' },
+};
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+${highlight('liku')} - Copilot-Liku CLI v${pkg.version}
+${dim('A powerful command-line interface for UI automation')}
+
+${highlight('USAGE:')}
+  liku [command] [options]
+
+${highlight('COMMANDS:')}
+`);
+
+  // Calculate padding for alignment
+  const maxLen = Math.max(...Object.keys(COMMANDS).map(k => k.length + (COMMANDS[k].args?.length || 0)));
+  
+  for (const [name, cmd] of Object.entries(COMMANDS)) {
+    const cmdStr = cmd.args ? `${name} ${cmd.args}` : name;
+    const padding = ' '.repeat(maxLen - cmdStr.length + 4);
+    console.log(`  ${highlight(cmdStr)}${padding}${dim(cmd.desc)}`);
+  }
+
+  console.log(`
+${highlight('OPTIONS:')}
+  --help, -h       Show this help message
+  --version, -v    Show version
+  --json           Output results as JSON (for scripting)
+  --quiet, -q      Suppress non-essential output
+
+${highlight('EXAMPLES:')}
+  ${dim('# Start the visual agent')}
+  liku start
+
+  ${dim('# Click a button by text')}
+  liku click "Submit"
+
+  ${dim('# Find all buttons with "Save" in their text')}
+  liku find "Save" --type Button
+
+  ${dim('# Type text')}
+  liku type "Hello, World!"
+
+  ${dim('# Send keyboard shortcut')}
+  liku keys ctrl+shift+s
+
+  ${dim('# Take a screenshot')}
+  liku screenshot ./capture.png
+
+  ${dim('# Focus VS Code window')}
+  liku window "Visual Studio Code"
+
+  ${dim('# Interactive mode')}
+  liku repl
+
+${highlight('ENVIRONMENT:')}
+  LIKU_DEBUG=1     Enable debug output
+  LIKU_JSON=1      Default to JSON output
+
+${dim('Documentation: https://github.com/TayDa64/copilot-Liku-cli')}
+`);
+}
+
+/**
+ * Show version
+ */
+function showVersion() {
+  console.log(`liku v${pkg.version}`);
+}
+
+/**
+ * Parse command-line arguments
+ */
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const result = {
+    command: null,
+    args: [],
+    flags: {
+      help: false,
+      version: false,
+      json: false,
+      quiet: false,
+      debug: process.env.LIKU_DEBUG === '1',
+    },
+    options: {},
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    
+    if (arg === '--help' || arg === '-h') {
+      result.flags.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.flags.version = true;
+    } else if (arg === '--json') {
+      result.flags.json = true;
+    } else if (arg === '--quiet' || arg === '-q') {
+      result.flags.quiet = true;
+    } else if (arg === '--debug') {
+      result.flags.debug = true;
+    } else if (arg.startsWith('--')) {
+      // Named option (--key=value or --key value)
+      const [key, val] = arg.slice(2).split('=');
+      if (val !== undefined) {
+        result.options[key] = val;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+        result.options[key] = args[++i];
+      } else {
+        result.options[key] = true;
+      }
+    } else if (!result.command) {
+      result.command = arg;
+    } else {
+      result.args.push(arg);
+    }
+    i++;
+  }
+
+  // Default JSON from env
+  if (process.env.LIKU_JSON === '1') {
+    result.flags.json = true;
+  }
+
+  return result;
+}
+
+/**
+ * Load and execute a command module
+ */
+async function executeCommand(name, cmdArgs, flags, options) {
+  const cmdInfo = COMMANDS[name];
+  if (!cmdInfo) {
+    error(`Unknown command: ${name}`);
+    console.log(`\nRun ${highlight('liku --help')} for available commands.`);
+    process.exit(1);
+  }
+
+  const cmdPath = path.join(COMMANDS_DIR, `${cmdInfo.file}.js`);
+  
+  if (!fs.existsSync(cmdPath)) {
+    error(`Command module not found: ${cmdPath}`);
+    process.exit(1);
+  }
+
+  try {
+    const command = require(cmdPath);
+    const result = await command.run(cmdArgs, { ...flags, ...options });
+    
+    // Output result
+    if (flags.json && result !== undefined) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    
+    // Exit with appropriate code
+    if (result && result.success === false) {
+      process.exit(1);
+    }
+  } catch (err) {
+    if (flags.debug) {
+      console.error(err);
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const { command, args, flags, options } = parseArgs(process.argv);
+
+  // Handle global flags
+  if (flags.version) {
+    showVersion();
+    return;
+  }
+
+  if (flags.help || (!command && args.length === 0)) {
+    showHelp();
+    return;
+  }
+
+  // Default command is 'start' (launch Electron)
+  const cmd = command || 'start';
+
+  // Execute the command
+  await executeCommand(cmd, args, flags, options);
+}
+
+// Run
+main().catch(err => {
+  error(err.message);
+  process.exit(1);
+});

package/src/cli/util/output.js

@@ -0,0 +1,174 @@
+/**
+ * CLI Output Utilities
+ * 
+ * Colored console output helpers for the liku CLI.
+ * @module cli/util/output
+ */
+
+// ANSI color codes
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+};
+
+// Check if colors are supported
+const supportsColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+function colorize(color, text) {
+  if (!supportsColor) return text;
+  return `${color}${text}${COLORS.reset}`;
+}
+
+/**
+ * Log a message (no prefix)
+ */
+function log(message) {
+  console.log(message);
+}
+
+/**
+ * Success message (green checkmark)
+ */
+function success(message) {
+  console.log(colorize(COLORS.green, '✓ ') + message);
+}
+
+/**
+ * Error message (red X)
+ */
+function error(message) {
+  console.error(colorize(COLORS.red, '✗ ') + message);
+}
+
+/**
+ * Warning message (yellow)
+ */
+function warn(message) {
+  console.log(colorize(COLORS.yellow, '⚠ ') + message);
+}
+
+/**
+ * Info message (blue)
+ */
+function info(message) {
+  console.log(colorize(COLORS.blue, 'ℹ ') + message);
+}
+
+/**
+ * Dim text (muted)
+ */
+function dim(text) {
+  return colorize(COLORS.dim, text);
+}
+
+/**
+ * Highlight text (cyan/bright)
+ */
+function highlight(text) {
+  return colorize(COLORS.cyan, text);
+}
+
+/**
+ * Bold text
+ */
+function bold(text) {
+  return colorize(COLORS.bright, text);
+}
+
+/**
+ * Format a table of data
+ */
+function table(rows, headers = null) {
+  if (rows.length === 0) return;
+  
+  // Calculate column widths
+  const allRows = headers ? [headers, ...rows] : rows;
+  const colCount = Math.max(...allRows.map(r => r.length));
+  const colWidths = [];
+  
+  for (let i = 0; i < colCount; i++) {
+    colWidths[i] = Math.max(...allRows.map(r => String(r[i] || '').length));
+  }
+  
+  // Print headers
+  if (headers) {
+    const headerLine = headers.map((h, i) => String(h).padEnd(colWidths[i])).join('  ');
+    console.log(bold(headerLine));
+    console.log(dim('-'.repeat(headerLine.length)));
+  }
+  
+  // Print rows
+  for (const row of rows) {
+    const line = row.map((cell, i) => String(cell || '').padEnd(colWidths[i])).join('  ');
+    console.log(line);
+  }
+}
+
+/**
+ * Spinner for long-running operations
+ */
+class Spinner {
+  constructor(message) {
+    this.message = message;
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.frameIndex = 0;
+    this.interval = null;
+  }
+
+  start() {
+    if (!supportsColor) {
+      console.log(this.message + '...');
+      return;
+    }
+    
+    process.stdout.write(this.message + ' ');
+    this.interval = setInterval(() => {
+      process.stdout.write(`\r${this.message} ${this.frames[this.frameIndex]}`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+
+  stop(finalMessage = null) {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (supportsColor) {
+      process.stdout.write('\r' + ' '.repeat(this.message.length + 10) + '\r');
+    }
+    if (finalMessage) {
+      console.log(finalMessage);
+    }
+  }
+
+  succeed(message) {
+    this.stop(colorize(COLORS.green, '✓ ') + (message || this.message));
+  }
+
+  fail(message) {
+    this.stop(colorize(COLORS.red, '✗ ') + (message || this.message));
+  }
+}
+
+module.exports = {
+  log,
+  success,
+  error,
+  warn,
+  info,
+  dim,
+  highlight,
+  bold,
+  table,
+  Spinner,
+  COLORS,
+  colorize,
+};