cli4ai 0.8.0

package/src/commands/init.ts

@@ -0,0 +1,560 @@
+/**
+ * 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?: 'bun' | 'node';
+  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 || 'bun';
+
+  // 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, runtime, 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, runtime, 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, runtime, manifest);
+    writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
+    log('Created package.json');
+  }
+
+  // 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, runtime, manifest);
+
+  output({
+    created: {
+      manifest: manifestPath,
+      entry: entryPath,
+      readme: readmePath,
+      gitignore: gitignorePath,
+      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: 'bun' | 'node'): Partial<Manifest> {
+  const author = guessAuthor();
+  const keywords = Array.from(new Set([
+    'cli4ai',
+    'cli4ai',
+    templateName,
+  ]));
+
+  return {
+    entry: runtime === 'node' ? 'run.mjs' : 'run.ts',
+    runtime,
+    description: `${templateName === 'basic' ? 'CLI' : templateName} tool`,
+    author,
+    license: 'MIT',
+    keywords,
+    mcp: { enabled: true, transport: 'stdio' },
+  };
+}
+
+function getTemplateManifest(templateName: string, runtime: 'bun' | 'node'): 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, runtime),
+      };
+    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, runtime),
+      };
+    default:
+      return {
+        commands: {
+          hello: {
+            description: 'Say hello',
+            args: [{ name: 'name', required: false }]
+          }
+        },
+        dependencies: getDefaultDependencies(templateName, runtime),
+      };
+  }
+}
+
+function getDefaultDependencies(
+  templateName: string,
+  runtime: 'bun' | 'node'
+): Record<string, string> | undefined {
+  const deps: Record<string, string> = {};
+
+  // Prefer shared SDK helpers when running on bun (or node with TS support, if that lands later).
+  if (runtime === 'bun') {
+    deps['@cli4ai/lib'] = '^1.0.0';
+  }
+
+  deps['commander'] = '^14.0.0';
+
+  if (templateName === 'browser') {
+    deps['puppeteer'] = '^24.0.0';
+  }
+
+  return deps;
+}
+
+function getTemplate(templateName: string, runtime: 'bun' | 'node', manifest: Manifest): string {
+  if (runtime === 'node') {
+    return getNodeTemplate(templateName, manifest);
+  }
+
+  switch (templateName) {
+    case 'api':
+      return getBunApiTemplate(manifest);
+    case 'browser':
+      return getBunBrowserTemplate(manifest);
+    default:
+      return getBunBasicTemplate(manifest);
+  }
+}
+
+function getBunBasicTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env bun
+/**
+ * ${manifest.name} - ${manifest.description || 'A cli4ai tool'}
+ */
+
+import { cli, output } from '@cli4ai/lib/cli.ts';
+
+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 getBunApiTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env bun
+/**
+ * ${manifest.name} - ${manifest.description || 'API wrapper tool'}
+ */
+
+import { cli, env, output, outputError, withErrorHandling } from '@cli4ai/lib/cli.ts';
+
+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');
+
+    try {
+      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());
+    } catch (err) {
+      outputError('NETWORK_ERROR', err instanceof Error ? err.message : String(err));
+    }
+  }));
+
+program.parse();
+`;
+}
+
+function getBunBrowserTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env bun
+/**
+ * ${manifest.name} - ${manifest.description || 'Browser automation tool'}
+ */
+
+import puppeteer from 'puppeteer';
+import { cli, output, outputError, withErrorHandling } from '@cli4ai/lib/cli.ts';
+
+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()
+      });
+    } catch (err) {
+      outputError('API_ERROR', err instanceof Error ? err.message : String(err));
+    } finally {
+      await browser.close();
+    }
+  }));
+
+program.parse();
+`;
+}
+
+function getNodeTemplate(templateName: string, manifest: Manifest): string {
+  switch (templateName) {
+    case 'api':
+      return getNodeApiTemplate(manifest);
+    case 'browser':
+      return getNodeBrowserTemplate(manifest);
+    default:
+      return getNodeBasicTemplate(manifest);
+  }
+}
+
+function getNodeBasicTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env node
+/**
+ * ${manifest.name} - ${manifest.description || 'A cli4ai tool'}
+ */
+
+import { Command } from 'commander';
+
+const output = (data) => console.log(JSON.stringify(data, null, 2));
+const outputError = (code, message, details) => {
+  console.error(JSON.stringify({ error: code, message, ...(details || {}) }));
+  process.exit(1);
+};
+
+const withErrorHandling = (fn) => async (...args) => {
+  try {
+    await fn(...args);
+  } catch (err) {
+    outputError('API_ERROR', err instanceof Error ? err.message : String(err));
+  }
+};
+
+const program = new Command()
+  .name('${manifest.name}')
+  .version('${manifest.version}', '-v, --version', 'Show version')
+  .description('${manifest.description || manifest.name}');
+
+program
+  .command('hello [name]')
+  .description('Say hello')
+  .action(withErrorHandling(async (name) => {
+    const who = (name || '').trim() || 'world';
+    output({ message: \`Hello, \${who}!\` });
+  }));
+
+program.parse();
+`;
+}
+
+function getNodeApiTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env node
+/**
+ * ${manifest.name} - ${manifest.description || 'API wrapper tool'}
+ */
+
+import { Command } from 'commander';
+
+const output = (data) => console.log(JSON.stringify(data, null, 2));
+const outputError = (code, message, details) => {
+  console.error(JSON.stringify({ error: code, message, ...(details || {}) }));
+  process.exit(1);
+};
+
+const withErrorHandling = (fn) => async (...args) => {
+  try {
+    await fn(...args);
+  } catch (err) {
+    outputError('API_ERROR', err instanceof Error ? err.message : String(err));
+  }
+};
+
+const env = (name) => {
+  const value = process.env[name];
+  if (!value) outputError('ENV_MISSING', \`Missing required environment variable: \${name}\`);
+  return value;
+};
+
+const program = new Command()
+  .name('${manifest.name}')
+  .version('${manifest.version}', '-v, --version', 'Show version')
+  .description('${manifest.description || manifest.name}');
+
+program
+  .command('fetch <endpoint>')
+  .description('Fetch JSON from an API endpoint')
+  .action(withErrorHandling(async (endpoint) => {
+    // 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 getNodeBrowserTemplate(manifest: Manifest): string {
+  return `#!/usr/bin/env node
+/**
+ * ${manifest.name} - ${manifest.description || 'Browser automation tool'}
+ */
+
+import { Command } from 'commander';
+import puppeteer from 'puppeteer';
+
+const output = (data) => console.log(JSON.stringify(data, null, 2));
+const outputError = (code, message, details) => {
+  console.error(JSON.stringify({ error: code, message, ...(details || {}) }));
+  process.exit(1);
+};
+
+const withErrorHandling = (fn) => async (...args) => {
+  try {
+    await fn(...args);
+  } catch (err) {
+    outputError('API_ERROR', err instanceof Error ? err.message : String(err));
+  }
+};
+
+const program = new Command()
+  .name('${manifest.name}')
+  .version('${manifest.version}', '-v, --version', 'Show version')
+  .description('${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, options) => {
+    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, runtime: 'bun' | 'node', manifest: Manifest): string {
+  const runCmd =
+    runtime === 'node' ? `node ${manifest.entry}` :
+    `bun run ${manifest.entry}`;
+
+  const exampleCmd =
+    templateName === 'api' ? 'fetch users' :
+    templateName === 'browser' ? 'screenshot https://example.com' :
+    'hello world';
+
+  return `# ${manifest.name}
+
+${manifest.description || ''}
+
+## Run directly
+
+\`\`\`bash
+${runCmd} ${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}
+\`\`\`
+
+## MCP
+
+\`\`\`bash
+cli4ai start ${manifest.name}
+\`\`\`
+`;
+}
+
+function getGitignoreTemplate(): string {
+  return `node_modules
+.cli4ai
+.env
+.env.*
+dist
+.DS_Store
+`;
+}
+
+function getDevPackageJson(
+  templateName: string,
+  runtime: 'bun' | 'node',
+  manifest: Manifest
+): Record<string, unknown> {
+  const deps = manifest.dependencies || {};
+
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    private: true,
+    type: 'module',
+    bin: {
+      [manifest.name]: `./${manifest.entry}`,
+    },
+    dependencies: deps,
+    scripts: {
+      dev: runtime === 'node' ? `node ${manifest.entry}` : `bun run ${manifest.entry}`,
+    },
+  };
+}
+
+function getNextSteps(
+  nameArg: string | undefined,
+  targetDir: string,
+  templateName: string,
+  runtime: 'bun' | 'node',
+  manifest: Manifest
+): Array<{ description: string; command: string }> {
+  const exampleArgs =
+    templateName === 'api' ? 'fetch users' :
+    templateName === 'browser' ? 'screenshot https://example.com' :
+    'hello world';
+
+  const runDirect =
+    runtime === 'node' ? `node ${manifest.entry} ${exampleArgs}` :
+    `bun run ${manifest.entry} ${exampleArgs}`;
+
+  const installPath = nameArg ? `./${basename(targetDir)}` : '.';
+
+  return [
+    {
+      description: 'Run the tool directly in this folder',
+      command: runDirect,
+    },
+    {
+      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

@@ -0,0 +1,89 @@
+/**
+ * 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);
+      }
+    }
+  }
+
+  if (options.json || !process.stdout.isTTY) {
+    output({
+      packages: packages.map(p => ({
+        name: p.name,
+        version: p.version,
+        path: p.path,
+        source: p.source,
+        scope: p.scope
+      })),
+      count: packages.length
+    });
+  } else {
+    // Human-readable output
+    if (packages.length === 0) {
+      console.log('No packages installed');
+      console.log('\nRun "cli4ai browse" to find and install packages');
+      console.log('Or:  npm install -g @cli4ai/<package>');
+    } else {
+      console.log(`\nInstalled packages (${packages.length}):\n`);
+      for (const pkg of packages) {
+        const scopeTag = pkg.scope === 'local' ? '' :
+                         pkg.scope === 'npm' ? ' (npm)' : ' (cli4ai)';
+        console.log(`  ${pkg.name}@${pkg.version}${scopeTag}`);
+        console.log(`    ${pkg.path}`);
+      }
+      console.log('');
+    }
+  }
+}

package/src/commands/mcp-config.ts

@@ -0,0 +1,59 @@
+/**
+ * cli4ai mcp-config - Generate MCP configuration for Claude Code
+ */
+
+import { outputError } from '../lib/cli.js';
+import {
+  generateClaudeCodeConfig,
+  formatClaudeCodeConfig,
+  generateConfigSnippet
+} 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 snippet = generateConfigSnippet(manifest!, pkg!.path);
+    console.log(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
+  console.log(formatClaudeCodeConfig(config));
+}