copilot-liku-cli 0.0.1

package/src/cli/commands/repl.js

@@ -0,0 +1,290 @@
+/**
+ * repl command - Interactive automation shell
+ * @module cli/commands/repl
+ */
+
+const readline = require('readline');
+const path = require('path');
+const { success, error, info, warn, highlight, dim, bold } = require('../util/output');
+
+const UI_MODULE = path.resolve(__dirname, '../../main/ui-automation');
+let ui;
+
+function loadUI() {
+  if (!ui) {
+    ui = require(UI_MODULE);
+  }
+  return ui;
+}
+
+/**
+ * Show REPL help
+ */
+function showHelp() {
+  console.log(`
+${bold('Liku Interactive Shell')}
+${dim('Type commands to execute UI automation')}
+
+${highlight('Commands:')}
+  click <text|x,y>       Click element or coordinates
+  find <text>            Find elements matching text
+  type <text>            Type text
+  keys <combo>           Send key combo (ctrl+c, enter, etc.)
+  window [title]         List or focus windows
+  mouse <x> <y>          Move mouse
+  pos                    Show mouse position
+  screenshot [path]      Take screenshot
+  scroll <up|down> [n]   Scroll direction
+  wait <text> [ms]       Wait for element
+  sleep <ms>             Wait for milliseconds
+  
+${highlight('Special:')}
+  help                   Show this help
+  clear                  Clear screen
+  exit, quit, q          Exit REPL
+  
+${highlight('Examples:')}
+  ${dim('> click "Submit"')}
+  ${dim('> find "Save" | Button')}
+  ${dim('> type "Hello World"')}
+  ${dim('> keys ctrl+s')}
+  ${dim('> window "Notepad"')}
+`);
+}
+
+/**
+ * Parse and execute a REPL command
+ */
+async function executeCommand(line) {
+  const parts = line.trim().split(/\s+/);
+  const cmd = parts[0]?.toLowerCase();
+  const args = parts.slice(1);
+  
+  if (!cmd) return;
+  
+  switch (cmd) {
+    case 'help':
+    case '?':
+      showHelp();
+      break;
+      
+    case 'clear':
+    case 'cls':
+      console.clear();
+      break;
+      
+    case 'exit':
+    case 'quit':
+    case 'q':
+      return 'exit';
+      
+    case 'click': {
+      const target = args.join(' ');
+      if (!target) {
+        error('Usage: click <text|x,y>');
+        break;
+      }
+      
+      const coordMatch = target.match(/^(\d+)[,\s]+(\d+)$/);
+      if (coordMatch) {
+        const x = parseInt(coordMatch[1], 10);
+        const y = parseInt(coordMatch[2], 10);
+        const result = await ui.clickAt(x, y);
+        result.success ? success(`Clicked at (${x}, ${y})`) : error('Click failed');
+      } else {
+        const result = await ui.click({ text: target });
+        result.success 
+          ? success(`Clicked "${result.element?.name || target}"`)
+          : error(`Not found: "${target}"`);
+      }
+      break;
+    }
+    
+    case 'find': {
+      const text = args.join(' ');
+      if (!text) {
+        error('Usage: find <text>');
+        break;
+      }
+      
+      // Check for type filter: find "text" | Button
+      const filterMatch = text.match(/^(.+?)\s*\|\s*(\w+)$/);
+      const criteria = filterMatch 
+        ? { text: filterMatch[1].trim(), controlType: filterMatch[2] }
+        : { text };
+      
+      const result = await ui.findElements(criteria);
+      if (result.count === 0) {
+        info('No elements found');
+      } else {
+        console.log(`Found ${result.count} elements:`);
+        result.elements.slice(0, 10).forEach((el, i) => {
+          console.log(`  ${i + 1}. ${el.name || '(unnamed)'} [${el.controlType}] @ ${el.bounds?.x},${el.bounds?.y}`);
+        });
+        if (result.count > 10) {
+          console.log(dim(`  ... and ${result.count - 10} more`));
+        }
+      }
+      break;
+    }
+    
+    case 'type': {
+      const text = args.join(' ');
+      if (!text) {
+        error('Usage: type <text>');
+        break;
+      }
+      const result = await ui.typeText(text);
+      result.success ? success(`Typed ${text.length} chars`) : error('Type failed');
+      break;
+    }
+    
+    case 'keys':
+    case 'key': {
+      const combo = args.join(' ');
+      if (!combo) {
+        error('Usage: keys <combo>');
+        break;
+      }
+      // Simple conversion
+      const sendKeys = combo
+        .replace(/ctrl\+/gi, '^')
+        .replace(/alt\+/gi, '%')
+        .replace(/shift\+/gi, '+')
+        .replace(/enter/gi, '{ENTER}')
+        .replace(/tab/gi, '{TAB}')
+        .replace(/esc(ape)?/gi, '{ESC}');
+      const result = await ui.sendKeys(sendKeys);
+      result.success ? success(`Sent: ${combo}`) : error('Keys failed');
+      break;
+    }
+    
+    case 'window':
+    case 'win': {
+      const title = args.join(' ');
+      if (title) {
+        const result = await ui.focusWindow({ title });
+        result.success 
+          ? success(`Focused: ${result.window?.title || title}`)
+          : error(`Window not found: "${title}"`);
+      } else {
+        const windows = await ui.findWindows({});
+        console.log(`${windows.length} windows:`);
+        windows.slice(0, 15).forEach((w, i) => {
+          console.log(`  ${i + 1}. ${w.title?.substring(0, 50) || '(untitled)'} [${w.processName}]`);
+        });
+      }
+      break;
+    }
+    
+    case 'mouse':
+    case 'move': {
+      if (args.length < 2) {
+        error('Usage: mouse <x> <y>');
+        break;
+      }
+      const x = parseInt(args[0], 10);
+      const y = parseInt(args[1], 10);
+      const result = await ui.moveMouse(x, y);
+      result.success ? success(`Moved to (${x}, ${y})`) : error('Move failed');
+      break;
+    }
+    
+    case 'pos':
+    case 'position': {
+      const pos = await ui.getMousePosition();
+      console.log(`Mouse: (${pos.x}, ${pos.y})`);
+      break;
+    }
+    
+    case 'screenshot':
+    case 'ss': {
+      const savePath = args[0] || `screenshot_${Date.now()}.png`;
+      const result = await ui.screenshot({ path: savePath });
+      result.success ? success(`Saved: ${result.path}`) : error('Screenshot failed');
+      break;
+    }
+    
+    case 'scroll': {
+      const dir = args[0]?.toLowerCase();
+      const amount = parseInt(args[1], 10) || 3;
+      if (!['up', 'down', 'left', 'right'].includes(dir)) {
+        error('Usage: scroll <up|down|left|right> [amount]');
+        break;
+      }
+      const fn = { up: 'scrollUp', down: 'scrollDown', left: 'scrollLeft', right: 'scrollRight' }[dir];
+      const result = await ui[fn](amount);
+      result.success ? success(`Scrolled ${dir}`) : error('Scroll failed');
+      break;
+    }
+    
+    case 'wait': {
+      const text = args[0];
+      const timeout = parseInt(args[1], 10) || 5000;
+      if (!text) {
+        error('Usage: wait <text> [timeout]');
+        break;
+      }
+      info(`Waiting for "${text}"...`);
+      const result = await ui.waitForElement({ text }, { timeout });
+      result.success 
+        ? success(`Found after ${result.elapsed}ms`)
+        : warn(`Not found within ${timeout}ms`);
+      break;
+    }
+    
+    case 'sleep':
+    case 'delay': {
+      const ms = parseInt(args[0], 10) || 1000;
+      await ui.sleep(ms);
+      success(`Waited ${ms}ms`);
+      break;
+    }
+    
+    default:
+      error(`Unknown command: ${cmd}`);
+      info('Type "help" for available commands');
+  }
+}
+
+/**
+ * Run the REPL
+ */
+async function run(args, options) {
+  loadUI();
+  
+  console.log(`
+${bold('Liku Interactive Shell')} ${dim('v1.0')}
+${dim('Type "help" for commands, "exit" to quit')}
+`);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: highlight('liku> '),
+  });
+
+  rl.prompt();
+
+  return new Promise((resolve) => {
+    rl.on('line', async (line) => {
+      try {
+        const result = await executeCommand(line);
+        if (result === 'exit') {
+          rl.close();
+          return;
+        }
+      } catch (err) {
+        error(err.message);
+      }
+      rl.prompt();
+    });
+
+    rl.on('close', () => {
+      console.log('\nGoodbye!');
+      resolve({ success: true });
+    });
+  });
+}
+
+module.exports = { run };

package/src/cli/commands/screenshot.js

@@ -0,0 +1,72 @@
+/**
+ * screenshot command - Capture screenshot
+ * @module cli/commands/screenshot
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { success, error, info } = 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 screenshot command
+ * 
+ * Usage:
+ *   liku screenshot                    # Save to temp with timestamp
+ *   liku screenshot ./capture.png      # Save to specific path
+ *   liku screenshot --clipboard        # Copy to clipboard (TODO)
+ */
+async function run(args, options) {
+  loadUI();
+  
+  // Determine output path
+  let outputPath = args[0];
+  
+  if (!outputPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    outputPath = path.join(process.cwd(), `screenshot_${timestamp}.png`);
+  } else {
+    // Resolve relative paths
+    if (!path.isAbsolute(outputPath)) {
+      outputPath = path.resolve(process.cwd(), outputPath);
+    }
+  }
+  
+  // Ensure directory exists
+  const dir = path.dirname(outputPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  if (!options.quiet) {
+    info('Capturing screenshot...');
+  }
+  
+  const result = await ui.screenshot({ path: outputPath });
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Screenshot saved: ${result.path}`);
+    }
+    return { 
+      success: true, 
+      path: result.path,
+      // Include base64 if JSON output requested
+      ...(options.json && result.base64 ? { base64: result.base64 } : {}),
+    };
+  } else {
+    error(`Screenshot failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/scroll.js

@@ -0,0 +1,74 @@
+/**
+ * scroll command - Scroll up or down
+ * @module cli/commands/scroll
+ */
+
+const path = require('path');
+const { success, error, info } = 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 scroll command
+ * 
+ * Usage:
+ *   liku scroll up
+ *   liku scroll down 5
+ *   liku scroll left 3
+ */
+async function run(args, options) {
+  loadUI();
+  
+  if (args.length === 0) {
+    error('Usage: liku scroll <up|down|left|right> [amount]');
+    return { success: false };
+  }
+  
+  const direction = args[0].toLowerCase();
+  const amount = args[1] ? parseInt(args[1], 10) : 3;
+  
+  if (!['up', 'down', 'left', 'right'].includes(direction)) {
+    error('Direction must be: up, down, left, or right');
+    return { success: false };
+  }
+  
+  if (!options.quiet) {
+    info(`Scrolling ${direction} by ${amount}...`);
+  }
+  
+  let result;
+  switch (direction) {
+    case 'up':
+      result = await ui.scrollUp(amount);
+      break;
+    case 'down':
+      result = await ui.scrollDown(amount);
+      break;
+    case 'left':
+      result = await ui.scrollLeft(amount);
+      break;
+    case 'right':
+      result = await ui.scrollRight(amount);
+      break;
+  }
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Scrolled ${direction} by ${amount}`);
+    }
+    return { success: true, direction, amount };
+  } else {
+    error(`Scroll failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/start.js

@@ -0,0 +1,67 @@
+/**
+ * start command - Launch the Electron agent
+ * @module cli/commands/start
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const { success, info, error } = require('../util/output');
+
+const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+
+/**
+ * Run the start command
+ */
+async function run(args, options) {
+  if (!options.quiet) {
+    info('Starting Copilot-Liku agent...');
+  }
+
+  return new Promise((resolve, reject) => {
+    // Copy environment and clear ELECTRON_RUN_AS_NODE
+    const env = { ...process.env };
+    delete env.ELECTRON_RUN_AS_NODE;
+
+    // Get electron path
+    let electronPath;
+    try {
+      electronPath = require('electron');
+    } catch (e) {
+      error('Electron not found. Run: npm install');
+      return reject(new Error('Electron not installed'));
+    }
+
+    const child = spawn(electronPath, ['.'], {
+      cwd: PROJECT_ROOT,
+      env,
+      stdio: options.quiet ? 'ignore' : 'inherit',
+      detached: options.background || false,
+      windowsHide: false,
+    });
+
+    if (options.background) {
+      // Detach and let it run
+      child.unref();
+      if (!options.quiet) {
+        success('Agent started in background');
+      }
+      resolve({ success: true, pid: child.pid });
+    } else {
+      // Wait for exit
+      child.on('exit', (code, signal) => {
+        if (signal) {
+          resolve({ success: true, signal });
+        } else {
+          resolve({ success: code === 0, code });
+        }
+      });
+
+      child.on('error', (err) => {
+        error(`Failed to start: ${err.message}`);
+        reject(err);
+      });
+    }
+  });
+}
+
+module.exports = { run };

package/src/cli/commands/type.js

@@ -0,0 +1,57 @@
+/**
+ * type command - Type text at cursor position
+ * @module cli/commands/type
+ */
+
+const path = require('path');
+const { success, error, info } = 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 type command
+ * 
+ * Usage:
+ *   liku type "Hello World"
+ *   liku type "slow typing" --delay 100
+ */
+async function run(args, options) {
+  if (args.length === 0) {
+    error('Usage: liku type <text> [--delay <ms>]');
+    return { success: false };
+  }
+
+  loadUI();
+  const text = args.join(' ');
+  
+  if (!options.quiet) {
+    info(`Typing: "${text.substring(0, 30)}${text.length > 30 ? '...' : ''}"`);
+  }
+  
+  const typeOptions = {};
+  if (options.delay) {
+    typeOptions.delay = parseInt(options.delay, 10);
+  }
+  
+  const result = await ui.typeText(text, typeOptions);
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Typed ${text.length} characters`);
+    }
+    return { success: true, length: text.length };
+  } else {
+    error(`Type failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/wait.js

@@ -0,0 +1,84 @@
+/**
+ * wait command - Wait for element to appear
+ * @module cli/commands/wait
+ */
+
+const path = require('path');
+const { success, error, info, Spinner } = 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 wait command
+ * 
+ * Usage:
+ *   liku wait "Loading..."              # Wait up to 10s for element
+ *   liku wait "Submit" 5000             # Wait up to 5s
+ *   liku wait "Dialog" --gone           # Wait for element to disappear
+ */
+async function run(args, options) {
+  loadUI();
+  
+  if (args.length === 0) {
+    error('Usage: liku wait <text> [timeout] [--gone]');
+    return { success: false };
+  }
+  
+  const searchText = args[0];
+  const timeout = args[1] ? parseInt(args[1], 10) : 10000;
+  const waitGone = options.gone || false;
+  
+  const spinner = !options.quiet ? new Spinner(
+    waitGone 
+      ? `Waiting for "${searchText}" to disappear` 
+      : `Waiting for "${searchText}"`
+  ) : null;
+  
+  spinner?.start();
+  
+  const criteria = { text: searchText };
+  
+  if (options.type) {
+    criteria.controlType = options.type;
+  }
+  
+  const result = waitGone 
+    ? await ui.waitForElementGone(criteria, timeout)
+    : await ui.waitForElement(criteria, { timeout });
+  
+  spinner?.stop();
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(
+        waitGone
+          ? `"${searchText}" disappeared after ${result.elapsed}ms`
+          : `Found "${searchText}" after ${result.elapsed}ms`
+      );
+    }
+    return { 
+      success: true, 
+      elapsed: result.elapsed,
+      element: result.element,
+    };
+  } else {
+    if (!options.quiet) {
+      error(
+        waitGone
+          ? `"${searchText}" did not disappear within ${timeout}ms`
+          : `"${searchText}" not found within ${timeout}ms`
+      );
+    }
+    return { success: false, elapsed: result.elapsed, timeout };
+  }
+}
+
+module.exports = { run };