cli4ai 1.2.0 → 1.2.1

package/src/commands/info.ts

@@ -1,133 +0,0 @@
-/**
- * cli4ai info - Show package information
- */
-
-import { resolve } from 'path';
-import { spawnSync } from 'child_process';
-import { output, outputError, log } from '../lib/cli.js';
-import { findPackage, loadConfig } from '../core/config.js';
-import { loadManifest, tryLoadManifest, type Manifest } from '../core/manifest.js';
-import { existsSync } from 'fs';
-import { remotePackageInfo, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
-
-interface InfoOptions {
-  versions?: boolean;
-  remote?: string;
-}
-
-export async function infoCommand(packageName: string, options: InfoOptions): Promise<void> {
-  // Handle remote info
-  if (options.remote) {
-    try {
-      const info = await remotePackageInfo(options.remote, packageName);
-      if (!info) {
-        outputError('NOT_FOUND', `Package not found on remote: ${packageName}`, {
-          remote: options.remote
-        });
-        return;
-      }
-      output({
-        remote: options.remote,
-        name: info.name,
-        version: info.version,
-        description: info.description,
-        commands: info.commands ? Object.keys(info.commands) : [],
-        commandDetails: info.commands
-      });
-    } 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;
-  }
-  // First check if it's installed
-  const installed = findPackage(packageName, process.cwd());
-
-  if (installed) {
-    const manifest = loadManifest(installed.path);
-    outputPackageInfo(manifest, installed.path, true);
-    return;
-  }
-
-  // Search in local registries
-  const config = loadConfig();
-  for (const registryPath of config.localRegistries) {
-    const pkgPath = resolve(registryPath, packageName);
-    const manifest = tryLoadManifest(pkgPath);
-    if (manifest) {
-      outputPackageInfo(manifest, pkgPath, false);
-      return;
-    }
-  }
-
-  // Try npm with @cli4ai scope
-  const scopedName = packageName.startsWith('@cli4ai/') ? packageName : `@cli4ai/${packageName}`;
-  try {
-    log(`Fetching ${scopedName} from npm...`);
-    // Use spawnSync with argument array to prevent command injection
-    const result = spawnSync('npm', ['view', scopedName, '--json'], {
-      encoding: 'utf-8',
-      timeout: 10000,
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-
-    if (result.status === 0 && result.stdout) {
-      const pkg = JSON.parse(result.stdout);
-      outputNpmPackageInfo(pkg, packageName);
-      return;
-    }
-  } catch {
-    // npm fetch failed
-  }
-
-  outputError('NOT_FOUND', `Package not found: ${packageName}`, {
-    hint: `Tried @cli4ai/${packageName} on npm. Check the package name or add a local registry with "cli4ai config --add-registry <path>"`
-  });
-}
-
-function outputPackageInfo(manifest: Manifest, path: string, installed: boolean): void {
-  output({
-    name: manifest.name,
-    version: manifest.version,
-    description: manifest.description,
-    author: manifest.author,
-    license: manifest.license,
-    runtime: manifest.runtime || 'node',
-    entry: manifest.entry,
-    path,
-    installed,
-    commands: manifest.commands ? Object.keys(manifest.commands) : [],
-    commandDetails: manifest.commands,
-    env: manifest.env,
-    peerDependencies: manifest.peerDependencies,
-    mcp: manifest.mcp,
-    repository: manifest.repository,
-    homepage: manifest.homepage,
-    keywords: manifest.keywords
-  });
-}
-
-function outputNpmPackageInfo(pkg: Record<string, unknown>, requestedName: string): void {
-  const shortName = typeof pkg.name === 'string' ? pkg.name.replace('@cli4ai/', '') : requestedName;
-  output({
-    name: shortName,
-    npmName: pkg.name,
-    version: pkg.version,
-    description: pkg.description,
-    author: typeof pkg.author === 'object' ? (pkg.author as Record<string, string>)?.name : pkg.author,
-    license: pkg.license,
-    source: 'npm',
-    installed: false,
-    install: `cli4ai add ${shortName} -g`,
-    repository: pkg.repository,
-    homepage: pkg.homepage,
-    keywords: pkg.keywords,
-    dependencies: pkg.dependencies,
-    versions: pkg.versions
-  });
-}

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}`,
-    }
-  ];
-}