db4ai 0.3.0 → 0.3.1

package/dist/cli/bin.js

@@ -1,41 +1,36 @@
 #!/usr/bin/env node
-/**
- * db4ai CLI - Command Line Interface
- *
- * Entry point for the db4ai CLI tool.
- */
-import { existsSync } from 'fs';
-import { resolve } from 'path';
-// Version from package.json
-export const CLI_VERSION = '0.1.0';
-const COMMANDS = ['scan', 'seed', 'workflow', 'sync', 'dashboard'];
-const COMMAND_DESCRIPTIONS = {
-    scan: 'Scan project for schemas',
-    seed: 'Run seed files',
-    workflow: 'Execute workflows',
-    sync: 'Synchronize data',
-    dashboard: 'Launch dashboard',
+
+// cli/bin.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var CLI_VERSION = "0.1.0";
+var COMMANDS = ["scan", "seed", "workflow", "sync", "dashboard"];
+var COMMAND_DESCRIPTIONS = {
+  scan: "Scan project for schemas",
+  seed: "Run seed files",
+  workflow: "Execute workflows",
+  sync: "Synchronize data",
+  dashboard: "Launch dashboard"
 };
-// Main help text
 function getMainHelp() {
-    let help = 'Usage: db4ai [options] [command]\n\n';
-    help += 'Commands:\n';
-    for (const cmd of COMMANDS) {
-        help += `  ${cmd.padEnd(12)} ${COMMAND_DESCRIPTIONS[cmd]}\n`;
-    }
-    help += '\nGlobal Options:\n';
-    help += '  --version, -v     Show version number\n';
-    help += '  --help, -h        Show help\n';
-    help += '  --config <file>   Path to config file\n';
-    help += '  --verbose         Enable verbose output\n';
-    help += '  --quiet           Suppress output\n';
-    help += '  --no-color        Disable colored output\n';
-    help += '  --json            Output as JSON\n';
-    return help;
+  let help = "Usage: db4ai [options] [command]\n\n";
+  help += "Commands:\n";
+  for (const cmd of COMMANDS) {
+    help += `  ${cmd.padEnd(12)} ${COMMAND_DESCRIPTIONS[cmd]}
+`;
+  }
+  help += "\nGlobal Options:\n";
+  help += "  --version, -v     Show version number\n";
+  help += "  --help, -h        Show help\n";
+  help += "  --config <file>   Path to config file\n";
+  help += "  --verbose         Enable verbose output\n";
+  help += "  --quiet           Suppress output\n";
+  help += "  --no-color        Disable colored output\n";
+  help += "  --json            Output as JSON\n";
+  return help;
 }
-// Command-specific help
 function getScanHelp() {
-    return `Usage: db4ai scan [options]
+  return `Usage: db4ai scan [options]
 
 Scan project for schemas
 
@@ -48,7 +43,7 @@ Options:
 `;
 }
 function getSeedHelp() {
-    return `Usage: db4ai seed [file] [options]
+  return `Usage: db4ai seed [file] [options]
 
 Run seed files
 
@@ -61,7 +56,7 @@ Options:
 `;
 }
 function getWorkflowHelp() {
-    return `Usage: db4ai workflow [name] [options]
+  return `Usage: db4ai workflow [name] [options]
 
 Execute workflows
 
@@ -73,7 +68,7 @@ Options:
 `;
 }
 function getSyncHelp() {
-    return `Usage: db4ai sync [subcommand] [options]
+  return `Usage: db4ai sync [subcommand] [options]
 
 Synchronize data
 
@@ -89,7 +84,7 @@ Options:
 `;
 }
 function getSyncPushHelp() {
-    return `Usage: db4ai sync push [options]
+  return `Usage: db4ai sync push [options]
 
 Push local changes to remote
 
@@ -100,7 +95,7 @@ Options:
 `;
 }
 function getSyncPullHelp() {
-    return `Usage: db4ai sync pull [options]
+  return `Usage: db4ai sync pull [options]
 
 Pull remote changes to local
 
@@ -111,7 +106,7 @@ Options:
 `;
 }
 function getDashboardHelp() {
-    return `Usage: db4ai dashboard [options]
+  return `Usage: db4ai dashboard [options]
 
 Launch dashboard
 
@@ -122,297 +117,272 @@ Options:
   --help             Show help
 `;
 }
-// Find similar commands for typo suggestions
 function findSimilarCommand(input) {
-    const threshold = 2; // Levenshtein distance threshold
-    function levenshtein(a, b) {
-        const matrix = [];
-        for (let i = 0; i <= b.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= a.length; j++) {
-            matrix[0][j] = j;
-        }
-        for (let i = 1; i <= b.length; i++) {
-            for (let j = 1; j <= a.length; j++) {
-                if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1][j - 1];
-                }
-                else {
-                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
-                }
-            }
-        }
-        return matrix[b.length][a.length];
+  const threshold = 2;
+  function levenshtein(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
     }
-    let closest = null;
-    let closestDistance = Infinity;
-    for (const cmd of COMMANDS) {
-        const distance = levenshtein(input, cmd);
-        if (distance < closestDistance && distance <= threshold) {
-            closest = cmd;
-            closestDistance = distance;
-        }
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
     }
-    return closest;
-}
-/**
- * Parse CLI arguments into a structured format
- * @param args - Raw command line arguments (process.argv.slice(2))
- * @returns Parsed arguments with flags, command, and remaining args
- */
-export function parseArgs(args) {
-    const result = {
-        version: false,
-        help: false,
-        args: [],
-        verbose: false,
-        quiet: false,
-        noColor: false,
-        json: false,
-    };
-    let i = 0;
-    let foundCommand = false;
-    while (i < args.length) {
-        const arg = args[i];
-        if (!foundCommand) {
-            // Global flags before command
-            if (arg === '--version' || arg === '-v') {
-                result.version = true;
-                i++;
-                continue;
-            }
-            if (arg === '--help' || arg === '-h') {
-                result.help = true;
-                i++;
-                continue;
-            }
-            if (arg === '--config') {
-                result.config = args[i + 1];
-                i += 2;
-                continue;
-            }
-            if (arg === '--verbose') {
-                result.verbose = true;
-                i++;
-                continue;
-            }
-            if (arg === '--quiet') {
-                result.quiet = true;
-                i++;
-                continue;
-            }
-            if (arg === '--no-color') {
-                result.noColor = true;
-                i++;
-                continue;
-            }
-            if (arg === '--json') {
-                result.json = true;
-                i++;
-                continue;
-            }
-            // Check if it's a command
-            if (COMMANDS.includes(arg)) {
-                result.command = arg;
-                foundCommand = true;
-                i++;
-                continue;
-            }
-            // Unknown argument before command - treat as command (will error later)
-            if (!arg.startsWith('-')) {
-                result.command = arg;
-                foundCommand = true;
-                i++;
-                continue;
-            }
-        }
-        // After command, collect all remaining args
-        if (foundCommand) {
-            // Check for subcommand (for sync)
-            if (result.command === 'sync' && !result.subcommand && !arg.startsWith('-')) {
-                if (arg === 'push' || arg === 'pull') {
-                    result.subcommand = arg;
-                    i++;
-                    continue;
-                }
-            }
-            // Check for global options after command
-            if (arg === '--verbose') {
-                result.verbose = true;
-                i++;
-                continue;
-            }
-            if (arg === '--quiet') {
-                result.quiet = true;
-                i++;
-                continue;
-            }
-            if (arg === '--help' || arg === '-h') {
-                result.help = true;
-                i++;
-                continue;
-            }
-            if (arg === '--json') {
-                result.json = true;
-                i++;
-                continue;
-            }
-            result.args.push(arg);
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        if (b.charAt(i - 1) === a.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
         }
-        i++;
+      }
+    }
+    return matrix[b.length][a.length];
+  }
+  let closest = null;
+  let closestDistance = Infinity;
+  for (const cmd of COMMANDS) {
+    const distance = levenshtein(input, cmd);
+    if (distance < closestDistance && distance <= threshold) {
+      closest = cmd;
+      closestDistance = distance;
     }
-    return result;
+  }
+  return closest;
 }
-// Command handlers
-export async function handleScan(args, streams) {
-    // Check for help
-    if (args.includes('--help') || args.includes('-h')) {
-        streams.stdout.write(getScanHelp());
-        return 0;
+function parseArgs(args) {
+  const result = {
+    version: false,
+    help: false,
+    args: [],
+    verbose: false,
+    quiet: false,
+    noColor: false,
+    json: false
+  };
+  let i = 0;
+  let foundCommand = false;
+  while (i < args.length) {
+    const arg = args[i];
+    if (!foundCommand) {
+      if (arg === "--version" || arg === "-v") {
+        result.version = true;
+        i++;
+        continue;
+      }
+      if (arg === "--help" || arg === "-h") {
+        result.help = true;
+        i++;
+        continue;
+      }
+      if (arg === "--config") {
+        result.config = args[i + 1];
+        i += 2;
+        continue;
+      }
+      if (arg === "--verbose") {
+        result.verbose = true;
+        i++;
+        continue;
+      }
+      if (arg === "--quiet") {
+        result.quiet = true;
+        i++;
+        continue;
+      }
+      if (arg === "--no-color") {
+        result.noColor = true;
+        i++;
+        continue;
+      }
+      if (arg === "--json") {
+        result.json = true;
+        i++;
+        continue;
+      }
+      if (COMMANDS.includes(arg)) {
+        result.command = arg;
+        foundCommand = true;
+        i++;
+        continue;
+      }
+      if (!arg.startsWith("-")) {
+        result.command = arg;
+        foundCommand = true;
+        i++;
+        continue;
+      }
     }
-    // Check for unknown options
-    for (const arg of args) {
-        if (arg.startsWith('--') && !['--root', '--include', '--exclude', '--json', '--verbose', '--quiet'].includes(arg)) {
-            streams.stderr.write(`Unknown option: ${arg}\n`);
-            return 2;
+    if (foundCommand) {
+      if (result.command === "sync" && !result.subcommand && !arg.startsWith("-")) {
+        if (arg === "push" || arg === "pull") {
+          result.subcommand = arg;
+          i++;
+          continue;
         }
+      }
+      if (arg === "--verbose") {
+        result.verbose = true;
+        i++;
+        continue;
+      }
+      if (arg === "--quiet") {
+        result.quiet = true;
+        i++;
+        continue;
+      }
+      if (arg === "--help" || arg === "-h") {
+        result.help = true;
+        i++;
+        continue;
+      }
+      if (arg === "--json") {
+        result.json = true;
+        i++;
+        continue;
+      }
+      result.args.push(arg);
     }
-    // Actual scan implementation would go here
-    streams.stdout.write('Scanning...\n');
-    return 0;
+    i++;
+  }
+  return result;
 }
-export async function handleSeed(args, streams) {
-    // Check for help
-    if (args.includes('--help') || args.includes('-h')) {
-        streams.stdout.write(getSeedHelp());
-        return 0;
+async function handleScan(args, streams) {
+  if (args.includes("--help") || args.includes("-h")) {
+    streams.stdout.write(getScanHelp());
+    return 0;
+  }
+  for (const arg of args) {
+    if (arg.startsWith("--") && !["--root", "--include", "--exclude", "--json", "--verbose", "--quiet"].includes(arg)) {
+      streams.stderr.write(`Unknown option: ${arg}
+`);
+      return 2;
     }
-    // Actual seed implementation would go here
-    streams.stdout.write('Seeding...\n');
+  }
+  streams.stdout.write("Scanning...\n");
+  return 0;
+}
+async function handleSeed(args, streams) {
+  if (args.includes("--help") || args.includes("-h")) {
+    streams.stdout.write(getSeedHelp());
     return 0;
+  }
+  streams.stdout.write("Seeding...\n");
+  return 0;
 }
-export async function handleWorkflow(args, streams) {
-    // Check for help
-    if (args.includes('--help') || args.includes('-h')) {
-        streams.stdout.write(getWorkflowHelp());
-        return 0;
-    }
-    // Actual workflow implementation would go here
-    streams.stdout.write('Running workflow...\n');
+async function handleWorkflow(args, streams) {
+  if (args.includes("--help") || args.includes("-h")) {
+    streams.stdout.write(getWorkflowHelp());
     return 0;
+  }
+  streams.stdout.write("Running workflow...\n");
+  return 0;
 }
-export async function handleSync(args, subcommand, streams) {
-    // Check for help on main sync command
-    if (args.includes('--help') || args.includes('-h')) {
-        if (subcommand === 'push') {
-            streams.stdout.write(getSyncPushHelp());
-        }
-        else if (subcommand === 'pull') {
-            streams.stdout.write(getSyncPullHelp());
-        }
-        else {
-            streams.stdout.write(getSyncHelp());
-        }
-        return 0;
-    }
-    // Actual sync implementation would go here
-    if (subcommand) {
-        streams.stdout.write(`Syncing (${subcommand})...\n`);
-    }
-    else {
-        streams.stdout.write('Syncing...\n');
+async function handleSync(args, subcommand, streams) {
+  if (args.includes("--help") || args.includes("-h")) {
+    if (subcommand === "push") {
+      streams.stdout.write(getSyncPushHelp());
+    } else if (subcommand === "pull") {
+      streams.stdout.write(getSyncPullHelp());
+    } else {
+      streams.stdout.write(getSyncHelp());
     }
     return 0;
+  }
+  if (subcommand) {
+    streams.stdout.write(`Syncing (${subcommand})...
+`);
+  } else {
+    streams.stdout.write("Syncing...\n");
+  }
+  return 0;
 }
-export async function handleDashboard(args, streams) {
-    // Check for help
-    if (args.includes('--help') || args.includes('-h')) {
-        streams.stdout.write(getDashboardHelp());
-        return 0;
-    }
-    // Actual dashboard implementation would go here
-    streams.stdout.write('Launching dashboard...\n');
+async function handleDashboard(args, streams) {
+  if (args.includes("--help") || args.includes("-h")) {
+    streams.stdout.write(getDashboardHelp());
     return 0;
+  }
+  streams.stdout.write("Launching dashboard...\n");
+  return 0;
 }
-/**
- * Main CLI entry point
- * @param args - Command line arguments
- * @param options - Optional output streams for testing
- * @returns Exit code (0 = success, 1 = error, 2 = invalid args)
- */
-export async function run(args, options = {}) {
-    const streams = {
-        stdout: options.stdout || process.stdout,
-        stderr: options.stderr || process.stderr,
-    };
-    const parsed = parseArgs(args);
-    // Handle version
-    if (parsed.version) {
-        if (parsed.json) {
-            streams.stdout.write(JSON.stringify({ version: CLI_VERSION }) + '\n');
-        }
-        else {
-            streams.stdout.write(CLI_VERSION + '\n');
-        }
-        return 0;
-    }
-    // Check for config file if specified - do this early, before help
-    // Only error on missing config if it's a custom config file (not default db4.config.ts/js)
-    if (parsed.config) {
-        const configPath = resolve(process.cwd(), parsed.config);
-        const isDefaultConfig = parsed.config === 'db4.config.ts' || parsed.config === 'db4.config.js';
-        if (!existsSync(configPath) && !isDefaultConfig) {
-            streams.stderr.write(`Config file not found: ${parsed.config}\n`);
-            return 1;
-        }
-    }
-    // Handle help (no command)
-    if (parsed.help && !parsed.command) {
-        streams.stdout.write(getMainHelp());
-        return 0;
-    }
-    // No command - show help
-    if (!parsed.command) {
-        streams.stdout.write(getMainHelp());
-        return 0;
+async function run(args, options = {}) {
+  const streams = {
+    stdout: options.stdout || process.stdout,
+    stderr: options.stderr || process.stderr
+  };
+  const parsed = parseArgs(args);
+  if (parsed.version) {
+    if (parsed.json) {
+      streams.stdout.write(JSON.stringify({ version: CLI_VERSION }) + "\n");
+    } else {
+      streams.stdout.write(CLI_VERSION + "\n");
     }
-    // Check for unknown command
-    if (!COMMANDS.includes(parsed.command)) {
-        const similar = findSimilarCommand(parsed.command);
-        streams.stderr.write(`Unknown command: ${parsed.command}\n`);
-        if (similar) {
-            streams.stderr.write(`Did you mean '${similar}'?\n`);
-        }
-        streams.stderr.write(`Run 'db4ai --help' for usage.\n`);
-        return 1;
+    return 0;
+  }
+  if (parsed.config) {
+    const configPath = resolve(process.cwd(), parsed.config);
+    const isDefaultConfig = parsed.config === "db4.config.ts" || parsed.config === "db4.config.js";
+    if (!existsSync(configPath) && !isDefaultConfig) {
+      streams.stderr.write(`Config file not found: ${parsed.config}
+`);
+      return 1;
     }
-    // Route to command handler
-    // If help flag is set, pass it to the handler
-    const commandArgs = parsed.help ? ['--help', ...parsed.args] : parsed.args;
-    switch (parsed.command) {
-        case 'scan':
-            return handleScan(commandArgs, streams);
-        case 'seed':
-            return handleSeed(commandArgs, streams);
-        case 'workflow':
-            return handleWorkflow(commandArgs, streams);
-        case 'sync':
-            return handleSync(commandArgs, parsed.subcommand, streams);
-        case 'dashboard':
-            return handleDashboard(commandArgs, streams);
-        default:
-            streams.stderr.write(`Unknown command: ${parsed.command}\n`);
-            return 1;
+  }
+  if (parsed.help && !parsed.command) {
+    streams.stdout.write(getMainHelp());
+    return 0;
+  }
+  if (!parsed.command) {
+    streams.stdout.write(getMainHelp());
+    return 0;
+  }
+  if (!COMMANDS.includes(parsed.command)) {
+    const similar = findSimilarCommand(parsed.command);
+    streams.stderr.write(`Unknown command: ${parsed.command}
+`);
+    if (similar) {
+      streams.stderr.write(`Did you mean '${similar}'?
+`);
     }
+    streams.stderr.write(`Run 'db4ai --help' for usage.
+`);
+    return 1;
+  }
+  const commandArgs = parsed.help ? ["--help", ...parsed.args] : parsed.args;
+  switch (parsed.command) {
+    case "scan":
+      return handleScan(commandArgs, streams);
+    case "seed":
+      return handleSeed(commandArgs, streams);
+    case "workflow":
+      return handleWorkflow(commandArgs, streams);
+    case "sync":
+      return handleSync(commandArgs, parsed.subcommand, streams);
+    case "dashboard":
+      return handleDashboard(commandArgs, streams);
+    default:
+      streams.stderr.write(`Unknown command: ${parsed.command}
+`);
+      return 1;
+  }
 }
-// CLI entry point
-if (process.argv[1] === import.meta.url.replace('file://', '') ||
-    process.argv[1]?.endsWith('/bin.ts') ||
-    process.argv[1]?.endsWith('/bin.js')) {
-    const args = process.argv.slice(2);
-    run(args).then((code) => {
-        process.exit(code);
-    });
+if (process.argv[1] === import.meta.url.replace("file://", "") || process.argv[1]?.endsWith("/bin.ts") || process.argv[1]?.endsWith("/bin.js")) {
+  const args = process.argv.slice(2);
+  run(args).then((code) => {
+    process.exit(code);
+  });
 }
+export {
+  CLI_VERSION,
+  handleDashboard,
+  handleScan,
+  handleSeed,
+  handleSync,
+  handleWorkflow,
+  parseArgs,
+  run
+};
 //# sourceMappingURL=bin.js.map