cli4ai 1.2.0 → 1.2.2

package/dist/commands/init.js

@@ -0,0 +1,458 @@
+/**
+ * cli4ai init - Create a new tool project
+ */
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve, basename } from 'path';
+import { output, outputError, log } from '../lib/cli.js';
+import { createManifest, MANIFEST_FILENAME } from '../core/manifest.js';
+export async function initCommand(name, options) {
+    const projectName = name || basename(process.cwd());
+    const targetDir = name ? resolve(process.cwd(), name) : process.cwd();
+    const manifestPath = resolve(targetDir, MANIFEST_FILENAME);
+    const templateName = options.template || 'basic';
+    const runtime = options.runtime || 'node';
+    // Check if cli4ai.json already exists
+    if (existsSync(manifestPath)) {
+        outputError('INVALID_INPUT', `${MANIFEST_FILENAME} already exists`, {
+            path: manifestPath,
+            hint: 'Remove it first or use a different directory'
+        });
+    }
+    // Create directory if needed
+    if (name && !existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+        log(`Created directory: ${targetDir}`);
+    }
+    const manifest = createManifest(projectName, {
+        ...getBaseManifest(templateName, runtime),
+        ...getTemplateManifest(templateName, runtime),
+    });
+    // Write manifest
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    log(`Created ${MANIFEST_FILENAME}`);
+    // Create entry file if it doesn't exist
+    const entryPath = resolve(targetDir, manifest.entry);
+    if (!existsSync(entryPath)) {
+        const template = getTemplate(templateName, manifest);
+        writeFileSync(entryPath, template);
+        log(`Created ${manifest.entry}`);
+    }
+    // Create helpful extras (non-destructive)
+    const readmePath = resolve(targetDir, 'README.md');
+    if (!existsSync(readmePath)) {
+        writeFileSync(readmePath, getReadmeTemplate(templateName, manifest));
+        log('Created README.md');
+    }
+    const gitignorePath = resolve(targetDir, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, getGitignoreTemplate());
+        log('Created .gitignore');
+    }
+    const pkgJsonPath = resolve(targetDir, 'package.json');
+    if (!existsSync(pkgJsonPath)) {
+        const pkgJson = getDevPackageJson(templateName, manifest);
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
+        log('Created package.json');
+    }
+    // Create test file
+    const testPath = resolve(targetDir, manifest.entry.replace(/\.ts$/, '.test.ts'));
+    if (!existsSync(testPath)) {
+        writeFileSync(testPath, getTestTemplate(templateName, manifest));
+        log(`Created ${basename(testPath)}`);
+    }
+    // Create tsconfig.json for TypeScript support
+    const tsconfigPath = resolve(targetDir, 'tsconfig.json');
+    if (!existsSync(tsconfigPath)) {
+        writeFileSync(tsconfigPath, getTsconfigTemplate());
+        log('Created tsconfig.json');
+    }
+    // Create vitest.config.ts
+    const vitestConfigPath = resolve(targetDir, 'vitest.config.ts');
+    if (!existsSync(vitestConfigPath)) {
+        writeFileSync(vitestConfigPath, getVitestConfigTemplate());
+        log('Created vitest.config.ts');
+    }
+    // Template-specific extras
+    if (templateName === 'api') {
+        const envExamplePath = resolve(targetDir, '.env.example');
+        if (!existsSync(envExamplePath)) {
+            writeFileSync(envExamplePath, 'API_KEY=\n');
+            log('Created .env.example');
+        }
+    }
+    const nextSteps = getNextSteps(name, targetDir, templateName, manifest);
+    output({
+        created: {
+            manifest: manifestPath,
+            entry: entryPath,
+            test: testPath,
+            readme: readmePath,
+            gitignore: gitignorePath,
+            tsconfig: tsconfigPath,
+            vitestConfig: vitestConfigPath,
+            packageJson: existsSync(resolve(targetDir, 'package.json')) ? resolve(targetDir, 'package.json') : undefined,
+        },
+        name: manifest.name,
+        version: manifest.version,
+        runtime: manifest.runtime,
+        hint: nextSteps[0]?.command,
+        nextSteps
+    });
+}
+function guessAuthor() {
+    const candidates = [
+        process.env.GIT_AUTHOR_NAME,
+        process.env.GIT_COMMITTER_NAME,
+        process.env.USER,
+        process.env.USERNAME,
+    ].filter((v) => Boolean(v));
+    return candidates[0];
+}
+function getBaseManifest(templateName, runtime) {
+    const author = guessAuthor();
+    const keywords = Array.from(new Set([
+        'cli4ai',
+        'cli4ai',
+        templateName,
+    ]));
+    return {
+        entry: 'run.ts',
+        runtime,
+        description: `${templateName === 'basic' ? 'CLI' : templateName} tool`,
+        author,
+        license: 'BUSL-1.1',
+        keywords,
+        mcp: { enabled: true, transport: 'stdio' },
+    };
+}
+function getTemplateManifest(templateName, runtime) {
+    switch (templateName) {
+        case 'api':
+            return {
+                commands: {
+                    fetch: {
+                        description: 'Fetch JSON from an API endpoint',
+                        args: [{ name: 'endpoint', required: true }],
+                    }
+                },
+                env: {
+                    API_KEY: {
+                        required: true,
+                        description: 'API key for the service you are calling (stored via `cli4ai secrets`)',
+                    }
+                },
+                dependencies: getDefaultDependencies(templateName),
+            };
+        case 'browser':
+            return {
+                commands: {
+                    screenshot: {
+                        description: 'Take a screenshot of a webpage',
+                        args: [
+                            { name: 'url', required: true },
+                            { name: 'output', required: false },
+                        ],
+                        options: [
+                            { name: 'full-page', type: 'boolean', description: 'Capture full page' },
+                        ]
+                    }
+                },
+                dependencies: getDefaultDependencies(templateName),
+            };
+        default:
+            return {
+                commands: {
+                    hello: {
+                        description: 'Say hello',
+                        args: [{ name: 'name', required: false }]
+                    }
+                },
+                dependencies: getDefaultDependencies(templateName),
+            };
+    }
+}
+function getDefaultDependencies(templateName) {
+    const deps = {
+        '@cli4ai/lib': '^1.0.0',
+        'commander': '^14.0.0',
+    };
+    if (templateName === 'browser') {
+        deps['puppeteer'] = '^24.0.0';
+    }
+    return deps;
+}
+function getTemplate(templateName, manifest) {
+    switch (templateName) {
+        case 'api':
+            return getApiTemplate(manifest);
+        case 'browser':
+            return getBrowserTemplate(manifest);
+        default:
+            return getBasicTemplate(manifest);
+    }
+}
+function getBasicTemplate(manifest) {
+    return `#!/usr/bin/env npx tsx
+/**
+ * ${manifest.name} - ${manifest.description || 'A cli4ai tool'}
+ */
+
+import { cli, output } from '@cli4ai/lib';
+
+const program = cli('${manifest.name}', '${manifest.version}', '${manifest.description || manifest.name}');
+
+program
+  .command('hello [name]')
+  .description('Say hello')
+  .action((name?: string) => {
+    const who = name?.trim() || 'world';
+    output({ message: \`Hello, \${who}!\` });
+  });
+
+program.parse();
+`;
+}
+function getApiTemplate(manifest) {
+    return `#!/usr/bin/env npx tsx
+/**
+ * ${manifest.name} - ${manifest.description || 'API wrapper tool'}
+ */
+
+import { cli, env, output, outputError, withErrorHandling } from '@cli4ai/lib';
+
+const program = cli('${manifest.name}', '${manifest.version}', '${manifest.description || manifest.name}');
+
+program
+  .command('fetch <endpoint>')
+  .description('Fetch data from API')
+  .action(withErrorHandling(async (endpoint: string) => {
+    // Use \`cli4ai secrets set API_KEY\` to store this securely (cli4ai injects it at runtime).
+    const apiKey = env('API_KEY');
+
+    const res = await fetch(\`https://api.example.com/\${endpoint}\`, {
+      headers: { 'Authorization': \`Bearer \${apiKey}\` }
+    });
+
+    if (!res.ok) {
+      outputError('API_ERROR', \`HTTP \${res.status}: \${res.statusText}\`);
+    }
+
+    output(await res.json());
+  }));
+
+program.parse();
+`;
+}
+function getBrowserTemplate(manifest) {
+    return `#!/usr/bin/env npx tsx
+/**
+ * ${manifest.name} - ${manifest.description || 'Browser automation tool'}
+ */
+
+import puppeteer from 'puppeteer';
+import { cli, output, outputError, withErrorHandling } from '@cli4ai/lib';
+
+const program = cli('${manifest.name}', '${manifest.version}', '${manifest.description || manifest.name}');
+
+program
+  .command('screenshot <url>')
+  .description('Take a screenshot of a webpage')
+  .option('-o, --output <file>', 'Output file', 'screenshot.png')
+  .option('--full-page', 'Capture full page')
+  .action(withErrorHandling(async (url: string, options: { output: string; fullPage?: boolean }) => {
+    const browser = await puppeteer.launch({ headless: true });
+
+    try {
+      const page = await browser.newPage();
+      await page.goto(url, { waitUntil: 'networkidle2' });
+      await page.screenshot({ path: options.output, fullPage: options.fullPage });
+
+      output({
+        url,
+        screenshot: options.output,
+        timestamp: new Date().toISOString()
+      });
+    } finally {
+      await browser.close();
+    }
+  }));
+
+program.parse();
+`;
+}
+function getReadmeTemplate(templateName, manifest) {
+    const exampleCmd = templateName === 'api' ? 'fetch users' :
+        templateName === 'browser' ? 'screenshot https://example.com' :
+            'hello world';
+    return `# ${manifest.name}
+
+${manifest.description || ''}
+
+## Setup
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Run directly
+
+\`\`\`bash
+npx tsx run.ts ${exampleCmd}
+\`\`\`
+
+## Install with cli4ai (project-scoped)
+
+\`\`\`bash
+# From the project you want to use this tool in:
+cli4ai add --local /path/to/${manifest.name} -y
+cli4ai run ${manifest.name} ${exampleCmd}
+\`\`\`
+
+## Testing
+
+\`\`\`bash
+npm test
+\`\`\`
+
+## MCP
+
+\`\`\`bash
+cli4ai start ${manifest.name}
+\`\`\`
+`;
+}
+function getGitignoreTemplate() {
+    return `node_modules
+.cli4ai
+.env
+.env.*
+dist
+.DS_Store
+*.log
+coverage
+`;
+}
+function getTsconfigTemplate() {
+    return `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": false,
+    "noEmit": true
+  },
+  "include": ["*.ts", "lib/**/*.ts"],
+  "exclude": ["node_modules"]
+}
+`;
+}
+function getVitestConfigTemplate() {
+    return `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+  },
+});
+`;
+}
+function getTestTemplate(templateName, manifest) {
+    const testCmd = templateName === 'api' ? 'fetch' : templateName === 'browser' ? 'screenshot' : 'hello';
+    const envSetup = templateName === 'api' ? `
+// Set required env vars before importing
+process.env.API_KEY = 'test-api-key';
+` : '';
+    return `import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+${envSetup}
+describe('${manifest.name}', () => {
+  let consoleSpy: ReturnType<typeof vi.spyOn>;
+  let logs: string[];
+
+  beforeEach(() => {
+    logs = [];
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation((msg: string) => {
+      logs.push(msg);
+    });
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  describe('${testCmd} command', () => {
+    test('should output valid JSON', async () => {
+      // TODO: Import and test your command handler
+      // Example:
+      // import { ${testCmd}Command } from './run';
+      // await ${testCmd}Command('test-arg');
+      // expect(logs.length).toBeGreaterThan(0);
+      // const result = JSON.parse(logs[0]);
+      // expect(result).toBeDefined();
+
+      expect(true).toBe(true); // Placeholder - replace with real test
+    });
+
+    test('should handle invalid input', async () => {
+      // TODO: Test error handling
+      // Example:
+      // expect(() => ${testCmd}Command('')).toThrow();
+
+      expect(true).toBe(true); // Placeholder - replace with real test
+    });
+  });
+});
+`;
+}
+function getDevPackageJson(templateName, manifest) {
+    const deps = manifest.dependencies || {};
+    return {
+        name: manifest.name,
+        version: manifest.version,
+        private: true,
+        type: 'module',
+        bin: {
+            [manifest.name]: `./run.ts`,
+        },
+        dependencies: deps,
+        devDependencies: {
+            'typescript': '^5.0.0',
+            'tsx': '^4.0.0',
+            'vitest': '^2.0.0',
+            '@types/node': '^22.0.0',
+        },
+        scripts: {
+            dev: 'tsx run.ts',
+            test: 'vitest run',
+            'test:watch': 'vitest',
+        },
+    };
+}
+function getNextSteps(nameArg, targetDir, templateName, manifest) {
+    const exampleArgs = templateName === 'api' ? 'fetch users' :
+        templateName === 'browser' ? 'screenshot https://example.com' :
+            'hello world';
+    const installPath = nameArg ? `./${basename(targetDir)}` : '.';
+    return [
+        {
+            description: 'Install dependencies',
+            command: 'npm install',
+        },
+        {
+            description: 'Run the tool directly',
+            command: `npx tsx run.ts ${exampleArgs}`,
+        },
+        {
+            description: 'Run tests',
+            command: 'npm test',
+        },
+        {
+            description: 'Install into a project and run via cli4ai',
+            command: `cli4ai add --local ${installPath} -y && cli4ai run ${manifest.name} ${exampleArgs}`,
+        }
+    ];
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * cli4ai list - Show installed packages
+ */
+interface ListOptions {
+    global?: boolean;
+    json?: boolean;
+    remote?: string;
+}
+export declare function listCommand(options: ListOptions): Promise<void>;
+export {};

package/dist/commands/list.js

@@ -0,0 +1,76 @@
+/**
+ * cli4ai list - Show installed packages
+ */
+import { output, outputError } from '../lib/cli.js';
+import { getGlobalPackages, getLocalPackages, getNpmGlobalPackages } from '../core/config.js';
+import { remoteListPackages, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
+export async function listCommand(options) {
+    // Handle remote listing
+    if (options.remote) {
+        try {
+            const result = await remoteListPackages(options.remote);
+            output({
+                remote: options.remote,
+                packages: result.packages,
+                count: result.packages.length
+            });
+        }
+        catch (err) {
+            if (err instanceof RemoteConnectionError) {
+                outputError('NETWORK_ERROR', err.message, { remote: err.remoteName, url: err.url });
+            }
+            else if (err instanceof RemoteApiError) {
+                outputError(err.code, err.message, { remote: err.remoteName, details: err.details });
+            }
+            else {
+                throw err;
+            }
+        }
+        return;
+    }
+    let packages;
+    // Get all package sources
+    const local = getLocalPackages(process.cwd());
+    const cli4aiGlobal = getGlobalPackages();
+    const npmGlobal = getNpmGlobalPackages();
+    if (options.global) {
+        // Only global packages (cli4ai + npm)
+        const cli4aiNames = new Set(cli4aiGlobal.map(p => p.name));
+        packages = [
+            ...cli4aiGlobal.map(p => ({ ...p, scope: 'cli4ai' })),
+            ...npmGlobal.filter(p => !cli4aiNames.has(p.name)).map(p => ({ ...p, scope: 'npm' }))
+        ];
+    }
+    else {
+        // All packages: local > cli4ai global > npm global
+        const seenNames = new Set();
+        packages = [];
+        for (const pkg of local) {
+            packages.push({ ...pkg, scope: 'local' });
+            seenNames.add(pkg.name);
+        }
+        for (const pkg of cli4aiGlobal) {
+            if (!seenNames.has(pkg.name)) {
+                packages.push({ ...pkg, scope: 'cli4ai' });
+                seenNames.add(pkg.name);
+            }
+        }
+        for (const pkg of npmGlobal) {
+            if (!seenNames.has(pkg.name)) {
+                packages.push({ ...pkg, scope: 'npm' });
+                seenNames.add(pkg.name);
+            }
+        }
+    }
+    output({
+        packages: packages.map(p => ({
+            name: p.name,
+            version: p.version,
+            path: p.path,
+            source: p.source,
+            scope: p.scope
+        })),
+        count: packages.length,
+        location: options.global ? 'global' : 'all'
+    });
+}

package/dist/commands/mcp-config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * cli4ai mcp-config - Generate MCP configuration for Claude Code
+ */
+interface McpConfigOptions {
+    global?: boolean;
+    package?: string;
+    snippet?: boolean;
+}
+export declare function mcpConfigCommand(options: McpConfigOptions): Promise<void>;
+export {};

package/dist/commands/mcp-config.js

@@ -0,0 +1,49 @@
+/**
+ * cli4ai mcp-config - Generate MCP configuration for Claude Code
+ */
+import { output, outputError } from '../lib/cli.js';
+import { generateClaudeCodeConfig, formatClaudeCodeConfig, generateConfigSnippet, generateServerConfig } from '../mcp/config-gen.js';
+import { findPackage } from '../core/config.js';
+import { tryLoadManifest } from '../core/manifest.js';
+export async function mcpConfigCommand(options) {
+    const cwd = process.cwd();
+    // Single package snippet mode
+    if (options.snippet && options.package) {
+        const pkg = findPackage(options.package, cwd);
+        if (!pkg) {
+            outputError('NOT_FOUND', `Package not found: ${options.package}`);
+        }
+        const manifest = tryLoadManifest(pkg.path);
+        if (!manifest) {
+            outputError('MANIFEST_ERROR', `Could not load manifest for ${options.package}`);
+        }
+        if (!manifest.mcp?.enabled) {
+            outputError('INVALID_INPUT', `Package ${options.package} does not have MCP enabled`);
+        }
+        const serverName = `cli4ai-${manifest.name}`;
+        const serverConfig = generateServerConfig(manifest, pkg.path);
+        const snippet = generateConfigSnippet(manifest, pkg.path);
+        output({
+            serverName,
+            serverConfig,
+            snippet
+        });
+        return;
+    }
+    // Generate full config
+    const packages = options.package ? [options.package] : undefined;
+    const config = generateClaudeCodeConfig(cwd, {
+        global: options.global,
+        packages
+    });
+    if (Object.keys(config.mcpServers).length === 0) {
+        outputError('NOT_FOUND', 'No MCP-enabled packages found', {
+            hint: 'Install packages with "cli4ai add <package>" first'
+        });
+    }
+    // Output formatted config
+    output({
+        config,
+        formatted: formatClaudeCodeConfig(config)
+    });
+}

package/dist/commands/remotes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Remote hosts management command.
+ *
+ * Manage connections to remote cli4ai instances for distributed execution.
+ */
+export declare function remotesListCommand(): Promise<void>;
+export interface AddRemoteOptions {
+    apiKey?: string;
+    description?: string;
+    test?: boolean;
+}
+export declare function remotesAddCommand(name: string, url: string, options: AddRemoteOptions): Promise<void>;
+export interface UpdateRemoteOptions {
+    url?: string;
+    apiKey?: string;
+    description?: string;
+}
+export declare function remotesUpdateCommand(name: string, options: UpdateRemoteOptions): Promise<void>;
+export declare function remotesRemoveCommand(name: string): Promise<void>;
+export declare function remotesShowCommand(name: string): Promise<void>;
+export declare function remotesTestCommand(name: string): Promise<void>;
+export declare function remotesPackagesCommand(name: string): Promise<void>;