cligr 1.0.7 → 1.0.9

package/.claude/worktrees/agent-ac25cfb2/scripts/test.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+/**
+ * Test runner script that compiles TypeScript tests with esbuild
+ * and runs them with Node.js built-in test runner
+ */
+
+import { build } from 'esbuild';
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const TESTS_DIR = path.join(PROJECT_ROOT, 'tests/integration');
+const DIST_DIR = path.join(PROJECT_ROOT, 'tests-dist');
+const SRC_DIR = path.join(PROJECT_ROOT, 'src');
+
+async function buildSourceModules() {
+  console.log('Building source modules...');
+
+  // Build source modules directly to src directory (as .js files alongside .ts)
+  const dirs = ['config', 'process', 'commands'];
+
+  for (const dir of dirs) {
+    const dirPath = path.join(SRC_DIR, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.ts'));
+
+    for (const file of files) {
+      const inFile = path.join(dirPath, file);
+      const outFile = path.join(dirPath, file.replace('.ts', '.js'));
+
+      await build({
+        entryPoints: [inFile],
+        bundle: false,
+        platform: 'node',
+        target: 'es2022',
+        format: 'esm',
+        outfile: outFile,
+        absWorkingDir: PROJECT_ROOT,
+        logLevel: 'silent',
+      });
+    }
+  }
+
+  console.log('Built source modules');
+}
+
+async function buildTests(skipBlocking = false) {
+  console.log('Building TypeScript tests...');
+
+  // Clean dist directory
+  if (fs.existsSync(DIST_DIR)) {
+    fs.rmSync(DIST_DIR, { recursive: true, force: true });
+  }
+  fs.mkdirSync(DIST_DIR, { recursive: true });
+
+  // Also create tests/integration subdirectory to match original structure
+  const outputSubDir = path.join(DIST_DIR, 'integration');
+  fs.mkdirSync(outputSubDir, { recursive: true });
+
+  // Find all test files
+  let testFiles = fs.readdirSync(TESTS_DIR)
+    .filter(f => f.endsWith('.test.ts'))
+    .map(f => path.join(TESTS_DIR, f));
+
+  // Skip blocking-processes tests by default (they have infinite loops)
+  if (skipBlocking) {
+    testFiles = testFiles.filter(f => !f.includes('blocking-processes'));
+  }
+
+  // Build each test file
+  for (const testFile of testFiles) {
+    const outputFile = path.join(
+      outputSubDir,
+      path.basename(testFile).replace('.ts', '.js')
+    );
+
+    await build({
+      entryPoints: [testFile],
+      bundle: false,
+      platform: 'node',
+      target: 'es2022',
+      format: 'esm',
+      outfile: outputFile,
+      absWorkingDir: PROJECT_ROOT,
+      logLevel: 'error',
+    });
+  }
+
+  console.log(`Built ${testFiles.length} test files`);
+  return testFiles.length;
+}
+
+function runTests(verbose = false) {
+  const testFiles = fs.readdirSync(path.join(DIST_DIR, 'integration'))
+    .filter(f => f.endsWith('.test.js'))
+    .map(f => path.join(DIST_DIR, 'integration', f));
+
+  const args = ['--test'];
+  if (verbose) {
+    args.push('--verbose');
+  }
+  args.push(...testFiles);
+
+  console.log('\nRunning tests...\n');
+  const result = spawnSync('node', args, {
+    stdio: 'inherit',
+    cwd: PROJECT_ROOT,
+    shell: true
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`Tests failed with exit code ${result.status}`);
+  }
+
+  return { status: result.status };
+}
+
+async function cleanupSourceModules() {
+  // Remove generated .js files from src directory
+  const dirs = ['config', 'process', 'commands'];
+
+  for (const dir of dirs) {
+    const dirPath = path.join(SRC_DIR, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.js'));
+
+    for (const file of files) {
+      const filePath = path.join(dirPath, file);
+      fs.unlinkSync(filePath);
+    }
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const includeBlocking = args.includes('--include-blocking') || args.includes('-b');
+
+  try {
+    await buildSourceModules();
+    await buildTests(!includeBlocking);
+    runTests(verbose);
+
+    // Clean up
+    cleanupSourceModules();
+    if (fs.existsSync(DIST_DIR)) {
+      fs.rmSync(DIST_DIR, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.error('Test failed:', error.message);
+    // Still try to clean up on error
+    try {
+      cleanupSourceModules();
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/.claude/worktrees/agent-ac25cfb2/src/commands/config.ts

@@ -0,0 +1,121 @@
+import { spawn, spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const CONFIG_FILENAME = '.cligr.yml';
+const TEMPLATE = `# Cligr Configuration
+
+groups:
+  web:
+    tool: docker
+    restart: false
+    items:
+      - "nginx,8080"      # $1=nginx (name), $2=8080 (port)
+      - "nginx,3000"
+
+  simple:
+    tool: node
+    items:
+      - "server"          # $1=server (name only)
+
+tools:
+  docker:
+    cmd: "docker run -p $2:$2 nginx"   # $1=name, $2=port
+  node:
+    cmd: "node $1.js"                   # $1=file name
+
+# Syntax:
+# - Items are comma-separated: "name,arg2,arg3"
+# - $1 = name (first value)
+# - $2, $3... = additional arguments
+# - If no tool specified, executes directly
+`;
+
+function detectEditor(): string {
+  const platform = process.platform;
+
+  // Try VS Code first
+  const whichCmd = platform === 'win32' ? 'where' : 'which';
+  const codeCheck = spawnSync(whichCmd, ['code'], { stdio: 'ignore' });
+  if (codeCheck.status === 0) {
+    return 'code';
+  }
+
+  // Try EDITOR environment variable
+  if (process.env.EDITOR) {
+    return process.env.EDITOR;
+  }
+
+  // Platform defaults
+  if (platform === 'win32') {
+    return 'notepad.exe';
+  }
+  return 'vim';
+}
+
+function spawnEditor(filePath: string, editorCmd: string): void {
+  // Check if editor exists before spawning
+  const platform = process.platform;
+  const whichCmd = platform === 'win32' ? 'where' : 'which';
+  const editorCheck = spawnSync(whichCmd, [editorCmd], { stdio: 'ignore' });
+
+  if (editorCheck.status !== 0 && editorCmd !== process.env.EDITOR) {
+    throw new Error(
+      `Editor '${editorCmd}' not found.\n` +
+      `Install VS Code or set EDITOR environment variable.\n\n` +
+      `Example:\n` +
+      `  export EDITOR=vim\n` +
+      `  cligr config`
+    );
+  }
+
+  // Spawn detached so terminal is not blocked
+  const child = spawn(editorCmd, [filePath], {
+    detached: true,
+    stdio: 'ignore',
+    shell: platform === 'win32',
+  });
+
+  child.unref();
+}
+
+function createTemplate(filePath: string): void {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, TEMPLATE, 'utf-8');
+}
+
+export async function configCommand(): Promise<number> {
+  try {
+    // Determine config path (same logic as ConfigLoader)
+    const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
+    const currentDirConfig = path.resolve(CONFIG_FILENAME);
+
+    let configPath: string;
+    if (fs.existsSync(homeDirConfig)) {
+      configPath = homeDirConfig;
+    } else if (fs.existsSync(currentDirConfig)) {
+      configPath = currentDirConfig;
+    } else {
+      configPath = homeDirConfig;
+    }
+
+    // Create template if doesn't exist
+    if (!fs.existsSync(configPath)) {
+      createTemplate(configPath);
+    }
+
+    // Detect and open editor
+    const editor = detectEditor();
+    spawnEditor(configPath, editor);
+
+    console.log(`Opening ${configPath} in ${editor}...`);
+    return 0;
+  } catch (err: any) {
+    console.error(`Error: ${err.message}`);
+    return 1;
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/commands/groups.ts

@@ -0,0 +1,68 @@
+import { ConfigLoader } from '../config/loader.js';
+
+interface GroupDetails {
+  name: string;
+  tool: string;
+  restart: string;
+  itemCount: number;
+}
+
+export async function groupsCommand(verbose: boolean): Promise<number> {
+  const loader = new ConfigLoader();
+
+  try {
+    const groupNames = loader.listGroups();
+
+    if (groupNames.length === 0) {
+      // No groups defined - empty output
+      return 0;
+    }
+
+    if (verbose) {
+      // Verbose mode: gather details and print table
+      const config = loader.load();
+      const details: GroupDetails[] = [];
+
+      for (const name of groupNames) {
+        const group = config.groups[name];
+        details.push({
+          name,
+          tool: group.tool || '(none)',
+          restart: group.restart || '(none)',
+          itemCount: Object.keys(group.items).length,
+        });
+      }
+
+      // Calculate column widths
+      const maxNameLen = Math.max('GROUP'.length, ...details.map(d => d.name.length));
+      const maxToolLen = Math.max('TOOL'.length, ...details.map(d => d.tool.length));
+      const maxRestartLen = Math.max('RESTART'.length, ...details.map(d => d.restart.length));
+
+      // Print header
+      const header = 'GROUP'.padEnd(maxNameLen) + '  ' +
+                     'TOOL'.padEnd(maxToolLen) + '  ' +
+                     'RESTART'.padEnd(maxRestartLen) + '  ' +
+                     'ITEMS';
+      console.log(header);
+
+      // Print rows
+      for (const d of details) {
+        const row = d.name.padEnd(maxNameLen) + '  ' +
+                    d.tool.padEnd(maxToolLen) + '  ' +
+                    d.restart.padEnd(maxRestartLen) + '  ' +
+                    String(d.itemCount);
+        console.log(row);
+      }
+    } else {
+      // Simple mode: just list names
+      for (const name of groupNames) {
+        console.log(name);
+      }
+    }
+
+    return 0;
+  } catch (err) {
+    console.error((err as Error).message);
+    return 1;
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/commands/ls.ts

@@ -0,0 +1,25 @@
+import { ConfigLoader } from '../config/loader.js';
+
+export async function lsCommand(groupName: string): Promise<number> {
+  const loader = new ConfigLoader();
+
+  try {
+    const { config, items } = loader.getGroup(groupName);
+
+    console.log(`\nGroup: ${groupName}`);
+    console.log(`Tool: ${config.tool}`);
+    console.log(`Restart: ${config.restart}`);
+    console.log('\nItems:');
+
+    for (const item of items) {
+      console.log(`  ${item.name}: ${item.value}`);
+    }
+
+    console.log('');
+
+    return 0;
+  } catch (err) {
+    console.error((err as Error).message);
+    return 1;
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/commands/up.ts

@@ -0,0 +1,49 @@
+import { ConfigLoader } from '../config/loader.js';
+import { TemplateExpander } from '../process/template.js';
+import { ProcessManager } from '../process/manager.js';
+import { PidStore } from '../process/pid-store.js';
+
+export async function upCommand(groupName: string): Promise<number> {
+  const loader = new ConfigLoader();
+  const manager = new ProcessManager();
+  const pidStore = new PidStore();
+
+  try {
+    // Clean up any stale PID files for this group on startup
+    await pidStore.cleanupStalePids();
+
+    // Load group config
+    const { config, items, tool, toolTemplate, params } = loader.getGroup(groupName);
+
+    // Build process items
+    const processItems = items.map((item, index) =>
+      TemplateExpander.parseItem(tool, toolTemplate, item, index, params)
+    );
+
+    // Spawn all processes
+    manager.spawnGroup(groupName, processItems, config.restart);
+
+    console.log(`Started group ${groupName} with ${processItems.length} process(es)`);
+    console.log('Press Ctrl+C to stop...');
+
+    // Wait for signals
+    return new Promise((resolve) => {
+      const cleanup = async () => {
+        console.log('\nShutting down...');
+        process.removeListener('SIGINT', cleanup);
+        process.removeListener('SIGTERM', cleanup);
+        await manager.killAll();
+        resolve(0);
+      };
+
+      process.on('SIGINT', cleanup);
+      process.on('SIGTERM', cleanup);
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === 'ConfigError') {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/config/loader.ts

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import yaml from 'js-yaml';
+import type { CliGrConfig, GroupConfig, ToolConfig, ItemEntry } from './types.js';
+
+const CONFIG_FILENAME = '.cligr.yml';
+
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ConfigError';
+  }
+}
+
+export class ConfigLoader {
+  private configPath: string;
+
+  constructor(configPath?: string) {
+    if (configPath) {
+      // User provided explicit path
+      this.configPath = path.resolve(configPath);
+    } else {
+      // Auto-detect: home dir first, then current dir
+      const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
+      const currentDirConfig = path.resolve(CONFIG_FILENAME);
+
+      if (fs.existsSync(homeDirConfig)) {
+        this.configPath = homeDirConfig;
+      } else if (fs.existsSync(currentDirConfig)) {
+        this.configPath = currentDirConfig;
+      } else {
+        // Store home dir as default, will error in load()
+        this.configPath = homeDirConfig;
+      }
+    }
+  }
+
+  load(): CliGrConfig {
+    if (!fs.existsSync(this.configPath)) {
+      throw new ConfigError(
+        `Config file not found. Looking for:\n` +
+        `  - ${path.join(os.homedir(), CONFIG_FILENAME)}\n` +
+        `  - ${path.resolve(CONFIG_FILENAME)}`
+      );
+    }
+
+    const content = fs.readFileSync(this.configPath, 'utf-8');
+    let config: unknown;
+
+    try {
+      config = yaml.load(content);
+    } catch (err) {
+      throw new ConfigError(`Invalid YAML: ${(err as Error).message}`);
+    }
+
+    return this.validate(config);
+  }
+
+  private validate(config: unknown): CliGrConfig {
+    if (!config || typeof config !== 'object') {
+      throw new ConfigError('Config must be an object');
+    }
+
+    const cfg = config as Record<string, unknown>;
+
+    if (!cfg.groups || typeof cfg.groups !== 'object') {
+      throw new ConfigError('Config must have a "groups" object');
+    }
+
+    // Validate each group's items
+    for (const [groupName, group] of Object.entries(cfg.groups as Record<string, unknown>)) {
+      if (group && typeof group === 'object') {
+        const groupObj = group as Record<string, unknown>;
+        this.validateItems(groupObj.items, groupName);
+      }
+    }
+
+    return cfg as unknown as CliGrConfig;
+  }
+
+  private validateItems(items: unknown, groupName: string): void {
+    if (!items || typeof items !== 'object' || Array.isArray(items)) {
+      throw new ConfigError(
+        `Group "${groupName}": items must be an object with named entries, e.g.:\n` +
+        '  items:\n' +
+        '    serviceName: "value1,value2"'
+      );
+    }
+
+    const seenNames = new Set<string>();
+
+    for (const [name, value] of Object.entries(items as Record<string, unknown>)) {
+      if (typeof value !== 'string') {
+        throw new ConfigError(`Group "${groupName}": item "${name}" must have a string value`);
+      }
+
+      if (seenNames.has(name)) {
+        throw new ConfigError(
+          `Group "${groupName}": duplicate item name "${name}". ` +
+          `Item names must be unique within a group.`
+        );
+      }
+      seenNames.add(name);
+    }
+  }
+
+  private normalizeItems(items: Record<string, string>): ItemEntry[] {
+    return Object.entries(items).map(([name, value]) => ({
+      name,
+      value
+    }));
+  }
+
+  getGroup(name: string): { config: GroupConfig; items: ItemEntry[]; tool: string | null; toolTemplate: string | null; params: Record<string, string> } {
+    const config = this.load();
+    const group = config.groups[name];
+
+    if (!group) {
+      const available = Object.keys(config.groups).join(', ');
+      throw new ConfigError(`Unknown group: ${name}. Available: ${available}`);
+    }
+
+    // Normalize items to ItemEntry[]
+    const items = this.normalizeItems(group.items);
+
+    // Resolve tool
+    let toolTemplate: string | null = null;
+    let tool: string | null = null;
+
+    if (config.tools && config.tools[group.tool]) {
+      toolTemplate = config.tools[group.tool].cmd;
+      tool = group.tool;
+    } else {
+      tool = null;
+      toolTemplate = null;
+    }
+
+    const params = group.params || {};
+
+    return { config: group, items, tool, toolTemplate, params };
+  }
+
+  listGroups(): string[] {
+    const config = this.load();
+    return Object.keys(config.groups);
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/config/types.ts

@@ -0,0 +1,26 @@
+export interface ToolConfig {
+  cmd: string;
+}
+
+export interface ItemEntry {
+  name: string;   // the key from config (e.g., "nginxService1")
+  value: string;  // the value string (e.g., "nginx,8080")
+}
+
+export interface GroupConfig {
+  tool: string;
+  restart?: 'yes' | 'no' | 'unless-stopped';
+  params?: Record<string, string>;
+  items: Record<string, string>;
+}
+
+export interface CliGrConfig {
+  tools?: Record<string, ToolConfig>;
+  groups: Record<string, GroupConfig>;
+}
+
+export interface ProcessItem {
+  name: string;
+  args: string[];
+  fullCmd: string;
+}

package/.claude/worktrees/agent-ac25cfb2/src/index.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import { upCommand } from './commands/up.js';
+import { lsCommand } from './commands/ls.js';
+import { configCommand } from './commands/config.js';
+import { groupsCommand } from './commands/groups.js';
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    printUsage();
+    process.exit(1);
+    return;
+  }
+
+  const [firstArg, ...rest] = args;
+  let verbose = false;
+
+  // Check if this is a known command
+  const knownCommands = ['config', 'up', 'ls', 'groups'];
+
+  if (knownCommands.includes(firstArg)) {
+    // It's a command
+    const command = firstArg;
+    let groupName: string | undefined;
+
+    // Parse flags for commands that support them
+    if (command === 'groups') {
+      // groups command supports -v/--verbose flags
+      const flagIndex = rest.findIndex(arg => arg === '-v' || arg === '--verbose');
+      if (flagIndex !== -1) {
+        verbose = true;
+        // Remove the flag from rest so it's not treated as a group name
+        rest.splice(flagIndex, 1);
+      }
+    }
+    groupName = rest[0];
+
+    // config and groups commands don't require group name
+    if (command !== 'config' && command !== 'groups' && !groupName) {
+      console.error('Error: group name required');
+      printUsage();
+      process.exit(1);
+      return;
+    }
+
+    let exitCode = 0;
+
+    switch (command) {
+      case 'config':
+        exitCode = await configCommand();
+        break;
+      case 'up':
+        exitCode = await upCommand(groupName!);
+        break;
+      case 'ls':
+        exitCode = await lsCommand(groupName!);
+        break;
+      case 'groups':
+        exitCode = await groupsCommand(verbose);
+        break;
+    }
+
+    process.exit(exitCode);
+  } else {
+    // Treat as a group name - run up command
+    const exitCode = await upCommand(firstArg);
+    process.exit(exitCode);
+  }
+}
+
+function printUsage(): void {
+  console.log(`
+Usage: cligr <group> | <command> [options]
+
+Commands:
+  config              Open config file in editor
+  ls <group>          List all items in the group
+  groups [-v|--verbose]  List all groups
+
+Options:
+  -v, --verbose       Show detailed group information
+
+Examples:
+  cligr test1         Start all processes in test1 group
+  cligr config
+  cligr ls test1
+  cligr groups
+  cligr groups -v
+`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(2);
+});