copilot-liku-cli 0.0.1

package/src/cli/commands/click.js

@@ -0,0 +1,108 @@
+/**
+ * click command - Click element by text or coordinates
+ * @module cli/commands/click
+ */
+
+const path = require('path');
+const { success, error, info, Spinner } = require('../util/output');
+
+// Load UI automation module
+const UI_MODULE = path.resolve(__dirname, '../../main/ui-automation');
+let ui;
+
+function loadUI() {
+  if (!ui) {
+    ui = require(UI_MODULE);
+  }
+  return ui;
+}
+
+/**
+ * Run the click command
+ * 
+ * Usage:
+ *   liku click "Button Text"
+ *   liku click 500,300
+ *   liku click "Submit" --double
+ *   liku click "Menu" --right
+ */
+async function run(args, options) {
+  if (args.length === 0) {
+    error('Usage: liku click <text|x,y> [--double] [--right] [--wait <ms>]');
+    return { success: false };
+  }
+
+  loadUI();
+  const target = args.join(' ');
+  
+  // Check if target is coordinates (e.g., "500,300" or "500 300")
+  const coordMatch = target.match(/^(\d+)[,\s]+(\d+)$/);
+  
+  if (coordMatch) {
+    // Click at coordinates
+    const x = parseInt(coordMatch[1], 10);
+    const y = parseInt(coordMatch[2], 10);
+    
+    if (!options.quiet) {
+      info(`Clicking at (${x}, ${y})...`);
+    }
+    
+    const button = options.right ? 'right' : 'left';
+    const clickFn = options.double ? ui.doubleClickAt : ui.clickAt;
+    
+    const result = await clickFn(x, y, { button });
+    
+    if (result.success) {
+      if (!options.quiet) {
+        success(`Clicked at (${x}, ${y})`);
+      }
+      return { success: true, x, y, method: 'coordinates' };
+    } else {
+      error(`Click failed: ${result.error || 'Unknown error'}`);
+      return { success: false, error: result.error };
+    }
+  } else {
+    // Click by text
+    const spinner = !options.quiet ? new Spinner(`Searching for "${target}"`) : null;
+    spinner?.start();
+    
+    const criteria = { text: target };
+    
+    // Add control type filter if specified
+    if (options.type) {
+      criteria.controlType = options.type;
+    }
+    
+    // Add window filter if specified
+    if (options.window) {
+      criteria.windowTitle = options.window;
+    }
+    
+    const clickOptions = {
+      button: options.right ? 'right' : 'left',
+      doubleClick: options.double || false,
+      waitTimeout: options.wait ? parseInt(options.wait, 10) : 0,
+    };
+    
+    const result = await ui.click(criteria, clickOptions);
+    
+    spinner?.stop();
+    
+    if (result.success) {
+      if (!options.quiet) {
+        const element = result.element;
+        success(`Clicked "${element?.name || target}" (${element?.controlType || 'unknown'})`);
+      }
+      return { 
+        success: true, 
+        element: result.element,
+        method: 'text',
+      };
+    } else {
+      error(`Element not found: "${target}"`);
+      return { success: false, error: result.error || 'Element not found' };
+    }
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/drag.js

@@ -0,0 +1,85 @@
+/**
+ * drag command - Drag from one point to another
+ * @module cli/commands/drag
+ */
+
+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 drag command
+ * 
+ * Usage:
+ *   liku drag 100 100 500 300
+ *   liku drag 100,100 to 500,300
+ */
+async function run(args, options) {
+  loadUI();
+  
+  // Parse coordinates
+  let fromX, fromY, toX, toY;
+  
+  // Remove "to" keyword if present
+  const cleanArgs = args.filter(a => a.toLowerCase() !== 'to');
+  
+  if (cleanArgs.length === 2) {
+    // Format: "100,100" "500,300"
+    const from = cleanArgs[0].split(',');
+    const to = cleanArgs[1].split(',');
+    fromX = parseInt(from[0], 10);
+    fromY = parseInt(from[1], 10);
+    toX = parseInt(to[0], 10);
+    toY = parseInt(to[1], 10);
+  } else if (cleanArgs.length >= 4) {
+    // Format: "100 100 500 300"
+    fromX = parseInt(cleanArgs[0], 10);
+    fromY = parseInt(cleanArgs[1], 10);
+    toX = parseInt(cleanArgs[2], 10);
+    toY = parseInt(cleanArgs[3], 10);
+  } else {
+    error('Usage: liku drag <fromX> <fromY> <toX> <toY>');
+    info('Example: liku drag 100 100 500 300');
+    return { success: false };
+  }
+  
+  if ([fromX, fromY, toX, toY].some(isNaN)) {
+    error('Invalid coordinates. Use numbers.');
+    return { success: false };
+  }
+  
+  if (!options.quiet) {
+    info(`Dragging from (${fromX}, ${fromY}) to (${toX}, ${toY})...`);
+  }
+  
+  const dragOptions = {};
+  if (options.steps) {
+    dragOptions.steps = parseInt(options.steps, 10);
+  }
+  if (options.delay) {
+    dragOptions.stepDelay = parseInt(options.delay, 10);
+  }
+  
+  const result = await ui.drag(fromX, fromY, toX, toY, dragOptions);
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Dragged from (${fromX}, ${fromY}) to (${toX}, ${toY})`);
+    }
+    return { success: true, from: { x: fromX, y: fromY }, to: { x: toX, y: toY } };
+  } else {
+    error(`Drag failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/find.js

@@ -0,0 +1,109 @@
+/**
+ * find command - Find UI elements matching criteria
+ * @module cli/commands/find
+ */
+
+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 find command
+ * 
+ * Usage:
+ *   liku find "Button Text"
+ *   liku find "Save" --type Button
+ *   liku find "*" --type Edit --window "Notepad"
+ */
+async function run(args, options) {
+  if (args.length === 0) {
+    error('Usage: liku find <text> [--type <ControlType>] [--window <title>]');
+    return { success: false };
+  }
+
+  loadUI();
+  const searchText = args.join(' ');
+  
+  if (!options.quiet) {
+    info(`Searching for elements matching "${searchText}"...`);
+  }
+  
+  const criteria = {};
+  
+  // Handle wildcard search (find all of a type)
+  if (searchText !== '*') {
+    criteria.text = searchText;
+  }
+  
+  if (options.type) {
+    criteria.controlType = options.type;
+  }
+  
+  if (options.window) {
+    criteria.windowTitle = options.window;
+  }
+  
+  if (options.id) {
+    criteria.automationId = options.id;
+  }
+  
+  if (options.class) {
+    criteria.className = options.class;
+  }
+  
+  const result = await ui.findElements(criteria);
+  
+  if (!result.success) {
+    error(`Search failed: ${result.error}`);
+    return { success: false, error: result.error };
+  }
+  
+  if (result.count === 0) {
+    if (!options.quiet) {
+      info('No elements found matching criteria');
+    }
+    return { success: true, elements: [], count: 0 };
+  }
+  
+  if (!options.quiet && !options.json) {
+    success(`Found ${result.count} element(s):\n`);
+    
+    // Display as table
+    const rows = result.elements.map((el, i) => [
+      i + 1,
+      el.name?.substring(0, 40) || dim('(unnamed)'),
+      el.controlType || '-',
+      el.bounds ? `${el.bounds.x},${el.bounds.y}` : '-',
+      el.bounds ? `${el.bounds.width}x${el.bounds.height}` : '-',
+    ]);
+    
+    table(rows, ['#', 'Name', 'Type', 'Position', 'Size']);
+    
+    // Show automation IDs if verbose
+    if (options.verbose) {
+      console.log('\n' + dim('Automation IDs:'));
+      result.elements.forEach((el, i) => {
+        if (el.automationId) {
+          console.log(`  ${i + 1}. ${highlight(el.automationId)}`);
+        }
+      });
+    }
+  }
+  
+  return {
+    success: true,
+    elements: result.elements,
+    count: result.count,
+  };
+}
+
+module.exports = { run };

package/src/cli/commands/keys.js

@@ -0,0 +1,132 @@
+/**
+ * keys command - Send keyboard shortcuts
+ * @module cli/commands/keys
+ */
+
+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;
+}
+
+/**
+ * Convert human-readable key combo to SendKeys format
+ * 
+ * Examples:
+ *   ctrl+c → ^c
+ *   ctrl+shift+s → ^+s
+ *   alt+f4 → %{F4}
+ *   enter → {ENTER}
+ */
+function toSendKeys(combo) {
+  // Already in SendKeys format
+  if (combo.includes('{') || combo.includes('^') || combo.includes('%') || combo.includes('+')) {
+    return combo;
+  }
+  
+  const parts = combo.toLowerCase().split(/[+\-]/);
+  let modifiers = '';
+  let key = '';
+  
+  for (const part of parts) {
+    const trimmed = part.trim();
+    switch (trimmed) {
+      case 'ctrl':
+      case 'control':
+        modifiers += '^';
+        break;
+      case 'alt':
+        modifiers += '%';
+        break;
+      case 'shift':
+        modifiers += '+';
+        break;
+      case 'win':
+      case 'windows':
+      case 'meta':
+        // Windows key - use PowerShell workaround
+        modifiers += '#';
+        break;
+      default:
+        key = trimmed;
+    }
+  }
+  
+  // Special keys
+  const specialKeys = {
+    'enter': '{ENTER}',
+    'return': '{ENTER}',
+    'tab': '{TAB}',
+    'esc': '{ESC}',
+    'escape': '{ESC}',
+    'space': ' ',
+    'backspace': '{BACKSPACE}',
+    'delete': '{DELETE}',
+    'del': '{DELETE}',
+    'insert': '{INSERT}',
+    'ins': '{INSERT}',
+    'home': '{HOME}',
+    'end': '{END}',
+    'pageup': '{PGUP}',
+    'pgup': '{PGUP}',
+    'pagedown': '{PGDN}',
+    'pgdn': '{PGDN}',
+    'up': '{UP}',
+    'down': '{DOWN}',
+    'left': '{LEFT}',
+    'right': '{RIGHT}',
+    'f1': '{F1}', 'f2': '{F2}', 'f3': '{F3}', 'f4': '{F4}',
+    'f5': '{F5}', 'f6': '{F6}', 'f7': '{F7}', 'f8': '{F8}',
+    'f9': '{F9}', 'f10': '{F10}', 'f11': '{F11}', 'f12': '{F12}',
+  };
+  
+  const finalKey = specialKeys[key] || key;
+  
+  return modifiers + finalKey;
+}
+
+/**
+ * Run the keys command
+ * 
+ * Usage:
+ *   liku keys ctrl+c
+ *   liku keys ctrl+shift+s
+ *   liku keys enter
+ *   liku keys "^c" (raw SendKeys format)
+ */
+async function run(args, options) {
+  if (args.length === 0) {
+    error('Usage: liku keys <combo>');
+    info('Examples: ctrl+c, ctrl+shift+s, alt+f4, enter, tab');
+    return { success: false };
+  }
+
+  loadUI();
+  const combo = args.join(' ');
+  const sendKeysFormat = toSendKeys(combo);
+  
+  if (!options.quiet) {
+    info(`Sending keys: ${combo} (${sendKeysFormat})`);
+  }
+  
+  const result = await ui.sendKeys(sendKeysFormat);
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Sent: ${combo}`);
+    }
+    return { success: true, keys: sendKeysFormat };
+  } else {
+    error(`Keys failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };

package/src/cli/commands/mouse.js

@@ -0,0 +1,79 @@
+/**
+ * mouse command - Move mouse to coordinates
+ * @module cli/commands/mouse
+ */
+
+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 mouse command
+ * 
+ * Usage:
+ *   liku mouse 500 300         # Move to coordinates
+ *   liku mouse --pos           # Show current position
+ */
+async function run(args, options) {
+  loadUI();
+  
+  // Show current position
+  if (options.pos || options.position || args.length === 0) {
+    const pos = await ui.getMousePosition();
+    
+    if (!options.quiet && !options.json) {
+      console.log(`Mouse position: (${pos.x}, ${pos.y})`);
+    }
+    
+    return { success: true, x: pos.x, y: pos.y };
+  }
+  
+  // Parse coordinates
+  let x, y;
+  
+  if (args.length === 1 && args[0].includes(',')) {
+    // Format: "500,300"
+    const parts = args[0].split(',');
+    x = parseInt(parts[0], 10);
+    y = parseInt(parts[1], 10);
+  } else if (args.length >= 2) {
+    // Format: "500 300"
+    x = parseInt(args[0], 10);
+    y = parseInt(args[1], 10);
+  } else {
+    error('Usage: liku mouse <x> <y>');
+    return { success: false };
+  }
+  
+  if (isNaN(x) || isNaN(y)) {
+    error('Invalid coordinates. Use numbers like: liku mouse 500 300');
+    return { success: false };
+  }
+  
+  if (!options.quiet) {
+    info(`Moving mouse to (${x}, ${y})...`);
+  }
+  
+  const result = await ui.moveMouse(x, y);
+  
+  if (result.success) {
+    if (!options.quiet) {
+      success(`Mouse moved to (${x}, ${y})`);
+    }
+    return { success: true, x, y };
+  } else {
+    error(`Move failed: ${result.error || 'Unknown error'}`);
+    return { success: false, error: result.error };
+  }
+}
+
+module.exports = { run };