@astrive-ai/cli 1.0.1

package/src/commands/plugins.ts

@@ -0,0 +1,35 @@
+import { Command } from '../cli.js';
+import { table, info } from '../ui.js';
+import * as BuiltInPlugins from '@astrive-ai/plugins';
+
+export class PluginsCommand implements Command {
+  name = 'plugins';
+  description = 'Manage plugins';
+
+  async execute(args: string[], flags: Record<string, string>): Promise<void> {
+    info('Available Built-in AstriveAI Plugins:');
+    
+    const pluginsData: string[][] = [];
+
+    // Assuming @astrive-ai/plugins exports plugin classes
+    for (const key of Object.keys(BuiltInPlugins)) {
+      const PluginClass = (BuiltInPlugins as any)[key];
+      if (typeof PluginClass === 'function' && PluginClass.prototype) {
+        try {
+          const instance = new PluginClass();
+          pluginsData.push([instance.name || key, instance.version || '1.0.0', 'Built-in plugin']);
+        } catch (e) {
+          // ignore instantiation errors
+        }
+      }
+    }
+
+    console.log();
+    if (pluginsData.length === 0) {
+      info('No built-in plugins found.');
+    } else {
+      table(['Name', 'Version', 'Description'], pluginsData);
+    }
+    console.log();
+  }
+}

package/src/commands/tools.ts

@@ -0,0 +1,47 @@
+import { Command } from '../cli.js';
+import { table, info } from '../ui.js';
+import * as BuiltInTools from '@astrive-ai/tools';
+
+export class ToolsCommand implements Command {
+  name = 'tools';
+  description = 'List available tools';
+
+  async execute(args: string[], flags: Record<string, string>): Promise<void> {
+    info('Registered AstriveAI Tools:');
+    
+    const toolClasses = [
+      BuiltInTools.DownloaderTool,
+      BuiltInTools.VisionTool,
+      BuiltInTools.TextToImageTool,
+      BuiltInTools.RemoveBGTool,
+      BuiltInTools.UpscalerTool,
+      BuiltInTools.OCRTool,
+      BuiltInTools.FaceSwapTool,
+      BuiltInTools.Img2ImgTool,
+      BuiltInTools.TextToSpeechTool,
+      BuiltInTools.SpeechToTextTool,
+      BuiltInTools.WebSearchTool,
+      BuiltInTools.FilesystemTool,
+      BuiltInTools.TerminalTool,
+      BuiltInTools.GitTool,
+    ];
+
+    const toolsData: string[][] = [];
+
+    for (const ToolClass of toolClasses) {
+      if (ToolClass) {
+        try {
+          const instance = new ToolClass();
+          const def = instance.definition;
+          toolsData.push([def.function.name, def.function.description || 'No description', 'builtin']);
+        } catch (e) {
+          // ignore instantiation errors
+        }
+      }
+    }
+
+    console.log();
+    table(['Name', 'Description', 'Category'], toolsData);
+    console.log();
+  }
+}

package/src/commands/version.ts

@@ -0,0 +1,25 @@
+import { Command } from '../cli.js';
+import { info, bold } from '../ui.js';
+import * as fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import * as path from 'path';
+
+export class VersionCommand implements Command {
+  name = 'version';
+  description = 'Show version information';
+  aliases = ['-v', '--version'];
+
+  async execute(args: string[], flags: Record<string, string>): Promise<void> {
+    try {
+      const __dirname = path.dirname(fileURLToPath(import.meta.url));
+      const pkgPath = path.resolve(__dirname, '../../package.json');
+      const pkgData = await fs.readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(pkgData);
+      
+      console.log(`${bold('AstriveAI CLI')} v${pkg.version}`);
+      console.log(`Node.js ${process.version}`);
+    } catch (err) {
+      info('AstriveAI CLI version unknown (could not read package.json)');
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { CLI } from './cli.js';
+export type { Command, Flag } from './cli.js';
+import { CLI } from './cli.js';
+
+export async function run(args: string[]): Promise<void> {
+  const cli = new CLI();
+  await cli.run(args);
+}

package/src/parser.ts

@@ -0,0 +1,41 @@
+export function parseArgs(args: string[]): { command: string; positional: string[]; flags: Record<string, string> } {
+  const command = args.length > 0 && !args[0].startsWith('-') ? args[0] : '';
+  const remaining = command ? args.slice(1) : args;
+  
+  const positional: string[] = [];
+  const flags: Record<string, string> = {};
+  
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        // Check if next arg is a value or another flag
+        if (i + 1 < remaining.length && !remaining[i + 1].startsWith('-')) {
+          flags[key] = remaining[i + 1];
+          i++; // Skip the value
+        } else {
+          flags[key] = 'true';
+        }
+      }
+    } else if (arg.startsWith('-')) {
+      const key = arg.slice(1);
+      if (i + 1 < remaining.length && !remaining[i + 1].startsWith('-')) {
+        flags[key] = remaining[i + 1];
+        i++;
+      } else {
+        flags[key] = 'true';
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  
+  return { command, positional, flags };
+}

package/src/ui.ts

@@ -0,0 +1,109 @@
+export const Colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+};
+
+export function bold(text: string): string {
+  return `${Colors.bold}${text}${Colors.reset}`;
+}
+
+export function dim(text: string): string {
+  return `${Colors.dim}${text}${Colors.reset}`;
+}
+
+export function success(msg: string): void {
+  console.log(`${Colors.green}✔${Colors.reset} ${msg}`);
+}
+
+export function error(msg: string): void {
+  console.log(`${Colors.red}✖${Colors.reset} ${msg}`);
+}
+
+export function warning(msg: string): void {
+  console.log(`${Colors.yellow}⚠${Colors.reset} ${msg}`);
+}
+
+export function info(msg: string): void {
+  console.log(`${Colors.cyan}ℹ${Colors.reset} ${msg}`);
+}
+
+export function banner(): void {
+  console.log(`
+${Colors.cyan}${Colors.bold}
+   ___       __       _         
+  / _ | ___ / /_ ____(_)  _____ 
+ / __ |(_-</ __/ __/ / |/ / -_)
+/_/ |_/___/\\__/_/ /_/|___/\\__/ 
+${Colors.reset}
+  `);
+}
+
+export function divider(): void {
+  console.log(dim('----------------------------------------'));
+}
+
+export function table(headers: string[], rows: string[][]): void {
+  const colWidths = headers.map(h => h.length);
+  rows.forEach(row => {
+    row.forEach((cell, i) => {
+      colWidths[i] = Math.max(colWidths[i], String(cell).length);
+    });
+  });
+
+  const printRow = (row: string[], isHeader = false) => {
+    const formatted = row.map((cell, i) => {
+      const padded = String(cell).padEnd(colWidths[i] + 2);
+      return isHeader ? bold(padded) : padded;
+    }).join('');
+    console.log(formatted);
+  };
+
+  printRow(headers, true);
+  divider();
+  rows.forEach(row => printRow(row));
+}
+
+export class Spinner {
+  private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  private currentFrame = 0;
+  private timer: NodeJS.Timeout | null = null;
+  private message = '';
+
+  start(msg: string): void {
+    this.message = msg;
+    if (this.timer) clearInterval(this.timer);
+    
+    this.timer = setInterval(() => {
+      process.stdout.write(`\r${Colors.cyan}${this.frames[this.currentFrame]}${Colors.reset} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+  }
+
+  stop(msg?: string): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (msg) {
+      process.stdout.write(`\r${msg}\n`);
+    } else {
+      process.stdout.write('\r\x1b[K'); // clear line
+    }
+  }
+
+  succeed(msg: string): void {
+    this.stop(`${Colors.green}✔${Colors.reset} ${msg}`);
+  }
+
+  fail(msg: string): void {
+    this.stop(`${Colors.red}✖${Colors.reset} ${msg}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}