@bobfrankston/winpos 2.0.39 → 2.0.41

package/.claude/settings.local.json

@@ -23,7 +23,14 @@
       "Bash(git gc:*)",
       "Bash(git rm:*)",
       "Bash(git reset:*)",
-      "Bash(git reflog:*)"
+      "Bash(git reflog:*)",
+      "Bash(git fetch:*)",
+      "Bash(git clone:*)",
+      "Bash(cmd /c \"cd /d Y:\\dev\\utils && git clone https://github.com/BobFrankston/winpos.git winpos-clean\")",
+      "Bash(git -C \"Y:\\dev\\utils\\winpos-clean\" count-objects -vH)",
+      "Bash(xcopy:*)",
+      "Bash(dir:*)",
+      "Bash(node:*)"
     ],
     "deny": [],
     "ask": []

package/README.md

@@ -15,13 +15,13 @@ TypeScript implementation of WinPos - A Windows window positioning utility for m
 ## Installation
 
 ```bash
-npm install @bobfrankston/tswinpos
+npm install @bobfrankston/winpos
 ```
 
 Or with Bun:
 
 ```bash
-bun add @bobfrankston/tswinpos
+bun add @bobfrankston/winpos
 ```
 
 ## Usage
@@ -30,34 +30,34 @@ bun add @bobfrankston/tswinpos
 
 ```bash
 # Move window to screen 0 at position (100, 200)
-tswinpos "Notepad" 100 200 0
+winpos "Notepad" 100 200 0
 
 # Move window using percentages
-tswinpos "Chrome*" 50% 50% 1
+winpos "Chrome*" 50% 50% 1
 
 # Set window size as well
-tswinpos "Visual Studio Code" 0 0 0 1920 1080
+winpos "Visual Studio Code" 0 0 0 1920 1080
 
 # List all windows
-tswinpos *
+winpos *
 
 # Get screen count
-tswinpos -c
+winpos -c
 
 # Debug mode
-tswinpos -d "Firefox" 0 0 1
+winpos -d "Firefox" 0 0 1
 ```
 
 ### Pattern Matching
 
-- **Exact match**: `tswinpos "Notepad" 0 0 0`
-- **Prefix match**: `tswinpos "Chrome*" 0 0 0`
-- **Regex match**: `tswinpos "/Visual.*Code/" 0 0 0`
+- **Exact match**: `winpos "Notepad" 0 0 0`
+- **Prefix match**: `winpos "Chrome*" 0 0 0`
+- **Regex match**: `winpos "/Visual.*Code/" 0 0 0`
 
 ### As a Library
 
 ```typescript
-import { run } from '@bobfrankston/tswinpos';
+import { run } from '@bobfrankston/winpos';
 
 // Move a window programmatically
 run(['Chrome*', '0', '0', '1', '1920', '1080']);
@@ -89,7 +89,7 @@ Screens are numbered starting from 0, sorted by position:
 ## Parameters
 
 ```
-tswinpos [-d -c *] <window title> <x> <y> <screen> [<width> <height>]
+winpos [-d -c *] <window title> <x> <y> <screen> [<width> <height>]
 ```
 
 - `<window title>` - Window title (exact, prefix with `*`, or regex with `/.../ `)

package/index.d.ts

@@ -7,6 +7,22 @@ import { user32, RECT } from './ffi-wrapper.js';
 import { enumerateScreens, sortScreens, ScreenInfo } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, WindowInfo, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, TabInfo, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
+export interface WindowConfig {
+    name: string;
+    regex?: boolean;
+    pos?: {
+        x: number | string;
+        y: number | string;
+        screen?: number;
+    };
+    size?: {
+        w: number | string;
+        h: number | string;
+    };
+    minimize?: boolean;
+    maximize?: boolean;
+}
+export type ConfigFile = WindowConfig | WindowConfig[];
 export { RECT, ScreenInfo, WindowInfo, WindowState, TabInfo, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, user32 };
 /**
  * Convert screen-relative coordinates to global coordinates

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EACH,gBAAgB,EAChB,oBAAoB,EAEpB,UAAU,EACV,WAAW,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,cAAc,EACd,cAAc,EACd,aAAa,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAKxF,OAAO,EACH,IAAI,EACJ,UAAU,EACV,UAAU,EACV,WAAW,EACX,OAAO,EACP,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,cAAc,EACd,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,MAAM,EACT,CAAC;AAQF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAyBlG;AAkLD,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAwEjC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EACH,gBAAgB,EAChB,oBAAoB,EAEpB,UAAU,EACV,WAAW,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,cAAc,EACd,cAAc,EACd,aAAa,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAMxF,MAAM,WAAW,YAAY;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,IAAI,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,YAAY,EAAE,CAAC;AAkBvD,OAAO,EACH,IAAI,EACJ,UAAU,EACV,UAAU,EACV,WAAW,EACX,OAAO,EACP,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,QAAQ,EACR,cAAc,EACd,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,MAAM,EACT,CAAC;AA8RF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAyBlG;AAmND,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAuHjC"}

package/index.js

@@ -7,11 +7,269 @@ import { user32 } from './ffi-wrapper.js';
 import { enumerateScreens, sortScreens } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, loadIgnorePatterns, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
-import { join } from 'path';
+import { join, resolve, isAbsolute } from 'path';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import * as packageJson from './package.json' with { type: 'json' };
 // Re-export public API for library usage
 export { WindowState, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, user32 };
+// WindowConfig and ConfigFile types are exported from interface definitions above
 // Note: screenPosToPos is exported separately below (after the function definition)
+/**
+ * Load window config from JSON file
+ */
+function loadConfigFile(filePath) {
+    const absPath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+    if (!existsSync(absPath)) {
+        throw new Error(`Config file not found: ${absPath}`);
+    }
+    const content = readFileSync(absPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Save window config to JSON file
+ * If file exists and contains array, merge; otherwise create/overwrite
+ */
+function saveConfigFile(filePath, config, merge = false) {
+    const absPath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+    let finalConfig;
+    if (merge && existsSync(absPath)) {
+        const existing = loadConfigFile(absPath);
+        if (Array.isArray(existing)) {
+            // Find and update existing entry with same name, or append
+            const idx = existing.findIndex(e => e.name === config.name);
+            if (idx >= 0) {
+                existing[idx] = config;
+            }
+            else {
+                existing.push(config);
+            }
+            finalConfig = existing;
+        }
+        else {
+            // Convert single entry to array
+            if (existing.name === config.name) {
+                finalConfig = config; // Replace single entry
+            }
+            else {
+                finalConfig = [existing, config];
+            }
+        }
+    }
+    else {
+        finalConfig = config;
+    }
+    writeFileSync(absPath, JSON.stringify(finalConfig, null, 2), 'utf-8');
+    console.log(`Config saved to: ${absPath}`);
+}
+/**
+ * Build WindowConfig from CLI options
+ */
+function buildConfigFromOptions(opts) {
+    if (!opts.windowTitle)
+        return null;
+    const config = {
+        name: opts.windowTitle
+    };
+    // Check if name is a regex pattern (enclosed in /.../)
+    if (config.name.startsWith('/') && config.name.endsWith('/')) {
+        config.regex = true;
+        config.name = config.name.slice(1, -1); // Store without delimiters
+    }
+    if (opts.pos) {
+        config.pos = { x: opts.pos.x, y: opts.pos.y };
+        if (opts.pos.screen !== undefined) {
+            config.pos.screen = opts.pos.screen;
+        }
+    }
+    if (opts.size) {
+        config.size = { w: opts.size.w, h: opts.size.h };
+    }
+    if (opts.minimize) {
+        config.minimize = true;
+    }
+    if (opts.maximize) {
+        config.maximize = true;
+    }
+    return config;
+}
+/**
+ * Parse CLI arguments into structured options
+ */
+function parseArgs(args) {
+    const opts = {
+        debug: false,
+        debugVerbose: false,
+        showCount: false,
+        positionalArgs: []
+    };
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        // Check for .json file as first non-flag arg (auto-load)
+        if (!arg.startsWith('-') && arg.toLowerCase().endsWith('.json') && !opts.loadFile) {
+            opts.loadFile = arg;
+            i++;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            const flag = arg.substring(1).toLowerCase();
+            switch (flag) {
+                case 'd':
+                    opts.debug = true;
+                    break;
+                case 'dbg':
+                    opts.debugVerbose = true;
+                    break;
+                case 'c':
+                    opts.showCount = true;
+                    break;
+                case 'version':
+                case 'v':
+                    console.log(`winpos version ${packageJson.default.version}`);
+                    process.exit(0);
+                    break;
+                case 'pos':
+                    i++;
+                    if (i < args.length) {
+                        const parts = args[i].split(',');
+                        opts.pos = { x: parts[0], y: parts[1] };
+                        if (parts.length > 2) {
+                            opts.pos.screen = parseInt(parts[2], 10);
+                        }
+                    }
+                    break;
+                case 'size':
+                    i++;
+                    if (i < args.length) {
+                        const parts = args[i].split(',');
+                        opts.size = { w: parts[0], h: parts[1] };
+                    }
+                    break;
+                case 'load':
+                    i++;
+                    if (i < args.length) {
+                        opts.loadFile = args[i];
+                    }
+                    break;
+                case 'save':
+                    i++;
+                    if (i < args.length) {
+                        opts.saveFile = args[i];
+                    }
+                    break;
+                case 'title':
+                    i++;
+                    if (i < args.length) {
+                        opts.windowTitle = args[i];
+                    }
+                    break;
+                case 'min':
+                    opts.minimize = true;
+                    break;
+                case 'max':
+                    opts.maximize = true;
+                    break;
+                case 'help':
+                case '?':
+                    return opts; // Will trigger usage display
+                default:
+                    // Unknown flag - could be negative number for position
+                    if (/^-?\d+/.test(arg)) {
+                        opts.positionalArgs.push(arg);
+                    }
+                    else {
+                        console.log(`Unknown option: ${arg}`);
+                    }
+                    break;
+            }
+        }
+        else {
+            opts.positionalArgs.push(arg);
+        }
+        i++;
+    }
+    // First positional arg is window title (if using new flag-based syntax and -title not set)
+    const usingFlagSyntax = opts.pos || opts.size || opts.loadFile || opts.saveFile || opts.minimize || opts.maximize;
+    if (opts.positionalArgs.length > 0 && usingFlagSyntax) {
+        if (!opts.windowTitle) {
+            opts.windowTitle = opts.positionalArgs[0];
+            opts.positionalArgs = opts.positionalArgs.slice(1);
+        }
+        // Error if stray positional args remain when using flag-based syntax
+        if (opts.positionalArgs.length > 0) {
+            console.error(`Error: unexpected arguments: ${opts.positionalArgs.join(' ')}`);
+            console.error('When using flags, only window title should be positional');
+            process.exit(1);
+        }
+    }
+    return opts;
+}
+/**
+ * Apply a single window config
+ */
+function applyWindowConfig(config, screensInfo) {
+    // Build pattern for matching
+    let pattern;
+    if (config.regex) {
+        pattern = `/${config.name}/`;
+    }
+    else {
+        pattern = config.name;
+    }
+    let matchedWindows = findWindowsByPattern(pattern);
+    matchedWindows = matchedWindows.filter(w => !w.title.toLowerCase().includes('tswinpos'));
+    if (matchedWindows.length === 0) {
+        console.log(`No windows found matching '${config.name}'`);
+        return;
+    }
+    // Handle minimize
+    if (config.minimize) {
+        for (const window of matchedWindows) {
+            if (dbgVerbose)
+                console.log(`[DBG] Minimizing: "${window.title}"`);
+            minimizeWindow(window.hwnd);
+        }
+        return;
+    }
+    // Handle maximize
+    if (config.maximize) {
+        for (const window of matchedWindows) {
+            if (dbgVerbose)
+                console.log(`[DBG] Maximizing: "${window.title}"`);
+            maximizeWindow(window.hwnd);
+        }
+        return;
+    }
+    // Handle positioning
+    if (!config.pos)
+        return;
+    const screenIndex = config.pos.screen ?? 0;
+    if (screenIndex < 0 || screenIndex >= screensInfo.length) {
+        console.log(`Invalid screen ${screenIndex} for window '${config.name}'`);
+        return;
+    }
+    const targetScreen = screensInfo[screenIndex];
+    const bounds = targetScreen.bounds;
+    const x = parseDimension(String(config.pos.x), bounds.Width) + bounds.Left;
+    const y = parseDimension(String(config.pos.y), bounds.Height) + bounds.Top;
+    let width = config.size ? parseDimension(String(config.size.w), bounds.Width) : 0;
+    let height = config.size ? parseDimension(String(config.size.h), bounds.Height) : 0;
+    for (const window of matchedWindows) {
+        let w = width, h = height;
+        if (w === 0)
+            w = window.rect.Right - window.rect.Left;
+        if (h === 0)
+            h = window.rect.Bottom - window.rect.Top;
+        if (dbgVerbose) {
+            console.log(`[DBG] Window: "${window.title}" -> Position: (${x}, ${y}) Size: ${w}x${h} Screen: ${screenIndex}`);
+        }
+        if (isMinimized(window.hwnd) || isMaximized(window.hwnd)) {
+            restoreWindow(window.hwnd);
+        }
+        user32.MoveWindow(window.hwnd, x, y, w, h, true);
+        user32.SetForegroundWindow(window.hwnd);
+    }
+}
 let dbg = false;
 let dbgVerbose = false; // -dbg flag for detailed output
 let screens = [];
@@ -125,6 +383,27 @@ function getScreenForWindow(windowRect) {
     return screens.findIndex(s => s.primary) || 0;
 }
 const padn = (n, p = 6) => n.toString().padStart(p);
+/**
+ * Show position info for windows matching pattern
+ */
+function showWindowInfo(pattern) {
+    let matchedWindows = findWindowsByPattern(pattern);
+    matchedWindows = matchedWindows.filter(w => !w.title.toLowerCase().includes('tswinpos'));
+    if (matchedWindows.length === 0) {
+        console.log(`No windows found matching '${pattern}'`);
+        return;
+    }
+    for (const window of matchedWindows) {
+        const screenIndex = getScreenForWindow(window.rect);
+        const screen = screens[screenIndex];
+        const x = window.rect.Left - screen.bounds.Left;
+        const y = window.rect.Top - screen.bounds.Top;
+        const width = window.rect.Right - window.rect.Left;
+        const height = window.rect.Bottom - window.rect.Top;
+        console.log(`${window.title}`);
+        console.log(`  pos: ${x},${y},${screenIndex}  size: ${width},${height}`);
+    }
+}
 function listAllWindows(includeIgnored = false) {
     console.log('====================================');
     console.log('Screens');
@@ -157,23 +436,32 @@ function listAllWindows(includeIgnored = false) {
 function usage(msg = '') {
     if (msg)
         console.log(msg);
-    console.log('Usage: winpos [-d -dbg -c -version *] <window title> <x> <y> <screen> [<width> <height>]');
-    console.log('       winpos <window title> min | -min');
-    console.log('  -d debug, -dbg verbose output (version, title, position, size), -c return count, -version (or -v) show version');
-    console.log('  where <screen> is a number from 0 to N-1, where N is the number of screens.');
-    console.log('  <x> and <y> can be a number of pixels or a percentage (e.g. 50%)');
-    console.log('  Use "min" or "-min" in place of <x> to minimize the window to the taskbar');
-    console.log('  title can be a regex pattern (if enclosed in /.../) or a prefix (if it ends with \'*\')');
-    console.log('  <width> and <height> are optional and can be a number of pixels or a percentage (e.g. 50%) or 0 (to keep the current size)');
-    console.log('To list all windows: tswinpos *');
-    console.log('To list all windows (including ignored): tswinpos **');
-    console.log('To return the window count use -c');
+    console.log('Usage: winpos [options] <title> <x> <y> <screen> [<width> <height>]');
+    console.log('       winpos [options] <title> -pos x,y[,screen] [-size w,h]');
+    console.log('       winpos [options] -title <name> -pos x,y[,screen] [-size w,h]');
+    console.log('       winpos <title> min | -min');
+    console.log('       winpos <config.json>');
+    console.log('       winpos -load <config.json> [-save <output.json>]');
+    console.log();
+    console.log('Options:');
+    console.log('  -d          Debug mode');
+    console.log('  -dbg        Verbose debug output');
+    console.log('  -c          Return screen count as exit code');
+    console.log('  -v/-version Show version');
+    console.log('  -title name Window title/pattern (alternative to positional)');
+    console.log('  -pos x,y[,s] Position (x,y with optional screen index)');
+    console.log('  -size w,h   Window size (width,height)');
+    console.log('  -min        Minimize window');
+    console.log('  -max        Maximize window');
+    console.log('  -load file  Load config from JSON file');
+    console.log('  -save file  Save config to JSON file (merges if file exists)');
     console.log();
-    console.log('  +---+---+');
-    console.log('  | 2 | 3 |');
-    console.log('  +---+---+');
-    console.log('  | 0 | 1 |');
-    console.log('  +---+---+');
+    console.log('Position/size values can be pixels or percentages (e.g. 50%)');
+    console.log('Title can be regex (/pattern/) or prefix (title*)');
+    console.log('* = list windows, ** = list all including ignored');
+    console.log();
+    console.log('JSON format: {"name":"app","regex":false,"pos":{"x":0,"y":0,"screen":0},"size":{"w":800,"h":600}}');
+    console.log('  or array: [{...}, {...}]');
     console.log();
     console.log('Screen |   X     Y   |   W     H   ');
     console.log('------------------------------------');
@@ -181,8 +469,6 @@ function usage(msg = '') {
         const screen = screens[i];
         console.log(`${i.toString().padStart(6)} | ${screen.bounds.Left.toString().padStart(5)} ${screen.bounds.Top.toString().padStart(5)} | ${screen.bounds.Width.toString().padStart(5)} ${screen.bounds.Height.toString().padStart(5)}`);
     }
-    console.log();
-    console.log('0-Lower right, 1-Lower Left, 2-Upper left, 3-Upper right');
     process.exit(1);
 }
 export function run(args) {
@@ -200,56 +486,94 @@ export function run(args) {
     // Load ignore patterns from the same directory as the script
     const ignoresPath = join(import.meta.dirname, 'ignores.txt');
     loadIgnorePatterns(ignoresPath);
-    // Parse options
-    while (args.length > 0 && args[0].startsWith('-')) {
-        const opt = args[0].substring(1);
-        switch (opt) {
-            case 'd':
-                dbg = true;
-                console.log('Debug mode enabled.');
-                break;
-            case 'dbg':
-                dbgVerbose = true;
-                console.log(`[DBG] winpos version ${packageJson.default.version}`);
-                break;
-            case 'c':
-                console.log(screens.length);
-                process.exit(screens.length);
-                break;
-            case 'version':
-            case 'v':
-                console.log(`tswinpos version ${packageJson.default.version}`);
-                process.exit(0);
-                break;
-            default:
-                usage(`Unknown option: ${args[0]}`);
-                break;
+    // Parse arguments using new parser
+    const opts = parseArgs(args);
+    // Set debug flags
+    dbg = opts.debug;
+    dbgVerbose = opts.debugVerbose;
+    if (dbg)
+        console.log('Debug mode enabled.');
+    if (dbgVerbose)
+        console.log(`[DBG] winpos version ${packageJson.default.version}`);
+    // Handle -c (screen count)
+    if (opts.showCount) {
+        console.log(screens.length);
+        process.exit(screens.length);
+    }
+    // Handle load file (JSON config)
+    if (opts.loadFile) {
+        try {
+            const config = loadConfigFile(opts.loadFile);
+            const configs = Array.isArray(config) ? config : [config];
+            // If -save specified with CLI params, merge new config into loaded
+            if (opts.saveFile && opts.windowTitle) {
+                const newConfig = buildConfigFromOptions(opts);
+                if (newConfig) {
+                    // Apply the CLI-specified window first
+                    applyWindowConfig(newConfig, screens);
+                    // Save merged config
+                    saveConfigFile(opts.saveFile, newConfig, true);
+                }
+            }
+            // Apply all loaded configs
+            for (const cfg of configs) {
+                applyWindowConfig(cfg, screens);
+            }
+            return;
+        }
+        catch (e) {
+            console.error(`Error loading config: ${e.message}`);
+            process.exit(1);
         }
-        args = args.slice(1);
     }
-    // Handle commands
-    // console.log(DEBUG: args.length=', args.length, 'args[0]=', args[0], 'check=', args.length === 1 && args[0] === '*');
+    // Handle new flag-based syntax (-pos, -size, -min, -max)
+    if (opts.pos || opts.size || opts.minimize || opts.maximize) {
+        if (!opts.windowTitle) {
+            usage('Window title required when using -pos, -size, -min, or -max');
+            return;
+        }
+        const config = buildConfigFromOptions(opts);
+        if (config) {
+            applyWindowConfig(config, screens);
+            // Save if requested
+            if (opts.saveFile) {
+                saveConfigFile(opts.saveFile, config, existsSync(opts.saveFile));
+            }
+        }
+        return;
+    }
+    // If only -title provided (no -pos/-size/-min/-max), show window position info
+    if (opts.windowTitle && !opts.loadFile) {
+        showWindowInfo(opts.windowTitle);
+        return;
+    }
+    // Fall back to legacy positional argument handling
+    const posArgs = opts.positionalArgs;
     if (dbg)
-        console.log(`DEBUG[${packageJson.default.version}]: ${args.join(' ')}`);
-    if (args.length === 1 && args[0] === '*') {
+        console.log(`DEBUG[${packageJson.default.version}]: ${posArgs.join(' ')}`);
+    if (posArgs.length === 1 && posArgs[0] === '*') {
         listAllWindows();
         return;
     }
-    if (args.length === 1 && args[0] === '**') {
+    if (posArgs.length === 1 && posArgs[0] === '**') {
         listAllWindows(true);
         return;
     }
     // Check for minimize command (title + min/-min)
-    // TODO: Refactor to eliminate duplicate min/minimize check - consolidate with adjustWindow logic
-    if (args.length === 2 && (args[1].toLowerCase() === 'min' || args[1].toLowerCase() === '-min')) {
-        adjustWindow(args);
+    if (posArgs.length === 2 && (posArgs[1].toLowerCase() === 'min' || posArgs[1].toLowerCase() === '-min')) {
+        adjustWindow(posArgs);
+        return;
+    }
+    // Single positional arg = show window info
+    if (posArgs.length === 1) {
+        showWindowInfo(posArgs[0]);
         return;
     }
-    if (args.length < 4) {
+    if (posArgs.length < 4) {
         usage();
         return;
     }
-    adjustWindow(args);
+    adjustWindow(posArgs);
 }
 // CLI entry point using import.meta.main
 if (import.meta.main) {