@contextos/cli 0.1.0 → 0.2.2

package/dist/index.js

@@ -2,6 +2,8 @@
 
 // src/index.ts
 import { Command as Command14 } from "commander";
+import { join as join7 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, appendFileSync } from "fs";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -835,18 +837,36 @@ function parseValue(value) {
 import { Command as Command10 } from "commander";
 import chalk10 from "chalk";
 import ora9 from "ora";
-import { readFileSync as readFileSync3, readdirSync } from "fs";
-import { join as join4, relative } from "path";
+import { readdirSync } from "fs";
+import { readFile } from "fs/promises";
+import { join as join4, relative, resolve, normalize } from "path";
 import {
   RLMEngine,
   createGeminiClient as createGeminiClient3,
   mergeFilesToContext
 } from "@contextos/core";
-function collectFiles(dir, extensions = [".ts", ".js", ".tsx", ".jsx", ".py", ".go", ".rs", ".java"], maxFiles = 100) {
+function validatePath(userPath, projectRoot) {
+  const resolved = resolve(projectRoot, userPath);
+  const normalized = normalize(resolved);
+  const rootNormalized = normalize(projectRoot);
+  if (!normalized.startsWith(rootNormalized)) {
+    throw new Error(
+      `Invalid path: "${userPath}" escapes project boundaries.
+Path must be within: ${rootNormalized}`
+    );
+  }
+  return normalized;
+}
+async function collectFiles(dir, extensions = [".ts", ".js", ".tsx", ".jsx", ".py", ".go", ".rs", ".java"], maxFiles = 100, maxDepth = 20) {
   const files = [];
-  function walk(currentDir) {
+  async function walk(currentDir, depth) {
+    if (depth > maxDepth) {
+      console.warn(`Maximum depth (${maxDepth}) reached at ${currentDir}. Skipping deeper directories.`);
+      return;
+    }
     if (files.length >= maxFiles) return;
     const entries = readdirSync(currentDir, { withFileTypes: true });
+    const filePromises = [];
     for (const entry of entries) {
       if (files.length >= maxFiles) break;
       const fullPath = join4(currentDir, entry.name);
@@ -854,32 +874,43 @@ function collectFiles(dir, extensions = [".ts", ".js", ".tsx", ".jsx", ".py", ".
         if (["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv"].includes(entry.name)) {
           continue;
         }
-        walk(fullPath);
+        await walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
         const ext = entry.name.substring(entry.name.lastIndexOf("."));
         if (extensions.includes(ext)) {
-          try {
-            const content = readFileSync3(fullPath, "utf-8");
-            files.push({
-              path: relative(dir, fullPath),
-              content
-            });
-          } catch {
+          const promise = (async () => {
+            try {
+              const content = await readFile(fullPath, "utf-8");
+              files.push({
+                path: relative(dir, fullPath),
+                content
+              });
+            } catch {
+            }
+          })();
+          filePromises.push(promise);
+          if (filePromises.length >= 10) {
+            await Promise.all(filePromises);
+            filePromises.length = 0;
           }
         }
       }
     }
+    if (filePromises.length > 0) {
+      await Promise.all(filePromises);
+    }
   }
-  walk(dir);
+  await walk(dir, 0);
   return files;
 }
-var analyzeCommand = new Command10("analyze").description("RLM-powered deep analysis of your codebase").argument("<goal>", 'Analysis goal or question (e.g., "Find all API endpoints")').option("-d, --depth <number>", "Maximum recursion depth for RLM", "3").option("-b, --budget <tokens>", "Token budget for analysis", "50000").option("-p, --path <path>", "Path to analyze (default: current directory)", ".").option("--max-files <number>", "Maximum files to include", "100").option("--verbose", "Show detailed execution trace").action(async (goal, options) => {
+var analyzeCommand = new Command10("analyze").description("RLM-powered deep analysis of your codebase").argument("<goal>", 'Analysis goal or question (e.g., "Find all API endpoints")').option("-d, --depth <number>", "Maximum recursion depth for RLM", "3").option("-b, --budget <tokens>", "Token budget for analysis", "50000").option("-p, --path <path>", "Path to analyze (default: current directory)", ".").option("--max-files <number>", "Maximum files to include", "100").option("--max-depth <number>", "Maximum directory depth to traverse", "20").option("--verbose", "Show detailed execution trace").action(async (goal, options) => {
   console.log(chalk10.blue.bold("\n\u{1F50D} RLM Analysis Engine\n"));
   console.log(chalk10.gray("Goal: ") + chalk10.white(goal));
   console.log();
   const spinner = ora9("Collecting codebase files...").start();
   try {
-    const files = collectFiles(options.path, void 0, parseInt(options.maxFiles));
+    const safePath = validatePath(options.path, process.cwd());
+    const files = await collectFiles(safePath, void 0, parseInt(options.maxFiles), parseInt(options.maxDepth));
     spinner.text = `Found ${files.length} files. Building context...`;
     if (files.length === 0) {
       spinner.fail("No source files found");
@@ -1079,7 +1110,16 @@ Respond in JSON format:
     try {
       const jsonMatch = result.answer.match(/\{[\s\S]*\}/);
       if (jsonMatch) {
-        plan = JSON.parse(jsonMatch[0]);
+        try {
+          plan = JSON.parse(jsonMatch[0]);
+        } catch (parseError) {
+          spinner.warn("Failed to parse refactoring plan JSON");
+          console.log();
+          console.log(chalk11.blue.bold("Analysis Result:"));
+          console.log(result.answer);
+          console.log();
+          process.exit(0);
+        }
       } else {
         throw new Error("No JSON found in response");
       }
@@ -1149,13 +1189,22 @@ Respond in JSON format:
 import { Command as Command12 } from "commander";
 import chalk12 from "chalk";
 import ora11 from "ora";
-import { readFileSync as readFileSync4, existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { join as join5, basename } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { join as join5, basename, resolve as resolve2, normalize as normalize2 } from "path";
 import {
   RLMEngine as RLMEngine3,
   createGeminiClient as createGeminiClient5,
   mergeFilesToContext as mergeFilesToContext3
 } from "@contextos/core";
+function validatePath2(userPath, projectRoot) {
+  const resolved = resolve2(projectRoot, userPath);
+  const normalized = normalize2(resolved);
+  const rootNormalized = normalize2(projectRoot);
+  if (!normalized.startsWith(rootNormalized)) {
+    throw new Error(`Path traversal detected: "${userPath}" escapes project boundaries`);
+  }
+  return normalized;
+}
 var explainCommand = new Command12("explain").description("Get AI-powered explanation of code").argument("<target>", "File path, function name, or module to explain").option("-d, --depth <number>", "Include dependencies up to depth", "1").option("-f, --format <format>", "Output format: text, markdown, json", "markdown").option("--no-examples", "Skip usage examples in explanation").option("--technical", "Include technical implementation details").action(async (target, options) => {
   console.log(chalk12.blue.bold("\n\u{1F4DA} ContextOS Code Explainer\n"));
   const spinner = ora11("Analyzing target...").start();
@@ -1163,15 +1212,26 @@ var explainCommand = new Command12("explain").description("Get AI-powered explan
     let targetContent = "";
     let targetPath = "";
     let contextFiles = [];
+    let safePath;
+    try {
+      safePath = validatePath2(target, process.cwd());
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Path traversal")) {
+        spinner.fail("Invalid path");
+        console.log(chalk12.red("Error:"), error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
     const possiblePath = join5(process.cwd(), target);
     if (existsSync2(possiblePath) && statSync2(possiblePath).isFile()) {
       targetPath = target;
-      targetContent = readFileSync4(possiblePath, "utf-8");
+      targetContent = readFileSync3(possiblePath, "utf-8");
       contextFiles.push({ path: target, content: targetContent });
       spinner.text = `Found file: ${target}`;
-    } else if (existsSync2(target) && statSync2(target).isFile()) {
+    } else if (existsSync2(safePath) && statSync2(safePath).isFile()) {
       targetPath = target;
-      targetContent = readFileSync4(target, "utf-8");
+      targetContent = readFileSync3(safePath, "utf-8");
       contextFiles.push({ path: basename(target), content: targetContent });
       spinner.text = `Found file: ${target}`;
     } else {
@@ -1331,7 +1391,571 @@ var traceCommand = new Command13("trace").description("Trace function call chain
   }
 });
 
+// src/commands/plugin.ts
+import chalk14 from "chalk";
+import ora13 from "ora";
+import inquirer3 from "inquirer";
+import { createPluginManager, createPluginRegistry } from "@contextos/core";
+function registerPluginCommand(program2) {
+  const plugin = program2.command("plugin").description("Manage ContextOS plugins");
+  plugin.command("list").description("List installed plugins").option("-a, --all", "Include disabled plugins").option("--remote", "Show available plugins from registry").action(async (options) => {
+    const cwd = process.cwd();
+    const registry = createPluginRegistry(cwd);
+    if (options.remote) {
+      console.log(chalk14.cyan("\n\u{1F4E6} Featured Plugins:\n"));
+      const featured = await registry.getFeatured();
+      for (const plugin2 of featured) {
+        const installed = registry.isInstalled(plugin2.name);
+        const status = installed ? chalk14.green("\u2713 installed") : "";
+        console.log(`  ${chalk14.bold(plugin2.name)} ${chalk14.gray(`v${plugin2.version}`)} ${status}`);
+        console.log(`    ${plugin2.description}`);
+        console.log(`    ${chalk14.gray(`Downloads: ${plugin2.downloads}`)}
+`);
+      }
+      return;
+    }
+    const plugins = registry.listLocal();
+    if (plugins.length === 0) {
+      console.log(chalk14.yellow("\nNo plugins installed."));
+      console.log(chalk14.gray("Run `ctx plugin list --remote` to see available plugins.\n"));
+      return;
+    }
+    console.log(chalk14.cyan("\n\u{1F50C} Installed Plugins:\n"));
+    for (const plugin2 of plugins) {
+      if (!options.all && !plugin2.enabled) continue;
+      const status = plugin2.enabled ? chalk14.green("\u25CF enabled") : chalk14.gray("\u25CB disabled");
+      console.log(`  ${status} ${chalk14.bold(plugin2.name)} ${chalk14.gray(`v${plugin2.version}`)}`);
+      console.log(`    ${plugin2.description || "No description"}`);
+      console.log(`    ${chalk14.gray(plugin2.path)}
+`);
+    }
+  });
+  plugin.command("install <source>").description("Install a plugin").option("-l, --local", "Install from local path").option("-f, --force", "Force reinstall").action(async (source, options) => {
+    const spinner = ora13("Installing plugin...").start();
+    try {
+      const cwd = process.cwd();
+      const manager = createPluginManager(cwd);
+      const plugin2 = await manager.install(source, {
+        local: options.local,
+        force: options.force
+      });
+      spinner.succeed(`Installed ${chalk14.bold(plugin2.name)} v${plugin2.version}`);
+    } catch (error) {
+      spinner.fail(`Failed to install plugin`);
+      console.error(chalk14.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  plugin.command("remove <name>").alias("uninstall").description("Remove a plugin").option("-f, --force", "Skip confirmation").action(async (name, options) => {
+    const cwd = process.cwd();
+    const registry = createPluginRegistry(cwd);
+    const localPlugin = registry.getLocal(name);
+    if (!localPlugin) {
+      console.log(chalk14.red(`Plugin not found: ${name}`));
+      process.exit(1);
+    }
+    if (!options.force) {
+      const { confirm } = await inquirer3.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Remove plugin ${chalk14.bold(name)}?`,
+          default: false
+        }
+      ]);
+      if (!confirm) {
+        console.log(chalk14.gray("Cancelled."));
+        return;
+      }
+    }
+    const spinner = ora13("Removing plugin...").start();
+    try {
+      const manager = createPluginManager(cwd);
+      await manager.uninstall(name);
+      spinner.succeed(`Removed ${chalk14.bold(name)}`);
+    } catch (error) {
+      spinner.fail(`Failed to remove plugin`);
+      console.error(chalk14.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  plugin.command("enable <name>").description("Enable a disabled plugin").action(async (name) => {
+    const cwd = process.cwd();
+    const manager = createPluginManager(cwd);
+    await manager.loadAll();
+    const success = await manager.enablePlugin(name);
+    if (success) {
+      console.log(chalk14.green(`\u2713 Enabled ${chalk14.bold(name)}`));
+    } else {
+      console.log(chalk14.red(`Plugin not found: ${name}`));
+      process.exit(1);
+    }
+  });
+  plugin.command("disable <name>").description("Disable a plugin").action(async (name) => {
+    const cwd = process.cwd();
+    const manager = createPluginManager(cwd);
+    await manager.loadAll();
+    const success = await manager.disablePlugin(name);
+    if (success) {
+      console.log(chalk14.green(`\u2713 Disabled ${chalk14.bold(name)}`));
+    } else {
+      console.log(chalk14.red(`Plugin not found: ${name}`));
+      process.exit(1);
+    }
+  });
+  plugin.command("create <name>").description("Create a new plugin scaffold").option("-d, --description <desc>", "Plugin description").option("-a, --author <author>", "Plugin author").option("--with-commands", "Include command examples").action(async (name, options) => {
+    const cwd = process.cwd();
+    const answers = await inquirer3.prompt([
+      {
+        type: "input",
+        name: "description",
+        message: "Plugin description:",
+        default: options.description || `A ContextOS plugin`,
+        when: !options.description
+      },
+      {
+        type: "input",
+        name: "author",
+        message: "Author:",
+        default: options.author || process.env.USER || "Anonymous",
+        when: !options.author
+      },
+      {
+        type: "checkbox",
+        name: "hooks",
+        message: "Select hooks to implement:",
+        choices: [
+          { name: "onBeforeContextBuild", value: "onBeforeContextBuild" },
+          { name: "onAfterContextBuild", value: "onAfterContextBuild" },
+          { name: "onBeforeIndex", value: "onBeforeIndex" },
+          { name: "onAfterIndex", value: "onAfterIndex" },
+          { name: "onBeforeAnalyze", value: "onBeforeAnalyze" },
+          { name: "onAfterAnalyze", value: "onAfterAnalyze" },
+          { name: "fileFilter", value: "fileFilter" },
+          { name: "rankingBoost", value: "rankingBoost" }
+        ],
+        default: ["onAfterContextBuild"]
+      }
+    ]);
+    const template = {
+      name,
+      description: options.description || answers.description,
+      author: options.author || answers.author,
+      hooks: answers.hooks,
+      withCommands: options.withCommands || false
+    };
+    const spinner = ora13("Creating plugin scaffold...").start();
+    try {
+      const manager = createPluginManager(cwd);
+      const pluginPath = manager.createPluginScaffold(template);
+      spinner.succeed(`Created plugin at ${chalk14.cyan(pluginPath)}`);
+      console.log(`
+${chalk14.gray("Next steps:")}`);
+      console.log(`  1. Edit ${chalk14.cyan(`${pluginPath}/index.js`)}`);
+      console.log(`  2. Run ${chalk14.cyan(`ctx plugin enable ${name}`)}`);
+      console.log(`  3. Test your plugin!
+`);
+    } catch (error) {
+      spinner.fail(`Failed to create plugin`);
+      console.error(chalk14.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  plugin.command("run <plugin> <command> [args...]").description("Run a custom command from a plugin").action(async (pluginName, command, args) => {
+    const cwd = process.cwd();
+    const manager = createPluginManager(cwd);
+    await manager.loadAll();
+    const pluginState = manager.get(pluginName);
+    if (!pluginState) {
+      console.log(chalk14.red(`Plugin not found: ${pluginName}`));
+      process.exit(1);
+    }
+    const cmd = pluginState.instance.commands?.[command];
+    if (!cmd) {
+      console.log(chalk14.red(`Command not found: ${command}`));
+      console.log(chalk14.gray("Available commands:"));
+      const commands = Object.keys(pluginState.instance.commands || {});
+      if (commands.length === 0) {
+        console.log(chalk14.gray("  (none)"));
+      } else {
+        for (const c of commands) {
+          console.log(`  ${c}`);
+        }
+      }
+      process.exit(1);
+    }
+    try {
+      const context = {
+        projectRoot: cwd,
+        configDir: `${cwd}/.contextos`,
+        log: {
+          debug: console.debug,
+          info: console.info,
+          warn: console.warn,
+          error: console.error
+        },
+        query: async () => ({ files: [], context: "" }),
+        readFile: async () => "",
+        getDependencies: async () => [],
+        storage: {
+          get: () => void 0,
+          set: () => {
+          },
+          delete: () => false
+        }
+      };
+      await cmd.handler(args, context);
+    } catch (error) {
+      console.error(chalk14.red(`Command failed: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/finetune.ts
+import chalk15 from "chalk";
+import ora14 from "ora";
+import {
+  createTrainingDataCollector,
+  createDatasetFormatter
+} from "@contextos/core";
+function registerFinetuneCommand(program2) {
+  const finetune = program2.command("finetune").description("Training data management for model fine-tuning");
+  finetune.command("export").description("Export training data to file").option("-o, --output <path>", "Output file path", "./training-data.jsonl").option("-f, --format <format>", "Output format (jsonl, openai, anthropic, csv)", "jsonl").option("-m, --max <count>", "Maximum examples to export", parseInt).option("-r, --min-rating <rating>", "Minimum rating (good, neutral, bad)").option("-l, --language <lang>", "Filter by language").option("--shuffle", "Shuffle examples").option("--split <ratio>", "Train/validation split ratio", parseFloat).action(async (options) => {
+    const cwd = process.cwd();
+    const spinner = ora14("Exporting training data...").start();
+    try {
+      const collector = createTrainingDataCollector(cwd);
+      const formatter = createDatasetFormatter();
+      const examples = collector.getAll();
+      if (examples.length === 0) {
+        spinner.warn("No training data found");
+        console.log(chalk15.gray("\nTraining data is collected automatically when you use ctx goal/build commands."));
+        return;
+      }
+      const format = {
+        format: options.format
+      };
+      const config = {
+        maxExamples: options.max,
+        minRating: options.minRating,
+        languageFilter: options.language,
+        shuffle: options.shuffle,
+        validationSplit: options.split
+      };
+      if (options.split) {
+        const outputDir = options.output.replace(/\.[^.]+$/, "");
+        const result = await formatter.exportWithSplit(
+          examples,
+          outputDir,
+          format,
+          config
+        );
+        spinner.succeed("Export complete");
+        console.log(`
+  Train: ${chalk15.cyan(result.train)} examples \u2192 ${outputDir}/train.jsonl`);
+        console.log(`  Validation: ${chalk15.cyan(result.validation)} examples \u2192 ${outputDir}/validation.jsonl`);
+      } else {
+        const result = await formatter.export(
+          examples,
+          options.output,
+          format,
+          config
+        );
+        spinner.succeed(`Exported ${chalk15.cyan(result.exported)} examples to ${chalk15.cyan(result.path)}`);
+      }
+    } catch (error) {
+      spinner.fail("Export failed");
+      console.error(chalk15.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  finetune.command("validate <file>").description("Validate a training data file").action(async (file) => {
+    const spinner = ora14("Validating dataset...").start();
+    try {
+      const formatter = createDatasetFormatter();
+      const result = await formatter.validate(file);
+      if (result.valid) {
+        spinner.succeed("Dataset is valid");
+      } else {
+        spinner.fail("Dataset has errors");
+      }
+      console.log(`
+${chalk15.bold("Statistics:")}`);
+      console.log(`  Total examples: ${chalk15.cyan(result.stats.totalExamples)}`);
+      console.log(`  Avg tokens: ${chalk15.cyan(result.stats.avgTokenCount)}`);
+      console.log(`  Avg files/example: ${chalk15.cyan(result.stats.avgFilesPerExample)}`);
+      console.log(`
+${chalk15.bold("Rating Distribution:")}`);
+      console.log(`  ${chalk15.green("Good")}: ${result.stats.ratingDistribution.good}`);
+      console.log(`  ${chalk15.yellow("Neutral")}: ${result.stats.ratingDistribution.neutral}`);
+      console.log(`  ${chalk15.red("Bad")}: ${result.stats.ratingDistribution.bad}`);
+      console.log(`  ${chalk15.gray("Unrated")}: ${result.stats.ratingDistribution.unrated}`);
+      if (Object.keys(result.stats.languageDistribution).length > 0) {
+        console.log(`
+${chalk15.bold("Languages:")}`);
+        for (const [lang, count] of Object.entries(result.stats.languageDistribution)) {
+          console.log(`  ${lang}: ${count}`);
+        }
+      }
+      if (result.errors.length > 0) {
+        console.log(`
+${chalk15.red.bold("Errors:")}`);
+        for (const error of result.errors.slice(0, 10)) {
+          console.log(`  Line ${error.line}: ${error.message}`);
+        }
+        if (result.errors.length > 10) {
+          console.log(chalk15.gray(`  ... and ${result.errors.length - 10} more`));
+        }
+      }
+      if (result.warnings.length > 0) {
+        console.log(`
+${chalk15.yellow.bold("Warnings:")}`);
+        for (const warning of result.warnings) {
+          console.log(`  \u26A0 ${warning}`);
+        }
+      }
+    } catch (error) {
+      spinner.fail("Validation failed");
+      console.error(chalk15.red(error instanceof Error ? error.message : String(error)));
+      process.exit(1);
+    }
+  });
+  finetune.command("stats").description("Show training data statistics").action(async () => {
+    const cwd = process.cwd();
+    const collector = createTrainingDataCollector(cwd);
+    const stats = collector.getStats();
+    console.log(chalk15.cyan.bold("\n\u{1F4CA} Training Data Statistics\n"));
+    if (stats.totalExamples === 0) {
+      console.log(chalk15.yellow("No training data collected yet."));
+      console.log(chalk15.gray("\nTraining data is collected when you use ctx goal/build commands.\n"));
+      return;
+    }
+    console.log(`${chalk15.bold("Total Examples:")} ${stats.totalExamples}`);
+    console.log(`${chalk15.bold("Avg Token Count:")} ${stats.avgTokenCount}`);
+    console.log(`${chalk15.bold("Avg Files/Example:")} ${stats.avgFilesPerExample}`);
+    console.log(`
+${chalk15.bold("Rating Distribution:")}`);
+    const total = stats.totalExamples;
+    const pct = (n) => (n / total * 100).toFixed(1);
+    console.log(`  ${chalk15.green("\u25CF")} Good: ${stats.ratingDistribution.good} (${pct(stats.ratingDistribution.good)}%)`);
+    console.log(`  ${chalk15.yellow("\u25CF")} Neutral: ${stats.ratingDistribution.neutral} (${pct(stats.ratingDistribution.neutral)}%)`);
+    console.log(`  ${chalk15.red("\u25CF")} Bad: ${stats.ratingDistribution.bad} (${pct(stats.ratingDistribution.bad)}%)`);
+    console.log(`  ${chalk15.gray("\u25CB")} Unrated: ${stats.ratingDistribution.unrated} (${pct(stats.ratingDistribution.unrated)}%)`);
+    console.log(`
+${chalk15.bold("Languages:")}`);
+    for (const [lang, count] of Object.entries(stats.languageDistribution)) {
+      console.log(`  ${lang}: ${count} (${pct(count)}%)`);
+    }
+    console.log(`
+${chalk15.bold("Date Range:")}`);
+    console.log(`  From: ${stats.dateRange.earliest.toLocaleDateString()}`);
+    console.log(`  To: ${stats.dateRange.latest.toLocaleDateString()}`);
+    console.log();
+  });
+  finetune.command("feedback <id> <rating>").description("Add feedback to a training example (good/bad/neutral)").option("-c, --comment <comment>", "Optional comment").action(async (id, rating, options) => {
+    const validRatings = ["good", "bad", "neutral"];
+    if (!validRatings.includes(rating)) {
+      console.error(chalk15.red(`Invalid rating. Use: ${validRatings.join(", ")}`));
+      process.exit(1);
+    }
+    const cwd = process.cwd();
+    const collector = createTrainingDataCollector(cwd);
+    const success = collector.addFeedback(
+      id,
+      rating,
+      options.comment
+    );
+    if (success) {
+      console.log(chalk15.green(`\u2713 Feedback added for ${id}`));
+    } else {
+      console.error(chalk15.red(`Example not found: ${id}`));
+      process.exit(1);
+    }
+  });
+  finetune.command("recent").description("Show recent training examples").option("-n, --limit <count>", "Number of examples", parseInt, 5).action(async (options) => {
+    const cwd = process.cwd();
+    const collector = createTrainingDataCollector(cwd);
+    const recent = collector.getRecent(options.limit);
+    if (recent.length === 0) {
+      console.log(chalk15.yellow("\nNo training data collected yet.\n"));
+      return;
+    }
+    console.log(chalk15.cyan.bold("\n\u{1F4CB} Recent Training Examples\n"));
+    for (const example of recent) {
+      const rating = example.feedback?.rating;
+      const ratingIcon = rating === "good" ? "\u{1F44D}" : rating === "bad" ? "\u{1F44E}" : "\u2022";
+      const date = new Date(example.meta.timestamp).toLocaleString();
+      console.log(`${chalk15.bold(example.id)} ${ratingIcon}`);
+      console.log(`  Goal: ${chalk15.white(example.goal.substring(0, 60))}${example.goal.length > 60 ? "..." : ""}`);
+      console.log(`  Files: ${example.selectedFiles.length} | Tokens: ${example.tokenCount}`);
+      console.log(`  ${chalk15.gray(date)}
+`);
+    }
+  });
+}
+
+// src/commands/cloud.ts
+import chalk16 from "chalk";
+import ora15 from "ora";
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { join as join6 } from "path";
+var CLOUD_CONFIG_PATH = join6(homedir(), ".contextos", "cloud.json");
+var DEFAULT_CLOUD_URL = "https://api.contextos.dev";
+function loadCloudConfig() {
+  if (existsSync3(CLOUD_CONFIG_PATH)) {
+    try {
+      return JSON.parse(readFileSync4(CLOUD_CONFIG_PATH, "utf-8"));
+    } catch {
+      return { cloudUrl: DEFAULT_CLOUD_URL };
+    }
+  }
+  return { cloudUrl: DEFAULT_CLOUD_URL };
+}
+function saveCloudConfig(config) {
+  const dir = join6(CLOUD_CONFIG_PATH, "..");
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync4(CLOUD_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function registerCloudCommands(program2) {
+  program2.command("login").description("Login to ContextOS Cloud").option("--api-key <key>", "API key").option("--url <url>", "Cloud server URL", DEFAULT_CLOUD_URL).action(async (options) => {
+    console.log(chalk16.cyan.bold("\n\u{1F510} ContextOS Cloud Login\n"));
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+      const { default: inquirer4 } = await import("inquirer");
+      const answers = await inquirer4.prompt([
+        {
+          type: "input",
+          name: "apiKey",
+          message: "Enter your API key:",
+          validate: (input) => input.startsWith("ctx_") || "API key must start with ctx_"
+        }
+      ]);
+      apiKey = answers.apiKey;
+    }
+    const spinner = ora15("Validating API key...").start();
+    try {
+      const response = await fetch(`${options.url}/health`, {
+        headers: { "X-API-Key": apiKey }
+      });
+      if (!response.ok) {
+        spinner.fail("Invalid API key or server error");
+        return;
+      }
+      spinner.succeed("API key validated");
+      const config = {
+        apiKey,
+        cloudUrl: options.url,
+        userId: `user_${apiKey.slice(4, 12)}`,
+        tier: "free"
+      };
+      saveCloudConfig(config);
+      console.log(chalk16.green("\n\u2705 Logged in successfully!"));
+      console.log(chalk16.gray(`Config saved to: ${CLOUD_CONFIG_PATH}
+`));
+    } catch (error) {
+      spinner.fail(error instanceof Error ? error.message : "Connection failed");
+    }
+  });
+  program2.command("logout").description("Logout from ContextOS Cloud").action(() => {
+    const config = loadCloudConfig();
+    config.apiKey = void 0;
+    config.userId = void 0;
+    saveCloudConfig(config);
+    console.log(chalk16.green("\n\u2705 Logged out successfully\n"));
+  });
+  program2.command("connect").description("Connect your IDEs to ContextOS Cloud").option("--all", "Configure all detected IDEs").option("--ide <name>", "Configure specific IDE").action(async (options) => {
+    const config = loadCloudConfig();
+    if (!config.apiKey) {
+      console.log(chalk16.red("\n\u274C Not logged in. Run `ctx login` first.\n"));
+      return;
+    }
+    console.log(chalk16.cyan.bold("\n\u{1F50C} Connecting IDEs to ContextOS Cloud\n"));
+    const { detectIDEs } = await import("@contextos/setup").catch(() => ({
+      detectIDEs: async () => []
+    }));
+    const ides = await detectIDEs();
+    if (ides.length === 0) {
+      console.log(chalk16.yellow("No supported IDEs detected.\n"));
+      return;
+    }
+    console.log(chalk16.gray("This will configure your IDEs to use the cloud MCP server."));
+    console.log(chalk16.gray(`Cloud URL: ${config.cloudUrl}
+`));
+    for (const ide of ides) {
+      if (options.ide && ide.id !== options.ide) continue;
+      console.log(`${chalk16.cyan("\u2192")} ${ide.name}`);
+    }
+    console.log(chalk16.green("\n\u2705 IDEs connected to cloud!\n"));
+  });
+  program2.command("cloud").description("Show ContextOS Cloud status").action(async () => {
+    const config = loadCloudConfig();
+    console.log(chalk16.cyan.bold("\n\u2601\uFE0F  ContextOS Cloud Status\n"));
+    if (!config.apiKey) {
+      console.log(chalk16.yellow("Not logged in"));
+      console.log(chalk16.gray("\nRun `ctx login` to connect to ContextOS Cloud.\n"));
+      return;
+    }
+    console.log(`${chalk16.gray("User ID:")}     ${config.userId}`);
+    console.log(`${chalk16.gray("Tier:")}        ${config.tier}`);
+    console.log(`${chalk16.gray("Cloud URL:")}   ${config.cloudUrl}`);
+    const spinner = ora15("Checking connection...").start();
+    try {
+      const response = await fetch(`${config.cloudUrl}/health`, {
+        headers: { "X-API-Key": config.apiKey }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        spinner.succeed(`Connected (v${data.version})`);
+      } else {
+        spinner.warn("Connection issues");
+      }
+    } catch {
+      spinner.fail("Cannot reach cloud server");
+    }
+    console.log();
+  });
+}
+
 // src/index.ts
+var crashLogDir = join7(process.cwd(), ".contextos");
+if (!existsSync4(crashLogDir)) {
+  mkdirSync3(crashLogDir, { recursive: true });
+}
+var crashLogPath = join7(crashLogDir, "crash.log");
+function logCrash(message, data) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logEntry = `[${timestamp}] ${message}${data ? `
+${data}
+
+` : "\n\n"}`;
+  console.error(logEntry);
+  appendFileSync(crashLogPath, logEntry, "utf-8");
+}
+process.on("uncaughtException", (error) => {
+  console.error("\u274C UNCAUGHT EXCEPTION:", error.message);
+  console.error("Stack:", error.stack);
+  if (process.env.NODE_ENV === "production") {
+    logCrash(`UNCAUGHT EXCEPTION: ${error.message}`, error.stack);
+  }
+  setTimeout(() => process.exit(1), 1e3);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("\u274C UNHANDLED REJECTION:", reason);
+  if (process.env.NODE_ENV === "production") {
+    const reasonStr = reason instanceof Error ? reason.stack : String(reason);
+    logCrash("UNHANDLED REJECTION", reasonStr);
+  }
+});
+process.on("multipleResolves", (type, promise) => {
+  console.warn("\u26A0\uFE0F  MULTIPLE RESOLVES:", type, promise);
+});
+process.on("warning", (warning) => {
+  console.warn("\u26A0\uFE0F  PROCESS WARNING:", warning.name, warning.message);
+});
 var program = new Command14();
 program.name("ctx").description("ContextOS - The Context Server Protocol for AI Coding").version("0.1.0").option("-v, --verbose", "Enable verbose output");
 program.addCommand(initCommand);
@@ -1347,4 +1971,7 @@ program.addCommand(analyzeCommand);
 program.addCommand(refactorCommand);
 program.addCommand(explainCommand);
 program.addCommand(traceCommand);
+registerPluginCommand(program);
+registerFinetuneCommand(program);
+registerCloudCommands(program);
 program.parse();

package/package.json

@@ -1,42 +1,42 @@
 {
-    "name": "@contextos/cli",
-    "version": "0.1.0",
-    "description": "CLI for ContextOS - The Context Server Protocol for AI Coding",
-    "type": "module",
-    "bin": {
-        "ctx": "./dist/index.js"
-    },
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "scripts": {
-        "build": "tsup src/index.ts --format esm --clean",
-        "dev": "tsup src/index.ts --format cjs --dts --watch",
-        "start": "node dist/index.js",
-        "test": "vitest run",
-        "lint": "eslint src/",
-        "clean": "rimraf dist"
-    },
-    "dependencies": {
-        "@contextos/core": "workspace:*",
-        "chalk": "^5.3.0",
-        "clipboardy": "^4.0.0",
-        "commander": "^12.0.0",
-        "glob": "^10.3.0",
-        "inquirer": "^9.2.0",
-        "ora": "^8.0.0",
-        "yaml": "^2.4.0"
-    },
-    "devDependencies": {
-        "@types/inquirer": "^9.0.7",
-        "@types/node": "^20.11.0",
-        "eslint": "^8.57.0",
-        "rimraf": "^5.0.5",
-        "tsup": "^8.0.2",
-        "typescript": "^5.4.0",
-        "vitest": "^1.4.0"
-    },
-    "files": [
-        "dist"
-    ],
-    "license": "MIT"
+  "name": "@contextos/cli",
+  "version": "0.2.2",
+  "description": "CLI for ContextOS - The Context Server Protocol for AI Coding",
+  "type": "module",
+  "bin": {
+    "ctx": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "clipboardy": "^4.0.0",
+    "commander": "^12.0.0",
+    "glob": "^10.3.0",
+    "inquirer": "^9.2.0",
+    "ora": "^8.0.0",
+    "yaml": "^2.4.0",
+    "@contextos/core": "0.2.2"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.0",
+    "eslint": "^8.57.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.0",
+    "vitest": "^1.4.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsup src/index.ts --format cjs --dts --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "clean": "rimraf dist"
+  }
 }