cligr 1.0.5 → 1.0.7

package/tests/integration/template-expander.test.ts

@@ -11,15 +11,15 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 import { TemplateExpander } from '../../src/process/template.js';
-import type { ProcessItem } from '../../src/config/types.js';
+import type { ProcessItem, ItemEntry } from '../../src/config/types.js';
 
 describe('TemplateExpander Integration Tests', () => {
   describe('expand()', () => {
     it('should expand template with single argument', () => {
       const template = 'echo $1';
-      const itemStr = 'hello';
+      const item: ItemEntry = { name: 'hello', value: 'hello' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.name, 'hello');
       assert.deepStrictEqual(result.args, ['hello']);
@@ -28,9 +28,9 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should expand template with multiple arguments', () => {
       const template = 'docker run -p $2:$3 $1';
-      const itemStr = 'nginx,8080,80';
+      const item: ItemEntry = { name: 'nginx', value: 'nginx,8080,80' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.name, 'nginx');
       assert.deepStrictEqual(result.args, ['nginx', '8080', '80']);
@@ -39,27 +39,27 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should replace all occurrences of placeholder', () => {
       const template = 'echo $1 and $1 again';
-      const itemStr = 'test';
+      const item: ItemEntry = { name: 'test', value: 'test' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.fullCmd, 'echo test and test again');
     });
 
     it('should handle placeholders with spaces around', () => {
       const template = 'cmd $1 opt $2 end';
-      const itemStr = 'arg1,arg2';
+      const item: ItemEntry = { name: 'args', value: 'arg1,arg2' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.fullCmd, 'cmd arg1 opt arg2 end');
     });
 
-    it('should use index as name when first argument is empty', () => {
+    it('should use ItemEntry name when first argument is empty', () => {
       const template = 'echo test';
-      const itemStr = ',arg2,arg3';
+      const item: ItemEntry = { name: 'item-5', value: ',arg2,arg3' };
 
-      const result = TemplateExpander.expand(template, itemStr, 5);
+      const result = TemplateExpander.expand(template, item, 5);
 
       assert.strictEqual(result.name, 'item-5');
       assert.deepStrictEqual(result.args, ['', 'arg2', 'arg3']);
@@ -67,29 +67,29 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle single argument with no commas', () => {
       const template = 'node $1';
-      const itemStr = 'server.js';
+      const item: ItemEntry = { name: 'server', value: 'server.js' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
-      assert.strictEqual(result.name, 'server.js');
+      assert.strictEqual(result.name, 'server');
       assert.deepStrictEqual(result.args, ['server.js']);
       assert.strictEqual(result.fullCmd, 'node server.js');
     });
 
     it('should handle more placeholders than arguments', () => {
       const template = 'cmd $1 $2 $3 $4';
-      const itemStr = 'a,b';
+      const item: ItemEntry = { name: 'args', value: 'a,b' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.fullCmd, 'cmd a b $3 $4');
     });
 
     it('should trim whitespace from arguments', () => {
       const template = 'cmd $1 $2 $3';
-      const itemStr = ' a , b , c ';
+      const item: ItemEntry = { name: 'args', value: ' a , b , c ' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.deepStrictEqual(result.args, ['a', 'b', 'c']);
       assert.strictEqual(result.fullCmd, 'cmd a b c');
@@ -97,9 +97,9 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle empty string argument', () => {
       const template = 'cmd $1 $2 $3';
-      const itemStr = 'first,,third';
+      const item: ItemEntry = { name: 'args', value: 'first,,third' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.deepStrictEqual(result.args, ['first', '', 'third']);
       assert.strictEqual(result.fullCmd, 'cmd first  third');
@@ -107,9 +107,9 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle quoted paths with spaces in template', () => {
       const template = '"C:\\Program Files\\app\\app.exe" $1';
-      const itemStr = 'arg1';
+      const item: ItemEntry = { name: 'arg', value: 'arg1' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.fullCmd, '"C:\\Program Files\\app\\app.exe" arg1');
     });
@@ -120,9 +120,9 @@ describe('TemplateExpander Integration Tests', () => {
       it('should use tool template for expansion', () => {
         const tool = 'docker';
         const toolTemplate = 'docker run -it --rm $1';
-        const itemStr = 'nginx,-p,80:80';
+        const item: ItemEntry = { name: 'nginx', value: 'nginx,-p,80:80' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0);
 
         assert.strictEqual(result.name, 'nginx');
         assert.strictEqual(result.fullCmd, 'docker run -it --rm nginx -p 80:80');
@@ -131,9 +131,9 @@ describe('TemplateExpander Integration Tests', () => {
       it('should handle complex docker compose templates', () => {
         const tool = 'compose';
         const toolTemplate = 'docker-compose run --service-ports $1';
-        const itemStr = 'web';
+        const item: ItemEntry = { name: 'web', value: 'web' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0);
 
         assert.strictEqual(result.name, 'web');
         assert.strictEqual(result.fullCmd, 'docker-compose run --service-ports web');
@@ -142,9 +142,9 @@ describe('TemplateExpander Integration Tests', () => {
       it('should handle templates with no placeholders', () => {
         const tool = 'echo';
         const toolTemplate = 'echo hello world';
-        const itemStr = 'item1';
+        const item: ItemEntry = { name: 'item1', value: 'item1' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0);
 
         assert.strictEqual(result.name, 'item1');
         assert.strictEqual(result.fullCmd, 'echo hello world');
@@ -155,31 +155,31 @@ describe('TemplateExpander Integration Tests', () => {
       it('should prefix command with tool name', () => {
         const tool = 'node';
         const toolTemplate = null;
-        const itemStr = 'server.js,3000';
+        const item: ItemEntry = { name: 'server', value: 'server.js,3000' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0);
 
-        assert.strictEqual(result.name, 'server.js');
+        assert.strictEqual(result.name, 'server');
         assert.strictEqual(result.fullCmd, 'node server.js,3000');
       });
 
       it('should handle null tool and toolTemplate', () => {
         const tool = null;
         const toolTemplate = null;
-        const itemStr = 'echo hello';
+        const item: ItemEntry = { name: 'echo', value: 'echo hello' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0);
 
         assert.strictEqual(result.name, 'echo');
         assert.strictEqual(result.fullCmd, 'echo hello');
       });
 
-      it('should use index for name when args are empty', () => {
+      it('should use ItemEntry name when value is empty', () => {
         const tool = null;
         const toolTemplate = null;
-        const itemStr = '';
+        const item: ItemEntry = { name: 'item-3', value: '' };
 
-        const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 3);
+        const result = TemplateExpander.parseItem(tool, toolTemplate, item, 3);
 
         assert.strictEqual(result.name, 'item-3');
       });
@@ -188,11 +188,11 @@ describe('TemplateExpander Integration Tests', () => {
         const tool = 'python';
         const toolTemplate = null;
 
-        const result1 = TemplateExpander.parseItem(tool, toolTemplate, 'script1.py', 0);
-        const result2 = TemplateExpander.parseItem(tool, toolTemplate, 'script2.py', 1);
+        const result1 = TemplateExpander.parseItem(tool, toolTemplate, { name: 'script1', value: 'script1.py' }, 0);
+        const result2 = TemplateExpander.parseItem(tool, toolTemplate, { name: 'script2', value: 'script2.py' }, 1);
 
-        assert.strictEqual(result1.name, 'script1.py');
-        assert.strictEqual(result2.name, 'script2.py');
+        assert.strictEqual(result1.name, 'script1');
+        assert.strictEqual(result2.name, 'script2');
       });
     });
   });
@@ -200,9 +200,9 @@ describe('TemplateExpander Integration Tests', () => {
   describe('Real-world scenarios', () => {
     it('should handle docker service templates', () => {
       const toolTemplate = 'docker run -d --name $1_$2 -p $2:$3 $1';
-      const itemStr = 'nginx,8080,80';
+      const item: ItemEntry = { name: 'nginx', value: 'nginx,8080,80' };
 
-      const result = TemplateExpander.expand(toolTemplate, itemStr, 0);
+      const result = TemplateExpander.expand(toolTemplate, item, 0);
 
       assert.strictEqual(result.name, 'nginx');
       assert.strictEqual(result.fullCmd, 'docker run -d --name nginx_8080 -p 8080:80 nginx');
@@ -210,19 +210,19 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle node process manager templates', () => {
       const toolTemplate = 'node $1 --port $2';
-      const itemStr = 'server.js,3000';
+      const item: ItemEntry = { name: 'server', value: 'server.js,3000' };
 
-      const result = TemplateExpander.expand(toolTemplate, itemStr, 0);
+      const result = TemplateExpander.expand(toolTemplate, item, 0);
 
-      assert.strictEqual(result.name, 'server.js');
+      assert.strictEqual(result.name, 'server');
       assert.strictEqual(result.fullCmd, 'node server.js --port 3000');
     });
 
     it('should handle database connection templates', () => {
       const toolTemplate = 'psql -h $1 -p $2 -U $3 -d $4';
-      const itemStr = 'localhost,5432,admin,mydb';
+      const item: ItemEntry = { name: 'localhost', value: 'localhost,5432,admin,mydb' };
 
-      const result = TemplateExpander.expand(toolTemplate, itemStr, 0);
+      const result = TemplateExpander.expand(toolTemplate, item, 0);
 
       assert.strictEqual(result.name, 'localhost');
       assert.strictEqual(result.fullCmd, 'psql -h localhost -p 5432 -U admin -d mydb');
@@ -230,9 +230,9 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle custom script execution', () => {
       const toolTemplate = './scripts/$1.sh $2 $3';
-      const itemStr = 'deploy,production,force';
+      const item: ItemEntry = { name: 'deploy', value: 'deploy,production,force' };
 
-      const result = TemplateExpander.expand(toolTemplate, itemStr, 0);
+      const result = TemplateExpander.expand(toolTemplate, item, 0);
 
       assert.strictEqual(result.name, 'deploy');
       assert.strictEqual(result.fullCmd, './scripts/deploy.sh production force');
@@ -240,11 +240,11 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle Windows executable paths', () => {
       const toolTemplate = '"C:\\My App\\app.exe" --config $1 --port $2';
-      const itemStr = 'config.json,8080';
+      const item: ItemEntry = { name: 'config', value: 'config.json,8080' };
 
-      const result = TemplateExpander.expand(toolTemplate, itemStr, 0);
+      const result = TemplateExpander.expand(toolTemplate, item, 0);
 
-      assert.strictEqual(result.name, 'config.json');
+      assert.strictEqual(result.name, 'config');
       assert.strictEqual(result.fullCmd, '"C:\\My App\\app.exe" --config config.json --port 8080');
     });
   });
@@ -252,9 +252,9 @@ describe('TemplateExpander Integration Tests', () => {
   describe('Edge cases and error handling', () => {
     it('should handle very long argument lists', () => {
       const template = Array.from({ length: 20 }, (_, i) => `$${i + 1}`).join(' ');
-      const itemStr = Array.from({ length: 20 }, (_, i) => `arg${i}`).join(',');
+      const item: ItemEntry = { name: 'args', value: Array.from({ length: 20 }, (_, i) => `arg${i}`).join(',') };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.args.length, 20);
       assert.ok(result.fullCmd.includes('arg0'));
@@ -263,38 +263,38 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle special characters in arguments', () => {
       const template = 'echo "$1" "$2"';
-      const itemStr = 'hello world,test&argument';
+      const item: ItemEntry = { name: 'args', value: 'hello world,test&argument' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.deepStrictEqual(result.args, ['hello world', 'test&argument']);
     });
 
     it('should handle unicode characters', () => {
       const template = 'echo $1 $2';
-      const itemStr = 'こんにちは,世界';
+      const item: ItemEntry = { name: 'unicode', value: 'こんにちは,世界' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
-      assert.strictEqual(result.name, 'こんにちは');
+      assert.strictEqual(result.name, 'unicode');
       assert.deepStrictEqual(result.args, ['こんにちは', '世界']);
       assert.strictEqual(result.fullCmd, 'echo こんにちは 世界');
     });
 
     it('should handle numeric arguments', () => {
       const template = 'app --port $1 --timeout $2 --retries $3';
-      const itemStr = '8080,5000,5';
+      const item: ItemEntry = { name: 'ports', value: '8080,5000,5' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(result.fullCmd, 'app --port 8080 --timeout 5000 --retries 5');
     });
 
     it('should preserve whitespace in command template', () => {
       const template = 'cmd    $1    $2';
-      const itemStr = 'a,b';
+      const item: ItemEntry = { name: 'args', value: 'a,b' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0);
+      const result = TemplateExpander.expand(template, item, 0);
 
       // Template whitespace is preserved
       assert.strictEqual(result.fullCmd, 'cmd    a    b');
@@ -302,9 +302,13 @@ describe('TemplateExpander Integration Tests', () => {
   });
 
   describe('Multiple items in sequence', () => {
-    it('should generate unique names using index', () => {
+    it('should generate unique names using ItemEntry name', () => {
       const template = 'worker $1';
-      const items = ['job1', 'job2', 'job3'];
+      const items: ItemEntry[] = [
+        { name: 'job1', value: 'job1' },
+        { name: 'job2', value: 'job2' },
+        { name: 'job3', value: 'job3' }
+      ];
 
       const results = items.map((item, index) =>
         TemplateExpander.expand(template, item, index)
@@ -315,27 +319,31 @@ describe('TemplateExpander Integration Tests', () => {
       assert.strictEqual(results[2].name, 'job3');
     });
 
-    it('should use index as fallback for identical names', () => {
+    it('should use ItemEntry name for identical values', () => {
       const template = 'echo $1';
-      const items = ['test', 'test', 'test'];
+      const items: ItemEntry[] = [
+        { name: 'test1', value: 'test' },
+        { name: 'test2', value: 'test' },
+        { name: 'test3', value: 'test' }
+      ];
 
       const results = items.map((item, index) =>
         TemplateExpander.expand(template, item, index)
       );
 
-      // All will have name 'test' since first arg is used
-      assert.strictEqual(results[0].name, 'test');
-      assert.strictEqual(results[1].name, 'test');
-      assert.strictEqual(results[2].name, 'test');
+      // All will have their unique ItemEntry name
+      assert.strictEqual(results[0].name, 'test1');
+      assert.strictEqual(results[1].name, 'test2');
+      assert.strictEqual(results[2].name, 'test3');
     });
   });
 
   describe('ProcessItem type compliance', () => {
     it('should return valid ProcessItem objects', () => {
       const template = 'cmd $1';
-      const itemStr = 'arg1,arg2';
+      const item: ItemEntry = { name: 'arg1', value: 'arg1,arg2' };
 
-      const result: ProcessItem = TemplateExpander.expand(template, itemStr, 0);
+      const result: ProcessItem = TemplateExpander.expand(template, item, 0);
 
       assert.strictEqual(typeof result.name, 'string');
       assert.ok(Array.isArray(result.args));
@@ -346,9 +354,9 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should have consistent structure across different calls', () => {
       const results: ProcessItem[] = [
-        TemplateExpander.expand('echo $1', 'test', 0),
-        TemplateExpander.expand('cmd $1 $2', 'a,b', 1),
-        TemplateExpander.parseItem('node', null, 'app.js', 2),
+        TemplateExpander.expand('echo $1', { name: 'test', value: 'test' }, 0),
+        TemplateExpander.expand('cmd $1 $2', { name: 'args', value: 'a,b' }, 1),
+        TemplateExpander.parseItem('node', null, { name: 'app', value: 'app.js' }, 2),
       ];
 
       for (const result of results) {
@@ -363,10 +371,10 @@ describe('TemplateExpander Integration Tests', () => {
   describe('Named params', () => {
     it('should replace named param in template', () => {
       const template = 'node $1.js --name $name';
-      const itemStr = 'server';
+      const item: ItemEntry = { name: 'server', value: 'server' };
       const params = { name: 'John doe' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.name, 'server');
       assert.strictEqual(result.fullCmd, 'node server.js --name John doe');
@@ -374,49 +382,49 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should replace multiple named params', () => {
       const template = 'app --host $host --port $port --env $env';
-      const itemStr = 'myapp';
+      const item: ItemEntry = { name: 'myapp', value: 'myapp' };
       const params = { host: 'localhost', port: '3000', env: 'production' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.fullCmd, 'app --host localhost --port 3000 --env production');
     });
 
     it('should combine positional and named params', () => {
       const template = 'node $1.js --name $name --port $port';
-      const itemStr = 'server';
+      const item: ItemEntry = { name: 'server', value: 'server' };
       const params = { name: 'Alice', port: '8080' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.fullCmd, 'node server.js --name Alice --port 8080');
     });
 
     it('should handle empty params object', () => {
       const template = 'node $1.js';
-      const itemStr = 'server';
+      const item: ItemEntry = { name: 'server', value: 'server' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, {});
+      const result = TemplateExpander.expand(template, item, 0, {});
 
       assert.strictEqual(result.fullCmd, 'node server.js');
     });
 
     it('should leave unreplaced named params as-is', () => {
       const template = 'node $1.js --name $name --env $env';
-      const itemStr = 'server';
+      const item: ItemEntry = { name: 'server', value: 'server' };
       const params = { name: 'Bob' }; // env not provided
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.fullCmd, 'node server.js --name Bob --env $env');
     });
 
     it('should replace all occurrences of named param', () => {
       const template = 'echo $name and $name again';
-      const itemStr = 'test';
+      const item: ItemEntry = { name: 'test', value: 'test' };
       const params = { name: 'world' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.fullCmd, 'echo world and world again');
     });
@@ -424,10 +432,10 @@ describe('TemplateExpander Integration Tests', () => {
     it('should work with parseItem for registered tools', () => {
       const tool = 'node-param';
       const toolTemplate = 'node $1.js --name $name';
-      const itemStr = 'server';
+      const item: ItemEntry = { name: 'server', value: 'server' };
       const params = { name: 'Charlie' };
 
-      const result = TemplateExpander.parseItem(tool, toolTemplate, itemStr, 0, params);
+      const result = TemplateExpander.parseItem(tool, toolTemplate, item, 0, params);
 
       assert.strictEqual(result.name, 'server');
       assert.strictEqual(result.fullCmd, 'node server.js --name Charlie');
@@ -435,10 +443,10 @@ describe('TemplateExpander Integration Tests', () => {
 
     it('should handle named params with spaces in values', () => {
       const template = 'echo "Hello, $name!"';
-      const itemStr = 'test';
+      const item: ItemEntry = { name: 'test', value: 'test' };
       const params = { name: 'John Doe' };
 
-      const result = TemplateExpander.expand(template, itemStr, 0, params);
+      const result = TemplateExpander.expand(template, item, 0, params);
 
       assert.strictEqual(result.fullCmd, 'echo "Hello, John Doe!"');
     });

package/.claude/settings.local.json

@@ -1,13 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node scripts/test.js --verbose)",
-      "Bash(node:*)",
-      "Bash(npm test)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git reset:*)",
-      "Bash(npm run build:*)"
-    ]
-  }
-}

package/dist/commands/config.js

@@ -1,102 +0,0 @@
-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() {
-  const platform = process.platform;
-  const whichCmd = platform === "win32" ? "where" : "which";
-  const codeCheck = spawnSync(whichCmd, ["code"], { stdio: "ignore" });
-  if (codeCheck.status === 0) {
-    return "code";
-  }
-  if (process.env.EDITOR) {
-    return process.env.EDITOR;
-  }
-  if (platform === "win32") {
-    return "notepad.exe";
-  }
-  return "vim";
-}
-function spawnEditor(filePath, editorCmd) {
-  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.
-Install VS Code or set EDITOR environment variable.
-
-Example:
-  export EDITOR=vim
-  cligr config`
-    );
-  }
-  const child = spawn(editorCmd, [filePath], {
-    detached: true,
-    stdio: "ignore",
-    shell: platform === "win32"
-  });
-  child.unref();
-}
-function createTemplate(filePath) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(filePath, TEMPLATE, "utf-8");
-}
-async function configCommand() {
-  try {
-    const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
-    const currentDirConfig = path.resolve(CONFIG_FILENAME);
-    let configPath;
-    if (fs.existsSync(homeDirConfig)) {
-      configPath = homeDirConfig;
-    } else if (fs.existsSync(currentDirConfig)) {
-      configPath = currentDirConfig;
-    } else {
-      configPath = homeDirConfig;
-    }
-    if (!fs.existsSync(configPath)) {
-      createTemplate(configPath);
-    }
-    const editor = detectEditor();
-    spawnEditor(configPath, editor);
-    console.log(`Opening ${configPath} in ${editor}...`);
-    return 0;
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    return 1;
-  }
-}
-export {
-  configCommand
-};

package/dist/commands/down.js

@@ -1,26 +0,0 @@
-import { ProcessManager } from "../process/manager.js";
-async function downCommand(groupName) {
-  const manager = new ProcessManager();
-  const result = await manager.killGroupByPid(groupName);
-  if (result.killed === 0 && result.notRunning === 0) {
-    console.log(`Group '${groupName}' is not running`);
-    return 0;
-  }
-  if (result.killed > 0) {
-    console.log(`Stopped ${result.killed} process(es) for group '${groupName}'`);
-  }
-  if (result.notRunning > 0) {
-    console.log(`Cleaned up ${result.notRunning} stale PID file(s) for group '${groupName}'`);
-  }
-  if (result.errors.length > 0) {
-    console.error("Errors while stopping processes:");
-    for (const err of result.errors) {
-      console.error(`  ${err}`);
-    }
-    return 1;
-  }
-  return 0;
-}
-export {
-  downCommand
-};