1.6.0: Introduce CLI utility commands, shell completion system, command history tracking, and comprehensive tests

Author: kaihaase

CLAUDE.md

@@ -42,6 +42,19 @@ $ lt
 - [Configuration Guide](docs/lt.config.md) - Configuration file documentation
 - [Plugin Guide](docs/plugins.md) - How to create plugins
 
+## Quick Start
+
+```bash
+# Check your environment
+$ lt doctor
+
+# Show project status
+$ lt status
+
+# Enable shell completions
+$ lt completion install
+```
+
 ## Configuration
 
 The CLI supports project-specific configuration via `lt.config` files. This allows you to set default values for commands, reducing repetitive input.
@@ -91,6 +104,23 @@ $ lt git get <branch-name or part-of-branch-name>
 or
 $ lt git g <branch-name or part-of-branch-name>
 
+// Preview what a command would do (dry-run)
+$ lt git clear --dry-run
+$ lt git reset --dry-run
+$ lt git squash --dry-run
+$ lt git rebase --dry-run
+
+// Skip confirmation prompts (noConfirm)
+$ lt git get feature --noConfirm
+$ lt git squash dev --noConfirm
+
+// Combine flags for CI/CD pipelines
+$ lt git clean --noConfirm
+$ lt server module User --noConfirm
+
+// View command history
+$ lt history
+
 ...
 
 ```

README.md

@@ -0,0 +1,26 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${filesystem.path(src, 'bin', 'lt')} ${cmd}`);
+
+describe('Config Commands', () => {
+  describe('lt config show', () => {
+    test('shows configuration or prompt to create', async () => {
+      const output = await cli('config show');
+      // Either shows config or prompts to create one
+      expect(
+        output.includes('Configuration') || output.includes('No configuration found')
+      ).toBe(true);
+    });
+  });
+
+  describe('lt config help', () => {
+    test('shows config help', async () => {
+      const output = await cli('config help');
+      // Should contain configuration-related info
+      expect(output.length).toBeGreaterThan(50);
+    });
+  });
+});

__tests__/cli-commands.test.ts

@@ -0,0 +1,37 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${filesystem.path(src, 'bin', 'lt')} ${cmd}`);
+
+// Database commands require running services (MongoDB, Qdrant, Redis)
+// These tests only verify the commands exist and can be invoked
+// They will fail gracefully when services are not available
+
+describe('Database Commands - Service Check', () => {
+  describe('lt qdrant stats', () => {
+    test('attempts to connect to Qdrant', async () => {
+      try {
+        const output = await cli('qdrant stats');
+        // If Qdrant is running, we get stats
+        expect(output).toBeDefined();
+      } catch (e: any) {
+        // If Qdrant is not running, we get an error message
+        expect(e.message || e.stderr).toContain('Qdrant');
+      }
+    });
+  });
+
+  describe('lt qdrant delete', () => {
+    test('attempts to connect to Qdrant', async () => {
+      try {
+        const output = await cli('qdrant delete');
+        expect(output).toBeDefined();
+      } catch (e: any) {
+        // Expected when Qdrant is not running
+        expect(e.message || e.stderr).toContain('Qdrant');
+      }
+    });
+  });
+});

__tests__/database-commands.test.ts

@@ -0,0 +1,89 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${filesystem.path(src, 'bin', 'lt')} ${cmd}`);
+
+describe('Git Commands', () => {
+  describe('lt git update', () => {
+    test('updates current branch', async () => {
+      const output = await cli('git update');
+      // Should run git fetch/pull
+      expect(output).toBeDefined();
+    });
+  });
+
+  describe('lt git update --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git update --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+      expect(output).toContain('Current branch:');
+    });
+  });
+
+  describe('lt git create --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git create test-branch-dry-run --base main --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+      expect(output).toContain('Would create branch');
+    });
+  });
+
+  describe('lt git force-pull --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git force-pull --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+
+  describe('lt git reset --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git reset --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+
+  describe('lt git undo --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git undo --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+
+  describe('lt git rename --dry-run', () => {
+    test('shows dry-run message or protected branch error', async () => {
+      const output = await cli('git rename newname --dry-run');
+      // On protected branches (main/dev/release), renaming is not allowed
+      // On other branches, it shows DRY-RUN MODE
+      expect(
+        output.includes('DRY-RUN MODE') || output.includes('not allowed')
+      ).toBe(true);
+    });
+  });
+
+  describe('lt git squash --dry-run', () => {
+    test('shows dry-run message or protected branch error', async () => {
+      const output = await cli('git squash --dry-run');
+      // On protected branches (main/dev/release), squashing is not allowed
+      // On other branches, it shows DRY-RUN MODE
+      expect(
+        output.includes('DRY-RUN MODE') || output.includes('not allowed')
+      ).toBe(true);
+    });
+  });
+
+  describe('lt git clear --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git clear --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+
+  describe('lt git clean --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git clean --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+});

__tests__/git-commands.test.ts

@@ -0,0 +1,35 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${filesystem.path(src, 'bin', 'lt')} ${cmd}`);
+
+describe('Tools Commands', () => {
+  describe('lt tools crypt', () => {
+    test('generates password hash', async () => {
+      const output = await cli('tools crypt testpassword');
+      // Should contain a bcrypt hash starting with $2
+      expect(output).toContain('$2');
+    });
+  });
+
+  describe('lt tools sha256', () => {
+    test('generates sha256 hash', async () => {
+      const output = await cli('tools sha256 test');
+      // SHA256 hash is 64 hex characters
+      expect(output.trim().length).toBeGreaterThanOrEqual(64);
+    });
+  });
+
+  describe('lt tools jwt-read', () => {
+    test('parses JWT payload', async () => {
+      // Sample JWT with payload: { "sub": "1234567890", "name": "Test User", "iat": 1516239022 }
+      const sampleJwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IlRlc3QgVXNlciIsImlhdCI6MTUxNjIzOTAyMn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+      const output = await cli(`tools jwt-read ${sampleJwt}`);
+      // Should contain parsed JWT data
+      expect(output).toContain('Test User');
+      expect(output).toContain('1234567890');
+    });
+  });
+});

__tests__/other-commands.test.ts

@@ -0,0 +1,22 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${filesystem.path(src, 'bin', 'lt')} ${cmd}`);
+
+describe('Server Commands', () => {
+  describe('lt server createSecret', () => {
+    test('generates a secret', async () => {
+      const output = await cli('server createSecret');
+      // Should output a base64 string (at least 20 chars)
+      expect(output.trim().length).toBeGreaterThan(20);
+    });
+
+    test('generates secret with custom length', async () => {
+      const output = await cli('server createSecret --length 64');
+      // Should output a longer base64 string
+      expect(output.trim().length).toBeGreaterThan(80);
+    });
+  });
+});

__tests__/server-commands.test.ts

@@ -0,0 +1,102 @@
+const { filesystem, system } = require('gluegun');
+
+const src = filesystem.path(__dirname, '..');
+
+const cli = async (cmd: string) =>
+  system.run(`node ${  filesystem.path(src, 'bin', 'lt')  } ${cmd}`);
+
+describe('Utility Commands', () => {
+  describe('lt status', () => {
+    test('outputs project status', async () => {
+      const output = await cli('status');
+      expect(output).toContain('Project Status');
+      expect(output).toContain('Directory:');
+    });
+  });
+
+  describe('lt doctor', () => {
+    test('runs doctor checks', async () => {
+      const output = await cli('doctor');
+      expect(output).toContain('lt doctor');
+      // Check for doctor output (may contain ANSI codes)
+      expect(output).toContain('Checks:');
+    });
+  });
+
+  describe('lt completion', () => {
+    test('outputs help without arguments', async () => {
+      const output = await cli('completion');
+      expect(output).toContain('Usage: lt completion');
+      expect(output).toContain('bash');
+      expect(output).toContain('zsh');
+      expect(output).toContain('fish');
+    });
+
+    test('generates bash completion', async () => {
+      const output = await cli('completion bash');
+      expect(output).toContain('_lt_completions');
+      expect(output).toContain('complete -F _lt_completions lt');
+    });
+
+    test('generates zsh completion', async () => {
+      const output = await cli('completion zsh');
+      expect(output).toContain('#compdef lt');
+      expect(output).toContain('_lt()');
+    });
+
+    test('generates fish completion', async () => {
+      const output = await cli('completion fish');
+      expect(output).toContain('# lt completion for Fish shell');
+      expect(output).toContain('complete -f -c lt');
+    });
+  });
+
+  describe('lt history', () => {
+    test('outputs history or empty message', async () => {
+      const output = await cli('history');
+      // Either shows history or "No command history yet"
+      expect(output.includes('Command History') || output.includes('No command history')).toBe(true);
+    });
+  });
+
+  describe('lt templates list', () => {
+    test('lists available templates', async () => {
+      const output = await cli('templates list');
+      expect(output).toContain('Available Templates');
+      expect(output).toContain('Built-in Templates');
+    });
+  });
+
+  describe('lt config validate', () => {
+    test('reports when no config file found', async () => {
+      // Run in a temp directory without config
+      const tempDir = filesystem.path(filesystem.homedir(), `.lt-test-${  Date.now()}`);
+      filesystem.dir(tempDir);
+
+      try {
+        const output = await system.run(
+          `cd ${tempDir} && node ${filesystem.path(src, 'bin', 'lt')} config validate`
+        );
+        expect(output).toContain('No lt.config file found');
+      } finally {
+        filesystem.remove(tempDir);
+      }
+    });
+  });
+});
+
+describe('Dry-run flags', () => {
+  describe('lt git clear --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git clear --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+
+  describe('lt git clean --dry-run', () => {
+    test('shows dry-run message', async () => {
+      const output = await cli('git clean --dry-run');
+      expect(output).toContain('DRY-RUN MODE');
+    });
+  });
+});