@nicolasmondain/cli-agent 2.1.0

package/README.md

@@ -0,0 +1,484 @@
+# cli-agent
+
+> Bridge the gap between natural language and CLI commands
+
+A CLI wrapper that enables AI agents to discover and execute commands through a semantic catalog. Define your commands once in JSON, and let both humans and AI agents use them seamlessly.
+
+## Why cli-agent?
+
+### The Problem
+
+AI agents can execute scripts, but they face challenges:
+
+- **Discovery**: They must read source code to understand what scripts exist
+- **Invocation**: They must guess arguments and options
+- **Parsing**: Each script outputs data differently
+
+### The Solution
+
+cli-agent provides a **semantic catalog** of commands:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  "Create a feature folder called user-profile"              │  Natural Language
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│  .cli-agent.json                                            │
+│  {                                                          │
+│    "commands": [{                                           │
+│      "name": "feature-folder",                              │
+│      "description": "Generate a new feature folder...",    │  Semantic Catalog
+│      "arguments": [{ "name": "name", ... }]                │
+│    }]                                                       │
+│  }                                                          │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│  cli-agent feature-folder user-profile --format json        │  CLI Command
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│  {"success": true, "data": {"path": "./src/features/..."}}  │  Structured Output
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Features
+
+- **Natural Language Mapping** — Command descriptions enable AI agents to match user intent to the right command
+- **Command Discovery** — `cli-agent list --format json` exposes all commands with their arguments and options
+- **MCP Integration** — Generate MCP tool manifests for native Claude Code integration
+- **Multi-runtime Support** — Execute JavaScript, TypeScript, and shell scripts
+- **AI-First Design** — JSON output, non-interactive execution, predictable exit codes
+
+## Installation
+
+```bash
+npm install @nicolasmondain/cli-agent
+```
+
+Or globally:
+
+```bash
+npm install -g @nicolasmondain/cli-agent
+```
+
+## Quick Start
+
+### 1. Create a configuration file
+
+Create `.cli-agent.json` in your project root:
+
+```json
+{
+  "name": "my-cli",
+  "description": "My project automation tools",
+  "commands": [
+    {
+      "name": "feature-folder",
+      "description": "Generate a new feature folder with component, hook, test, and type files",
+      "script": "./scripts/generate-feature.js",
+      "arguments": [
+        {
+          "name": "name",
+          "description": "Feature name (e.g., 'user-profile', 'checkout')",
+          "required": true
+        }
+      ],
+      "options": [
+        {
+          "flags": "-p, --path <path>",
+          "description": "Base path where to create the feature",
+          "default": "./src/features"
+        }
+      ]
+    }
+  ]
+}
+```
+
+### 2. Create your script
+
+Create `scripts/generate-feature.js`:
+
+```javascript
+export default async function(context) {
+  const name = context.args.name;
+  const path = context.options.path;
+  
+  // Your logic here...
+  
+  return {
+    success: true,
+    message: `Created feature: ${name}`,
+    data: {
+      name,
+      path: `${path}/${name}`,
+      files: ['index.ts', 'component.tsx', 'hook.ts', 'types.ts']
+    }
+  };
+}
+```
+
+### 3. Run your command
+
+```bash
+# Human-friendly output
+cli-agent feature-folder user-profile
+
+# JSON output for AI agents
+cli-agent feature-folder user-profile --format json
+```
+
+## Command Discovery
+
+### For Humans
+
+```bash
+# Show all commands
+cli-agent list
+
+# Show help for a specific command
+cli-agent feature-folder --help
+```
+
+### For AI Agents
+
+```bash
+# Get machine-readable command catalog
+cli-agent list --format json
+```
+
+Output:
+```json
+{
+  "success": true,
+  "data": {
+    "name": "my-cli",
+    "commands": [
+      {
+        "name": "feature-folder",
+        "description": "Generate a new feature folder with component, hook, test, and type files",
+        "arguments": [{ "name": "name", "description": "Feature name", "required": true }],
+        "options": [{ "flags": "-p, --path <path>", "description": "Base path", "default": "./src/features" }]
+      }
+    ]
+  }
+}
+```
+
+### For MCP Clients
+
+Generate an MCP tool manifest for Claude Code and other MCP-compatible clients:
+
+```bash
+# Output to stdout
+cli-agent mcp:manifest
+
+# Write to file
+cli-agent mcp:manifest --output .mcp-tools.json
+```
+
+Output:
+```json
+{
+  "tools": [
+    {
+      "name": "feature-folder",
+      "description": "Generate a new feature folder with component, hook, test, and type files",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string", "description": "Feature name" },
+          "path": { "type": "string", "description": "Base path", "default": "./src/features" }
+        },
+        "required": ["name"]
+      }
+    }
+  ]
+}
+```
+
+## Configuration Reference
+
+### Configuration File Locations
+
+cli-agent looks for configuration in this order:
+
+1. `--config <path>` flag (explicit path)
+2. `.cli-agent.json` in current directory
+3. `cli-agent` field in `package.json`
+4. `~/.cli-agent.json` (global commands)
+
+### Full Schema
+
+```json
+{
+  "name": "my-cli",
+  "version": "1.0.0",
+  "description": "CLI description shown in help",
+  "commands": [
+    {
+      "name": "command-name",
+      "description": "Clear description for AI agent understanding",
+      "script": "./path/to/script.js",
+      "arguments": [
+        {
+          "name": "arg-name",
+          "description": "What this argument represents",
+          "required": true,
+          "variadic": false
+        }
+      ],
+      "options": [
+        {
+          "flags": "-s, --short <value>",
+          "description": "What this option does",
+          "default": "default-value",
+          "required": false,
+          "choices": ["option1", "option2"]
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Writing Effective Descriptions
+
+Good descriptions are crucial for AI agents to match user intent:
+
+```json
+{
+  "name": "feature-folder",
+  "description": "Generate a new feature folder with component, hook, test, and type files"
+}
+```
+
+```json
+{
+  "name": "db:migrate",
+  "description": "Run database migrations to update schema to latest version"
+}
+```
+
+```json
+{
+  "name": "deploy",
+  "description": "Deploy the application to the specified environment (staging or production)"
+}
+```
+
+## Writing Scripts
+
+### JavaScript Scripts (.js)
+
+Scripts must export a default async function:
+
+```javascript
+/**
+ * @param {import('@nicolasmondain/cli-agent').ScriptContext} context
+ * @returns {Promise<import('@nicolasmondain/cli-agent').CommandResult>}
+ */
+export default async function(context) {
+  // context.args - positional arguments { name: 'value' }
+  // context.options - command options { path: './src', verbose: true }
+  // context.cwd - current working directory
+  // context.format - 'human' or 'json'
+  
+  return {
+    success: true,
+    message: 'Human-readable message',
+    data: { /* structured data */ }
+  };
+}
+```
+
+### TypeScript Scripts (.ts)
+
+TypeScript scripts are executed via `tsx` or `ts-node`:
+
+```typescript
+import type { ScriptContext, CommandResult } from '@nicolasmondain/cli-agent';
+
+export default async function(context: ScriptContext): Promise<CommandResult> {
+  const name = context.args.name as string;
+  
+  return {
+    success: true,
+    message: `Hello, ${name}!`,
+    data: { greeting: `Hello, ${name}!` }
+  };
+}
+```
+
+> **Note:** Install `tsx` for TypeScript support: `npm install -g tsx`
+
+### Shell Scripts (.sh)
+
+Shell scripts receive context via environment variables:
+
+```bash
+#!/bin/bash
+
+# Arguments: CLI_AGENT_ARG_<NAME>
+# Options: CLI_AGENT_OPT_<NAME>
+# Format: CLI_AGENT_FORMAT
+# CWD: CLI_AGENT_CWD
+
+NAME="${CLI_AGENT_ARG_NAME}"
+PATH_OPT="${CLI_AGENT_OPT_PATH:-./src/features}"
+
+# Output JSON for structured response
+if [ "$CLI_AGENT_FORMAT" = "json" ]; then
+  echo "{\"success\": true, \"data\": {\"name\": \"$NAME\", \"path\": \"$PATH_OPT\"}}"
+else
+  echo "Created feature: $NAME at $PATH_OPT"
+fi
+```
+
+## Standard Options
+
+All commands automatically have these options:
+
+| Option | Description |
+|--------|-------------|
+| `--format <format>` | Output format: `human` or `json` (default: `human`) |
+| `--quiet` | Suppress all output except errors |
+| `--verbose` | Show detailed output |
+| `--debug` | Show debug information |
+
+## Built-in Commands
+
+| Command | Description |
+|---------|-------------|
+| `list` | List all available commands |
+| `mcp:manifest` | Generate MCP tool manifest |
+
+## Using Utilities in Scripts
+
+cli-agent exports utility functions for use in your scripts:
+
+```javascript
+import {
+  // Naming utilities
+  toKebabCase,
+  toPascalCase,
+  toCamelCase,
+  toScreamingSnakeCase,
+  
+  // File system utilities
+  pathExists,
+  createDirectory,
+  createFile,
+  
+  // Logging
+  logInfo,
+  logError,
+  logSuccess,
+  logWarning,
+} from '@nicolasmondain/cli-agent';
+
+export default async function(context) {
+  const name = toKebabCase(context.args.name);
+  
+  if (await pathExists(`./${name}`)) {
+    return { success: false, error: 'Directory already exists' };
+  }
+  
+  await createDirectory(`./${name}`);
+  logSuccess(`Created ${name}/`);
+  
+  return { success: true, message: `Created ${name}/` };
+}
+```
+
+## Example: Complete Feature Generator
+
+`.cli-agent.json`:
+```json
+{
+  "name": "project-cli",
+  "commands": [
+    {
+      "name": "feature",
+      "description": "Generate a new feature folder with React component, custom hook, tests, and TypeScript types",
+      "script": "./scripts/generate-feature.js",
+      "arguments": [
+        { "name": "name", "description": "Feature name in kebab-case (e.g., 'user-profile')", "required": true }
+      ],
+      "options": [
+        { "flags": "-p, --path <path>", "description": "Base path for features", "default": "./src/features" },
+        { "flags": "--no-test", "description": "Skip test file generation" },
+        { "flags": "--no-hook", "description": "Skip hook file generation" }
+      ]
+    }
+  ]
+}
+```
+
+`scripts/generate-feature.js`:
+```javascript
+import { toKebabCase, toPascalCase, createDirectory, createFile, pathExists } from '@nicolasmondain/cli-agent';
+import { resolve } from 'node:path';
+
+export default async function(context) {
+  const name = toKebabCase(context.args.name);
+  const pascalName = toPascalCase(name);
+  const basePath = context.options.path;
+  const featurePath = resolve(context.cwd, basePath, name);
+  
+  if (await pathExists(featurePath)) {
+    return { success: false, error: `Feature "${name}" already exists at ${featurePath}` };
+  }
+  
+  const files = [];
+  
+  await createDirectory(featurePath);
+  
+  // Component
+  await createFile(`${featurePath}/${pascalName}.tsx`, `export function ${pascalName}() {\n  return <div>${pascalName}</div>;\n}\n`);
+  files.push(`${pascalName}.tsx`);
+  
+  // Hook
+  if (context.options.hook !== false) {
+    await createFile(`${featurePath}/use${pascalName}.ts`, `export function use${pascalName}() {\n  return {};\n}\n`);
+    files.push(`use${pascalName}.ts`);
+  }
+  
+  // Test
+  if (context.options.test !== false) {
+    await createFile(`${featurePath}/${pascalName}.test.tsx`, `import { ${pascalName} } from './${pascalName}';\n\ndescribe('${pascalName}', () => {\n  it('renders', () => {});\n});\n`);
+    files.push(`${pascalName}.test.tsx`);
+  }
+  
+  // Index
+  await createFile(`${featurePath}/index.ts`, `export * from './${pascalName}';\n`);
+  files.push('index.ts');
+  
+  return {
+    success: true,
+    message: `Created feature "${name}" with ${files.length} files`,
+    data: { name, path: featurePath, files }
+  };
+}
+```
+
+## Project Structure
+
+```
+your-project/
+├── .cli-agent.json          # CLI configuration
+├── scripts/
+│   ├── generate-feature.js  # JavaScript script
+│   ├── run-migrations.ts    # TypeScript script
+│   └── deploy.sh            # Shell script
+└── package.json
+```
+
+## License
+
+MIT

package/dist/cli/commands/list.command.d.ts

@@ -0,0 +1,48 @@
+/**
+ * List Command
+ *
+ * Built-in command that lists all available commands from configuration.
+ * Enables AI agents to discover commands dynamically.
+ */
+import { Command } from 'commander';
+import type { CliConfig } from '../../config/config-schema.js';
+import type { CommandResult } from '../../types/index.js';
+/**
+ * Data structure for list command output
+ */
+export interface ListCommandData {
+    name: string;
+    description?: string;
+    version?: string;
+    commands: Array<{
+        name: string;
+        description?: string;
+        script: string;
+        arguments?: Array<{
+            name: string;
+            description?: string;
+            required?: boolean;
+            variadic?: boolean;
+        }>;
+        options?: Array<{
+            flags: string;
+            description?: string;
+            default?: unknown;
+            required?: boolean;
+            choices?: string[];
+        }>;
+    }>;
+}
+/**
+ * Create the list command result
+ */
+export declare function createListResult(config: CliConfig | null): CommandResult<ListCommandData | null>;
+/**
+ * Format list output for human display
+ */
+export declare function formatListHuman(config: CliConfig): string;
+/**
+ * Create the list command
+ */
+export declare function createListCommand(config: CliConfig | null): Command;
+//# sourceMappingURL=list.command.d.ts.map

package/dist/cli/commands/list.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.command.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/list.command.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGxE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,KAAK,CAAC;YAChB,IAAI,EAAE,MAAM,CAAC;YACb,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;YACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;SACpB,CAAC,CAAC;QACH,OAAO,CAAC,EAAE,KAAK,CAAC;YACd,KAAK,EAAE,MAAM,CAAC;YACd,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;YACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;SACpB,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,aAAa,CAAC,eAAe,GAAG,IAAI,CAAC,CA0BhG;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAwBzD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAyBnE"}

package/dist/cli/commands/list.command.js

@@ -0,0 +1,87 @@
+/**
+ * List Command
+ *
+ * Built-in command that lists all available commands from configuration.
+ * Enables AI agents to discover commands dynamically.
+ */
+import { Command } from 'commander';
+import { outputResult } from '../../infra/output.js';
+/**
+ * Create the list command result
+ */
+export function createListResult(config) {
+    if (!config) {
+        return {
+            success: false,
+            error: 'No configuration found. Create a .cli-agent.json file to define commands.',
+        };
+    }
+    const data = {
+        name: config.name ?? 'cli-agent',
+        description: config.description,
+        version: config.version,
+        commands: config.commands.map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description,
+            script: cmd.script,
+            arguments: cmd.arguments,
+            options: cmd.options,
+        })),
+    };
+    return {
+        success: true,
+        message: `Found ${config.commands.length} command(s)`,
+        data,
+    };
+}
+/**
+ * Format list output for human display
+ */
+export function formatListHuman(config) {
+    const lines = [];
+    lines.push(`Commands available in ${config.name ?? 'cli-agent'}:`);
+    lines.push('');
+    if (config.commands.length === 0) {
+        lines.push('  No commands defined.');
+    }
+    else {
+        // Find longest command name for alignment
+        const maxNameLength = Math.max(...config.commands.map((c) => c.name.length));
+        for (const cmd of config.commands) {
+            const padding = ' '.repeat(maxNameLength - cmd.name.length + 2);
+            const description = cmd.description ?? 'No description';
+            lines.push(`  ${cmd.name}${padding}${description}`);
+        }
+    }
+    lines.push('');
+    lines.push('Use "cli-agent <command> --help" for more information about a command.');
+    lines.push('Use "cli-agent list --format json" for machine-readable output.');
+    return lines.join('\n');
+}
+/**
+ * Create the list command
+ */
+export function createListCommand(config) {
+    const command = new Command('list');
+    command
+        .description('List all available commands')
+        .option('--format <format>', 'Output format: human or json', 'human')
+        .action((options) => {
+        const format = options.format === 'json' ? 'json' : 'human';
+        if (!config) {
+            const result = createListResult(null);
+            outputResult(result, format);
+            process.exit(1);
+            return;
+        }
+        if (format === 'json') {
+            const result = createListResult(config);
+            outputResult(result, format);
+        }
+        else {
+            console.log(formatListHuman(config));
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=list.command.js.map

package/dist/cli/commands/list.command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.command.js","sourceRoot":"","sources":["../../../src/cli/commands/list.command.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/mcp-manifest.command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP Manifest Command
+ *
+ * Built-in command that generates an MCP (Model Context Protocol) tool manifest
+ * from the cli-agent configuration. This enables native integration with
+ * Claude Code and other MCP-compatible clients.
+ */
+import { Command } from 'commander';
+import type { CliConfig } from '../../config/config-schema.js';
+/**
+ * Create the mcp:manifest command
+ */
+export declare function createMcpManifestCommand(config: CliConfig | null): Command;
+//# sourceMappingURL=mcp-manifest.command.d.ts.map

package/dist/cli/commands/mcp-manifest.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-manifest.command.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/mcp-manifest.command.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAK/D;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAyF1E"}