cli4ai 1.1.5 → 1.2.1

package/src/commands/init.ts

@@ -1,514 +0,0 @@
-/**
- * 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, type Manifest } from '../core/manifest.js';
-
-interface InitOptions {
-  template?: string;
-  runtime?: 'node' | 'bun';
-  yes?: boolean;
-}
-
-export async function initCommand(name: string | undefined, options: InitOptions): Promise<void> {
-  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(): string | undefined {
-  const candidates = [
-    process.env.GIT_AUTHOR_NAME,
-    process.env.GIT_COMMITTER_NAME,
-    process.env.USER,
-    process.env.USERNAME,
-  ].filter((v): v is string => Boolean(v));
-
-  return candidates[0];
-}
-
-function getBaseManifest(templateName: string, runtime: 'node' | 'bun'): Partial<Manifest> {
-  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: string, runtime: 'node' | 'bun'): Partial<Manifest> {
-  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: string): Record<string, string> | undefined {
-  const deps: Record<string, string> = {
-    '@cli4ai/lib': '^1.0.0',
-    'commander': '^14.0.0',
-  };
-
-  if (templateName === 'browser') {
-    deps['puppeteer'] = '^24.0.0';
-  }
-
-  return deps;
-}
-
-function getTemplate(templateName: string, manifest: Manifest): string {
-  switch (templateName) {
-    case 'api':
-      return getApiTemplate(manifest);
-    case 'browser':
-      return getBrowserTemplate(manifest);
-    default:
-      return getBasicTemplate(manifest);
-  }
-}
-
-function getBasicTemplate(manifest: Manifest): string {
-  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: Manifest): string {
-  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: Manifest): string {
-  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: string, manifest: Manifest): string {
-  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(): string {
-  return `node_modules
-.cli4ai
-.env
-.env.*
-dist
-.DS_Store
-*.log
-coverage
-`;
-}
-
-function getTsconfigTemplate(): string {
-  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(): string {
-  return `import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-  },
-});
-`;
-}
-
-function getTestTemplate(templateName: string, manifest: Manifest): string {
-  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: string,
-  manifest: Manifest
-): Record<string, unknown> {
-  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: string | undefined,
-  targetDir: string,
-  templateName: string,
-  manifest: Manifest
-): Array<{ description: string; command: string }> {
-  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/src/commands/list.ts

@@ -1,72 +0,0 @@
-/**
- * cli4ai list - Show installed packages
- */
-
-import { output } from '../lib/cli.js';
-import {
-  getGlobalPackages,
-  getLocalPackages,
-  getNpmGlobalPackages,
-  type InstalledPackage
-} from '../core/config.js';
-
-interface ListOptions {
-  global?: boolean;
-  json?: boolean;
-}
-
-type PackageWithScope = InstalledPackage & { scope: 'local' | 'cli4ai' | 'npm' };
-
-export async function listCommand(options: ListOptions): Promise<void> {
-  let packages: PackageWithScope[];
-
-  // 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' as const })),
-      ...npmGlobal.filter(p => !cli4aiNames.has(p.name)).map(p => ({ ...p, scope: 'npm' as const }))
-    ];
-  } else {
-    // All packages: local > cli4ai global > npm global
-    const seenNames = new Set<string>();
-
-    packages = [];
-
-    for (const pkg of local) {
-      packages.push({ ...pkg, scope: 'local' as const });
-      seenNames.add(pkg.name);
-    }
-
-    for (const pkg of cli4aiGlobal) {
-      if (!seenNames.has(pkg.name)) {
-        packages.push({ ...pkg, scope: 'cli4ai' as const });
-        seenNames.add(pkg.name);
-      }
-    }
-
-    for (const pkg of npmGlobal) {
-      if (!seenNames.has(pkg.name)) {
-        packages.push({ ...pkg, scope: 'npm' as const });
-        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/src/commands/mcp-config.ts

@@ -1,69 +0,0 @@
-/**
- * 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';
-
-interface McpConfigOptions {
-  global?: boolean;
-  package?: string;
-  snippet?: boolean;
-}
-
-export async function mcpConfigCommand(options: McpConfigOptions): Promise<void> {
-  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)
-  });
-}