kubit-forge 0.0.1-canary.85d379a

package/dist/index.js

@@ -0,0 +1,1979 @@
+#!/usr/bin/env node
+
+// src/core/plugin-manager.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/core/plugin-dependency-resolver.ts
+var PluginDependencyResolver = class {
+  logger;
+  plugins = /* @__PURE__ */ new Map();
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Register plugin metadata
+   */
+  register(metadata) {
+    this.plugins.set(metadata.name, metadata);
+    this.logger.debug(`Registered plugin metadata: ${metadata.name}@${metadata.version}`);
+  }
+  /**
+   * Resolve dependencies and determine load order
+   */
+  resolve(pluginNames) {
+    const errors = [];
+    const warnings = [];
+    const missing = [];
+    const conflicts = [];
+    const graph = this.buildDependencyGraph(pluginNames);
+    for (const pluginName of pluginNames) {
+      const metadata = this.plugins.get(pluginName);
+      if (!metadata) {
+        warnings.push(`Plugin '${pluginName}' not found (not installed or not registered)`);
+        continue;
+      }
+      if (metadata.dependencies) {
+        for (const dep of metadata.dependencies) {
+          if (!this.plugins.has(dep.name)) {
+            if (dep.optional) {
+              warnings.push(
+                `Optional dependency '${dep.name}' for '${pluginName}' is not installed`
+              );
+            } else {
+              errors.push(`Required dependency '${dep.name}' for '${pluginName}' is not installed`);
+              missing.push(dep);
+            }
+          }
+        }
+      }
+      if (metadata.peerDependencies) {
+        for (const peer of metadata.peerDependencies) {
+          if (!this.plugins.has(peer.name)) {
+            warnings.push(`Peer dependency '${peer.name}' for '${pluginName}' is not installed`);
+            if (!peer.optional) {
+              missing.push(peer);
+            }
+          }
+        }
+      }
+      if (metadata.conflicts) {
+        for (const conflict of metadata.conflicts) {
+          if (this.plugins.has(conflict)) {
+            errors.push(`Plugin '${pluginName}' conflicts with '${conflict}'`);
+            conflicts.push({ conflictsWith: conflict, plugin: pluginName });
+          }
+        }
+      }
+    }
+    const circular = this.detectCircularDependencies(graph);
+    if (circular.length > 0) {
+      errors.push(`Circular dependencies detected: ${circular.join(" -> ")}`);
+    }
+    let loadOrder = [];
+    if (errors.length === 0) {
+      try {
+        loadOrder = this.topologicalSort(graph);
+      } catch (error) {
+        errors.push(
+          `Failed to resolve load order: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return {
+      conflicts,
+      errors,
+      loadOrder,
+      missing,
+      warnings
+    };
+  }
+  /**
+   * Build dependency graph
+   */
+  buildDependencyGraph(pluginNames) {
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...pluginNames];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) {
+        continue;
+      }
+      visited.add(current);
+      const metadata = this.plugins.get(current);
+      if (!metadata) {
+        continue;
+      }
+      nodes.set(current, metadata);
+      if (metadata.dependencies) {
+        for (const dep of metadata.dependencies) {
+          if (!edges.has(current)) {
+            edges.set(current, /* @__PURE__ */ new Set());
+          }
+          edges.get(current).add(dep.name);
+          if (!visited.has(dep.name)) {
+            queue.push(dep.name);
+          }
+        }
+      }
+      if (metadata.peerDependencies) {
+        for (const peer of metadata.peerDependencies) {
+          if (!edges.has(current)) {
+            edges.set(current, /* @__PURE__ */ new Set());
+          }
+          edges.get(current).add(peer.name);
+          if (!visited.has(peer.name)) {
+            queue.push(peer.name);
+          }
+        }
+      }
+    }
+    return { edges, nodes };
+  }
+  /**
+   * Detect circular dependencies
+   */
+  detectCircularDependencies(graph) {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const path = [];
+    const dfs = (node) => {
+      visited.add(node);
+      recursionStack.add(node);
+      path.push(node);
+      const dependencies = graph.edges.get(node) || /* @__PURE__ */ new Set();
+      for (const dep of dependencies) {
+        if (!visited.has(dep)) {
+          if (dfs(dep)) {
+            return true;
+          }
+        } else if (recursionStack.has(dep)) {
+          return true;
+        }
+      }
+      recursionStack.delete(node);
+      path.pop();
+      return false;
+    };
+    for (const node of graph.nodes.keys()) {
+      if (!visited.has(node)) {
+        if (dfs(node)) {
+          return path;
+        }
+      }
+    }
+    return [];
+  }
+  /**
+   * Topological sort to determine load order
+   */
+  topologicalSort(graph) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const result = [];
+    for (const node of graph.nodes.keys()) {
+      inDegree.set(node, 0);
+    }
+    for (const dependencies of graph.edges.values()) {
+      for (const dep of dependencies) {
+        if (graph.nodes.has(dep)) {
+          inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+        }
+      }
+    }
+    const queue = [];
+    for (const [node, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(node);
+      }
+    }
+    while (queue.length > 0) {
+      const current = queue.shift();
+      result.push(current);
+      const dependencies = graph.edges.get(current) || /* @__PURE__ */ new Set();
+      for (const dep of dependencies) {
+        if (!graph.nodes.has(dep)) {
+          continue;
+        }
+        const newDegree = (inDegree.get(dep) || 0) - 1;
+        inDegree.set(dep, newDegree);
+        if (newDegree === 0) {
+          queue.push(dep);
+        }
+      }
+    }
+    if (result.length !== graph.nodes.size) {
+      throw new Error("Circular dependency detected");
+    }
+    return result.reverse();
+  }
+  /**
+   * Get dependency tree for a plugin
+   */
+  getDependencyTree(pluginName) {
+    const metadata = this.plugins.get(pluginName);
+    if (!metadata) {
+      return { dependencies: [], name: pluginName, version: "unknown" };
+    }
+    const tree = {
+      dependencies: [],
+      name: metadata.name,
+      version: metadata.version
+    };
+    if (metadata.dependencies) {
+      for (const dep of metadata.dependencies) {
+        const depTree = this.getDependencyTree(dep.name);
+        tree.dependencies.push(depTree);
+      }
+    }
+    return tree;
+  }
+  /**
+   * Get all dependencies (flat list)
+   */
+  getAllDependencies(pluginName) {
+    const dependencies = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const traverse = (name) => {
+      if (visited.has(name)) {
+        return;
+      }
+      visited.add(name);
+      const metadata = this.plugins.get(name);
+      if (!metadata) {
+        return;
+      }
+      if (metadata.dependencies) {
+        for (const dep of metadata.dependencies) {
+          dependencies.add(dep.name);
+          traverse(dep.name);
+        }
+      }
+      if (metadata.peerDependencies) {
+        for (const peer of metadata.peerDependencies) {
+          dependencies.add(peer.name);
+          traverse(peer.name);
+        }
+      }
+    };
+    traverse(pluginName);
+    return dependencies;
+  }
+  /**
+   * Check if plugin can be safely unloaded
+   */
+  canUnload(pluginName) {
+    const blockedBy = [];
+    for (const [name] of this.plugins.entries()) {
+      if (name === pluginName) {
+        continue;
+      }
+      const deps = this.getAllDependencies(name);
+      if (deps.has(pluginName)) {
+        blockedBy.push(name);
+      }
+    }
+    return {
+      blockedBy,
+      canUnload: blockedBy.length === 0
+    };
+  }
+  /**
+   * Get plugins that depend on a specific plugin
+   */
+  getDependents(pluginName) {
+    const dependents = [];
+    for (const [name] of this.plugins.entries()) {
+      if (name === pluginName) {
+        continue;
+      }
+      const metadata = this.plugins.get(name);
+      if (!metadata) {
+        continue;
+      }
+      if (metadata.dependencies) {
+        const hasDep = metadata.dependencies.some((dep) => dep.name === pluginName);
+        if (hasDep) {
+          dependents.push(name);
+        }
+      }
+      if (metadata.peerDependencies) {
+        const hasPeer = metadata.peerDependencies.some((peer) => peer.name === pluginName);
+        if (hasPeer) {
+          dependents.push(name);
+        }
+      }
+    }
+    return dependents;
+  }
+  /**
+   * Clear all registered plugins
+   */
+  clear() {
+    this.plugins.clear();
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    let totalDeps = 0;
+    let totalPeerDeps = 0;
+    let totalConflicts = 0;
+    for (const metadata of this.plugins.values()) {
+      totalDeps += metadata.dependencies?.length || 0;
+      totalPeerDeps += metadata.peerDependencies?.length || 0;
+      totalConflicts += metadata.conflicts?.length || 0;
+    }
+    return {
+      totalConflicts,
+      totalDependencies: totalDeps,
+      totalPeerDependencies: totalPeerDeps,
+      totalPlugins: this.plugins.size
+    };
+  }
+};
+
+// src/core/plugin-registry.ts
+var PluginRegistry = class {
+  logger;
+  constructor(logger, _registryUrl = "https://registry.npmjs.org") {
+    this.logger = logger;
+  }
+  /**
+   * Search for plugins matching query
+   *
+   * @param query - Search query
+   * @param options - Search options
+   * @returns Array of matching plugins
+   */
+  async search(query, options = {}) {
+    this.logger.debug(`Searching plugins: ${query}`);
+    const mockPlugins = [
+      {
+        author: "Kubit Team",
+        capabilities: ["fs:write", "shell:run"],
+        category: "tooling",
+        description: "Bernova Design System integration for Kubit projects",
+        downloads: 15e3,
+        kubitVersion: "^2.0.0",
+        name: "@kubit/plugin-bernova",
+        tags: ["css", "bernova", "design-system", "styling"],
+        verified: true,
+        version: "1.2.0"
+      },
+      {
+        author: "Kubit Team",
+        capabilities: ["fs:write", "shell:run", "net:localhost"],
+        category: "tooling",
+        description: "Storybook integration with hot reload",
+        downloads: 12e3,
+        kubitVersion: "^2.0.0",
+        name: "@kubit/plugin-storybook",
+        tags: ["storybook", "components", "ui"],
+        verified: true,
+        version: "2.0.1"
+      },
+      {
+        author: "Kubit Team",
+        capabilities: ["fs:read", "fs:write"],
+        category: "utility",
+        description: "Internationalization support with i18next",
+        downloads: 8e3,
+        kubitVersion: "^2.0.0",
+        name: "@kubit/plugin-i18n",
+        tags: ["i18n", "translation", "localization"],
+        verified: true,
+        version: "1.5.0"
+      }
+    ];
+    let results = mockPlugins.filter(
+      (p) => p.name.toLowerCase().includes(query.toLowerCase()) || p.description.toLowerCase().includes(query.toLowerCase()) || p.tags?.some((t) => t.toLowerCase().includes(query.toLowerCase()))
+    );
+    if (options.verified !== void 0) {
+      results = results.filter((p) => p.verified === options.verified);
+    }
+    if (options.category) {
+      results = results.filter((p) => p.category === options.category);
+    }
+    return results;
+  }
+  /**
+   * Get detailed information about a plugin
+   *
+   * @param name - Plugin name
+   * @returns Plugin information or null if not found
+   */
+  async getInfo(name) {
+    this.logger.debug(`Fetching plugin info: ${name}`);
+    const mockPlugin = {
+      author: "Plugin Author",
+      capabilities: ["fs:read"],
+      category: "utility",
+      description: "Plugin description",
+      downloads: 1e3,
+      homepage: `https://github.com/kubit-ui/${name}`,
+      kubitVersion: "^2.0.0",
+      name,
+      repository: `https://github.com/kubit-ui/${name}`,
+      tags: ["utility"],
+      updated: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: false,
+      version: "1.0.0"
+    };
+    return mockPlugin;
+  }
+  /**
+   * Check if a plugin is verified
+   *
+   * @param name - Plugin name
+   * @returns True if verified
+   */
+  async isVerified(name) {
+    const info = await this.getInfo(name);
+    return info?.verified || false;
+  }
+  /**
+   * Get compatible plugins for current kubit-forge version
+   *
+   * @param kubitVersion - Current kubit-forge version
+   * @returns Array of compatible plugins
+   */
+  async getCompatible(_kubitVersion) {
+    return this.search("", {});
+  }
+  /**
+   * Get featured/recommended plugins
+   *
+   * @returns Array of featured plugins
+   */
+  async getFeatured() {
+    return this.search("", { verified: true });
+  }
+};
+
+// src/core/plugin-sandbox.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+var PluginSandbox = class {
+  logger;
+  options;
+  worker;
+  isRunning = false;
+  constructor(logger, options = {}) {
+    this.logger = logger;
+    this.options = {
+      allowedCapabilities: options.allowedCapabilities || [],
+      allowFileSystem: options.allowFileSystem ?? true,
+      allowNetwork: options.allowNetwork ?? false,
+      allowProcessEnv: options.allowProcessEnv ?? true,
+      memoryLimit: options.memoryLimit || 512 * 1024 * 1024,
+      // 512MB
+      timeout: options.timeout || 3e4
+      // 30 seconds
+    };
+  }
+  /**
+   * Execute plugin in sandboxed environment
+   */
+  async execute(pluginPath, method, args) {
+    if (this.isRunning) {
+      throw new Error("Sandbox is already running");
+    }
+    this.isRunning = true;
+    try {
+      if (!existsSync(pluginPath)) {
+        throw new Error(`Plugin not found: ${pluginPath}`);
+      }
+      const sandboxContext = this.createSandboxContext();
+      const result = await this.executeInWorker(pluginPath, method, args, sandboxContext);
+      return result;
+    } finally {
+      this.isRunning = false;
+      this.cleanup();
+    }
+  }
+  /**
+   * Create restricted context for plugin
+   */
+  createSandboxContext() {
+    const context = {
+      console: {
+        error: (...args) => this.logger.error(args.join(" ")),
+        log: (...args) => this.logger.info(args.join(" ")),
+        warn: (...args) => this.logger.warn(args.join(" "))
+      }
+    };
+    if (this.options.allowProcessEnv) {
+      context.process = {
+        arch: process.arch,
+        cwd: process.cwd,
+        env: { ...process.env },
+        platform: process.platform
+      };
+    }
+    if (this.options.allowFileSystem) {
+      context.fs = this.createRestrictedFS();
+    }
+    if (this.options.allowNetwork) {
+      context.fetch = fetch;
+    }
+    return context;
+  }
+  /**
+   * Create restricted filesystem API
+   */
+  createRestrictedFS() {
+    const cwd = process.cwd();
+    return {
+      exists: (path) => {
+        const fullPath = join(cwd, path);
+        if (!fullPath.startsWith(cwd)) {
+          throw new Error("Access denied: Path outside project directory");
+        }
+        return existsSync(fullPath);
+      },
+      mkdir: (path) => {
+        const fullPath = join(cwd, path);
+        if (!fullPath.startsWith(cwd)) {
+          throw new Error("Access denied: Path outside project directory");
+        }
+        return mkdirSync(fullPath, { recursive: true });
+      },
+      readFile: (path) => {
+        const fullPath = join(cwd, path);
+        if (!fullPath.startsWith(cwd)) {
+          throw new Error("Access denied: Path outside project directory");
+        }
+        return readFileSync(fullPath, "utf-8");
+      },
+      writeFile: (path, content) => {
+        const fullPath = join(cwd, path);
+        if (!fullPath.startsWith(cwd)) {
+          throw new Error("Access denied: Path outside project directory");
+        }
+        return writeFileSync(fullPath, content, "utf-8");
+      }
+    };
+  }
+  /**
+   * Execute plugin method in worker thread
+   */
+  async executeInWorker(pluginPath, method, args, _context) {
+    const timeout = setTimeout(() => {
+      if (this.worker) {
+        this.worker.terminate();
+      }
+    }, this.options.timeout);
+    try {
+      const pluginModule = await import(pluginPath);
+      const plugin = pluginModule.default || pluginModule;
+      const pluginInstance = plugin.default || plugin;
+      if (!pluginInstance[method]) {
+        clearTimeout(timeout);
+        throw new Error(`Method '${method}' not found in plugin`);
+      }
+      const result = pluginInstance[method](...args);
+      if (result instanceof Promise) {
+        return result.then((res) => {
+          clearTimeout(timeout);
+          return res;
+        }).catch((err) => {
+          clearTimeout(timeout);
+          throw err;
+        });
+      }
+      clearTimeout(timeout);
+      return result;
+    } catch (error) {
+      clearTimeout(timeout);
+      throw error;
+    }
+  }
+  /**
+   * Check if capability is allowed
+   */
+  hasCapability(capability) {
+    return this.options.allowedCapabilities.includes(capability);
+  }
+  /**
+   * Get sandbox statistics
+   */
+  getStats() {
+    return {
+      allowedCapabilities: this.options.allowedCapabilities,
+      allowFileSystem: this.options.allowFileSystem,
+      allowNetwork: this.options.allowNetwork,
+      isRunning: this.isRunning,
+      memoryLimit: this.options.memoryLimit,
+      timeout: this.options.timeout
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = void 0;
+    }
+  }
+  /**
+   * Terminate sandbox
+   */
+  terminate() {
+    this.cleanup();
+    this.isRunning = false;
+  }
+};
+var SandboxManager = class {
+  sandboxes = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Create sandbox for plugin
+   */
+  createSandbox(pluginName, options = {}) {
+    if (this.sandboxes.has(pluginName)) {
+      throw new Error(`Sandbox already exists for plugin '${pluginName}'`);
+    }
+    const sandbox = new PluginSandbox(this.logger, options);
+    this.sandboxes.set(pluginName, sandbox);
+    this.logger.debug(`Created sandbox for plugin '${pluginName}'`);
+    return sandbox;
+  }
+  /**
+   * Get sandbox for plugin
+   */
+  getSandbox(pluginName) {
+    return this.sandboxes.get(pluginName);
+  }
+  /**
+   * Remove sandbox
+   */
+  removeSandbox(pluginName) {
+    const sandbox = this.sandboxes.get(pluginName);
+    if (sandbox) {
+      sandbox.terminate();
+      this.sandboxes.delete(pluginName);
+      this.logger.debug(`Removed sandbox for plugin '${pluginName}'`);
+    }
+  }
+  /**
+   * Terminate all sandboxes
+   */
+  terminateAll() {
+    for (const [pluginName, sandbox] of this.sandboxes.entries()) {
+      sandbox.terminate();
+      this.logger.debug(`Terminated sandbox for plugin '${pluginName}'`);
+    }
+    this.sandboxes.clear();
+  }
+  /**
+   * Get statistics for all sandboxes
+   */
+  getStats() {
+    const stats = {};
+    for (const [pluginName, sandbox] of this.sandboxes.entries()) {
+      stats[pluginName] = sandbox.getStats();
+    }
+    return {
+      sandboxes: stats,
+      totalSandboxes: this.sandboxes.size
+    };
+  }
+};
+
+// src/core/plugin-validator.ts
+var PluginValidator = class {
+  /**
+   * Validate a plugin
+   */
+  validate(plugin) {
+    const errors = [];
+    const warnings = [];
+    const securityIssues = [];
+    if (!plugin.name) {
+      errors.push("Plugin must have a name");
+    } else {
+      if (!/^[@a-z0-9-]+\/[a-z0-9-]+$|^[a-z0-9-]+$/.test(plugin.name)) {
+        errors.push(
+          'Plugin name must be in format "name" or "@scope/name" with lowercase letters, numbers, and hyphens'
+        );
+      }
+    }
+    if (!plugin.version) {
+      errors.push("Plugin must have a version");
+    } else {
+      if (!/^\d+\.\d+\.\d+(-[a-z0-9.-]+)?(\+[a-z0-9.-]+)?$/i.test(plugin.version)) {
+        errors.push("Plugin version must follow semver format (e.g., 1.0.0)");
+      }
+    }
+    if (plugin.capabilities) {
+      const validCapabilities = [
+        "fs:read",
+        "fs:write",
+        "shell:run",
+        "net:localhost",
+        "process:env"
+      ];
+      for (const cap of plugin.capabilities) {
+        if (!validCapabilities.includes(cap)) {
+          errors.push(`Invalid capability: ${cap}`);
+        }
+        if (cap === "fs:write") {
+          securityIssues.push("Plugin requests file system write access");
+        }
+        if (cap === "shell:run") {
+          securityIssues.push("Plugin requests shell command execution");
+        }
+        if (cap === "process:env") {
+          warnings.push("Plugin requests access to environment variables");
+        }
+      }
+    }
+    const validHooks = [
+      "onLoad",
+      "onConfigLoaded",
+      "onProjectDetected",
+      "beforeCommand",
+      "afterCommand",
+      "beforeTask",
+      "afterTask"
+    ];
+    for (const hook of validHooks) {
+      if (hook in plugin && typeof plugin[hook] !== "function") {
+        errors.push(`Hook '${hook}' must be a function`);
+      }
+    }
+    const validRegistrations = [
+      "registerCommands",
+      "registerTasks",
+      "registerGenerators",
+      "registerProviders"
+    ];
+    for (const method of validRegistrations) {
+      if (method in plugin && typeof plugin[method] !== "function") {
+        errors.push(`Registration method '${method}' must be a function`);
+      }
+    }
+    if (!plugin.capabilities || plugin.capabilities.length === 0) {
+      warnings.push("Plugin does not declare any capabilities");
+    }
+    return {
+      errors,
+      securityIssues,
+      valid: errors.length === 0,
+      warnings
+    };
+  }
+  /**
+   * Check if plugin requires user approval based on capabilities
+   */
+  requiresApproval(plugin) {
+    if (!plugin.capabilities) {
+      return false;
+    }
+    const dangerousCapabilities = ["fs:write", "shell:run"];
+    return plugin.capabilities.some((cap) => dangerousCapabilities.includes(cap));
+  }
+  /**
+   * Get security level of plugin
+   */
+  getSecurityLevel(plugin) {
+    if (!plugin.capabilities || plugin.capabilities.length === 0) {
+      return "safe";
+    }
+    const dangerousCapabilities = ["fs:write", "shell:run"];
+    const hasDangerous = plugin.capabilities.some((cap) => dangerousCapabilities.includes(cap));
+    if (hasDangerous) {
+      return "dangerous";
+    }
+    const moderateCapabilities = ["process:env", "net:localhost"];
+    const hasModerate = plugin.capabilities.some((cap) => moderateCapabilities.includes(cap));
+    if (hasModerate) {
+      return "moderate";
+    }
+    return "safe";
+  }
+  /**
+   * Validate command registration
+   */
+  validateCommand(command) {
+    const errors = [];
+    if (!command.name || typeof command.name !== "string") {
+      errors.push("Command must have a name (string)");
+    }
+    if (!command.description || typeof command.description !== "string") {
+      errors.push("Command must have a description (string)");
+    }
+    if (!command.action || typeof command.action !== "function") {
+      errors.push("Command must have an action (function)");
+    }
+    if (command.options && !Array.isArray(command.options)) {
+      errors.push("Command options must be an array");
+    }
+    return {
+      errors,
+      valid: errors.length === 0
+    };
+  }
+  /**
+   * Validate task registration
+   */
+  validateTask(task) {
+    const errors = [];
+    if (!task.name || typeof task.name !== "string") {
+      errors.push("Task must have a name (string)");
+    }
+    if (!task.description || typeof task.description !== "string") {
+      errors.push("Task must have a description (string)");
+    }
+    if (!task.run || typeof task.run !== "function") {
+      errors.push("Task must have a run function");
+    }
+    return {
+      errors,
+      valid: errors.length === 0
+    };
+  }
+  /**
+   * Validate generator registration
+   */
+  validateGenerator(generator) {
+    const errors = [];
+    if (!generator.kind || typeof generator.kind !== "string") {
+      errors.push("Generator must have a kind (string)");
+    }
+    if (!generator.description || typeof generator.description !== "string") {
+      errors.push("Generator must have a description (string)");
+    }
+    if (!generator.generate || typeof generator.generate !== "function") {
+      errors.push("Generator must have a generate function");
+    }
+    return {
+      errors,
+      valid: errors.length === 0
+    };
+  }
+  /**
+   * Validate provider registration
+   */
+  validateProvider(provider) {
+    const errors = [];
+    if (!provider.command || typeof provider.command !== "string") {
+      errors.push("Provider must have a command (string)");
+    }
+    if (typeof provider.priority !== "number") {
+      errors.push("Provider must have a priority (number)");
+    }
+    if (!provider.canHandle || typeof provider.canHandle !== "function") {
+      errors.push("Provider must have a canHandle function");
+    }
+    if (!provider.handler || typeof provider.handler !== "function") {
+      errors.push("Provider must have a handler function");
+    }
+    return {
+      errors,
+      valid: errors.length === 0
+    };
+  }
+};
+
+// src/core/plugin-version-manager.ts
+import { satisfies, valid, coerce, gt, lt, eq } from "semver";
+var PluginVersionManager = class {
+  logger;
+  installedVersions = /* @__PURE__ */ new Map();
+  requiredVersions = /* @__PURE__ */ new Map();
+  latestVersions = /* @__PURE__ */ new Map();
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Register installed plugin version
+   */
+  registerInstalled(pluginName, version) {
+    const normalized = this.normalizeVersion(version);
+    if (!normalized) {
+      this.logger.warn(`Invalid version for plugin '${pluginName}': ${version}`);
+      return;
+    }
+    this.installedVersions.set(pluginName, normalized);
+    this.logger.debug(`Registered plugin '${pluginName}' version ${normalized}`);
+  }
+  /**
+   * Set required version for plugin
+   */
+  setRequired(pluginName, versionRange) {
+    this.requiredVersions.set(pluginName, versionRange);
+    this.logger.debug(`Set required version for '${pluginName}': ${versionRange}`);
+  }
+  /**
+   * Set latest available version
+   */
+  setLatest(pluginName, version) {
+    const normalized = this.normalizeVersion(version);
+    if (normalized) {
+      this.latestVersions.set(pluginName, normalized);
+    }
+  }
+  /**
+   * Check if plugin version satisfies requirement
+   */
+  satisfies(pluginName, versionRange) {
+    const installed = this.installedVersions.get(pluginName);
+    if (!installed) {
+      return false;
+    }
+    try {
+      return satisfies(installed, versionRange);
+    } catch {
+      this.logger.warn(`Invalid version range for '${pluginName}': ${versionRange}`);
+      return false;
+    }
+  }
+  /**
+   * Check compatibility of plugin
+   */
+  checkCompatibility(pluginName) {
+    const issues = [];
+    const warnings = [];
+    const recommendations = [];
+    const installed = this.installedVersions.get(pluginName);
+    const required = this.requiredVersions.get(pluginName);
+    const latest = this.latestVersions.get(pluginName);
+    if (!installed) {
+      issues.push(`Plugin '${pluginName}' is not installed`);
+      return { compatible: false, issues, recommendations, warnings };
+    }
+    if (required && !this.satisfies(pluginName, required)) {
+      issues.push(
+        `Plugin '${pluginName}' version ${installed} does not satisfy requirement ${required}`
+      );
+    }
+    if (latest && gt(latest, installed)) {
+      warnings.push(`Plugin '${pluginName}' has an update available: ${installed} \u2192 ${latest}`);
+      recommendations.push(`Run: kubit-forge plugin:update ${pluginName}`);
+    }
+    if (latest) {
+      const installedMajor = parseInt(installed.split(".")[0], 10);
+      const latestMajor = parseInt(latest.split(".")[0], 10);
+      if (latestMajor > installedMajor + 1) {
+        warnings.push(
+          `Plugin '${pluginName}' is ${latestMajor - installedMajor} major versions behind`
+        );
+        recommendations.push(`Consider upgrading to version ${latest}`);
+      }
+    }
+    return {
+      compatible: issues.length === 0,
+      issues,
+      recommendations,
+      warnings
+    };
+  }
+  /**
+   * Get plugin version info
+   */
+  getVersionInfo(pluginName) {
+    const installed = this.installedVersions.get(pluginName);
+    const required = this.requiredVersions.get(pluginName);
+    const latest = this.latestVersions.get(pluginName);
+    const compatible = required ? this.satisfies(pluginName, required) : true;
+    const updateAvailable = installed && latest ? gt(latest, installed) : false;
+    return {
+      compatible,
+      installedVersion: installed,
+      latestVersion: latest,
+      name: pluginName,
+      requiredVersion: required,
+      updateAvailable,
+      version: installed || "not-installed"
+    };
+  }
+  /**
+   * Get all plugin versions
+   */
+  getAllVersions() {
+    const allPlugins = /* @__PURE__ */ new Set([
+      ...this.installedVersions.keys(),
+      ...this.requiredVersions.keys(),
+      ...this.latestVersions.keys()
+    ]);
+    return Array.from(allPlugins).map((plugin) => this.getVersionInfo(plugin));
+  }
+  /**
+   * Check if update is available
+   */
+  hasUpdate(pluginName) {
+    const installed = this.installedVersions.get(pluginName);
+    const latest = this.latestVersions.get(pluginName);
+    if (!installed || !latest) {
+      return false;
+    }
+    return gt(latest, installed);
+  }
+  /**
+   * Get plugins with updates available
+   */
+  getUpdatablePlugins() {
+    return this.getAllVersions().filter((p) => p.updateAvailable);
+  }
+  /**
+   * Get incompatible plugins
+   */
+  getIncompatiblePlugins() {
+    return this.getAllVersions().filter((p) => !p.compatible);
+  }
+  /**
+   * Resolve version conflicts
+   */
+  resolveConflicts(constraints) {
+    const resolved = /* @__PURE__ */ new Map();
+    const conflicts = [];
+    const byPlugin = /* @__PURE__ */ new Map();
+    for (const constraint of constraints) {
+      if (!byPlugin.has(constraint.plugin)) {
+        byPlugin.set(constraint.plugin, []);
+      }
+      byPlugin.get(constraint.plugin).push(constraint);
+    }
+    for (const [plugin, pluginConstraints] of byPlugin.entries()) {
+      if (pluginConstraints.length === 1) {
+        resolved.set(plugin, pluginConstraints[0].version);
+        continue;
+      }
+      const versions = pluginConstraints.map((c) => c.version);
+      const compatible = this.findCompatibleVersion(versions);
+      if (compatible) {
+        resolved.set(plugin, compatible);
+      } else {
+        conflicts.push(
+          `Cannot resolve version for '${plugin}': ${versions.join(", ")} are incompatible`
+        );
+      }
+    }
+    return { conflicts, resolved };
+  }
+  /**
+   * Find compatible version from multiple constraints
+   */
+  findCompatibleVersion(versionRanges) {
+    const candidates = [];
+    for (const range of versionRanges) {
+      const normalized = this.normalizeVersion(range);
+      if (normalized && candidates.length === 0) {
+        candidates.push(normalized);
+      }
+    }
+    for (const candidate of candidates) {
+      const satisfiesAll = versionRanges.every((range) => {
+        try {
+          return satisfies(candidate, range);
+        } catch {
+          return false;
+        }
+      });
+      if (satisfiesAll) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  /**
+   * Normalize version string
+   */
+  normalizeVersion(version) {
+    if (valid(version)) {
+      return version;
+    }
+    const coerced = coerce(version);
+    if (coerced) {
+      return coerced.version;
+    }
+    return null;
+  }
+  /**
+   * Compare two versions
+   */
+  compare(version1, version2) {
+    const v1 = this.normalizeVersion(version1);
+    const v2 = this.normalizeVersion(version2);
+    if (!v1 || !v2) {
+      return 0;
+    }
+    if (gt(v1, v2)) {
+      return 1;
+    }
+    if (lt(v1, v2)) {
+      return -1;
+    }
+    return 0;
+  }
+  /**
+   * Check if version is equal
+   */
+  isEqual(version1, version2) {
+    const v1 = this.normalizeVersion(version1);
+    const v2 = this.normalizeVersion(version2);
+    if (!v1 || !v2) {
+      return false;
+    }
+    return eq(v1, v2);
+  }
+  /**
+   * Get version statistics
+   */
+  getStats() {
+    const all = this.getAllVersions();
+    return {
+      compatible: all.filter((p) => p.compatible).length,
+      incompatible: all.filter((p) => !p.compatible).length,
+      installed: all.filter((p) => p.installedVersion).length,
+      totalPlugins: all.length,
+      updatable: all.filter((p) => p.updateAvailable).length
+    };
+  }
+  /**
+   * Clear all version data
+   */
+  clear() {
+    this.installedVersions.clear();
+    this.requiredVersions.clear();
+    this.latestVersions.clear();
+  }
+};
+
+// src/core/plugin-manager.ts
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  commands = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  generators = /* @__PURE__ */ new Map();
+  providers = /* @__PURE__ */ new Map();
+  logger;
+  cwd;
+  validator;
+  registry;
+  sandboxManager;
+  versionManager;
+  dependencyResolver;
+  constructor(logger, cwd) {
+    this.logger = logger;
+    this.cwd = cwd;
+    this.validator = new PluginValidator();
+    this.registry = new PluginRegistry(logger);
+    this.sandboxManager = new SandboxManager(logger);
+    this.versionManager = new PluginVersionManager(logger);
+    this.dependencyResolver = new PluginDependencyResolver(logger);
+  }
+  /**
+   * Load plugins from config or auto-detect
+   */
+  async loadPlugins(pluginNames, ctx, options = {}) {
+    if (options.checkDependencies !== false) {
+      const resolution = this.dependencyResolver.resolve(pluginNames);
+      if (resolution.errors.length > 0) {
+        this.logger.error("Plugin dependency resolution failed:");
+        resolution.errors.forEach((err) => this.logger.error(`  - ${err}`));
+        throw new Error("Cannot load plugins due to dependency errors");
+      }
+      if (resolution.warnings.length > 0) {
+        resolution.warnings.forEach((warn) => this.logger.warn(warn));
+      }
+      pluginNames = resolution.loadOrder;
+      this.logger.debug(`Plugin load order: ${pluginNames.join(" -> ")}`);
+    }
+    for (const pluginName of pluginNames) {
+      try {
+        await this.loadPlugin(pluginName, ctx, options);
+      } catch (error) {
+        this.logger.warn(
+          `Failed to load plugin '${pluginName}': ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  }
+  /**
+   * Load a single plugin
+   */
+  async loadPlugin(pluginName, ctx, options = {}) {
+    let pluginModule;
+    try {
+      const pluginPath = join2(this.cwd, "node_modules", pluginName);
+      if (existsSync2(pluginPath)) {
+        pluginModule = await import(pluginPath);
+      } else {
+        pluginModule = await import(pluginName);
+      }
+    } catch {
+      throw new Error(`Cannot resolve plugin '${pluginName}'`);
+    }
+    const plugin = pluginModule.default || pluginModule;
+    if (!plugin.name || !plugin.version) {
+      throw new Error(`Invalid plugin '${pluginName}': missing name or version`);
+    }
+    this.versionManager.registerInstalled(plugin.name, plugin.version);
+    const versionCheck = this.versionManager.checkCompatibility(plugin.name);
+    if (!versionCheck.compatible) {
+      this.logger.error(`Plugin '${plugin.name}' version compatibility check failed:`);
+      versionCheck.issues.forEach((issue) => this.logger.error(`  - ${issue}`));
+      throw new Error(`Plugin '${plugin.name}' is not compatible`);
+    }
+    if (versionCheck.warnings.length > 0) {
+      versionCheck.warnings.forEach((warn) => this.logger.warn(warn));
+    }
+    if (options.validate !== false) {
+      const validation = this.validator.validate(plugin);
+      if (!validation.valid) {
+        throw new Error(
+          `Plugin '${plugin.name}' validation failed:
+${validation.errors.join("\n")}`
+        );
+      }
+      if (validation.warnings.length > 0) {
+        for (const warning of validation.warnings) {
+          this.logger.warn(`Plugin '${plugin.name}': ${warning}`);
+        }
+      }
+      if (!options.skipSecurityCheck && validation.securityIssues.length > 0) {
+        this.logger.warn(`
+Security notice for plugin '${plugin.name}':`);
+        for (const issue of validation.securityIssues) {
+          this.logger.warn(`  - ${issue}`);
+        }
+        const securityLevel = this.validator.getSecurityLevel(plugin);
+        if (securityLevel === "dangerous") {
+          this.logger.warn(
+            "\nThis plugin requires dangerous permissions. Only install if you trust the source."
+          );
+        }
+      }
+    }
+    this.plugins.set(plugin.name, plugin);
+    if (plugin.onLoad) {
+      await plugin.onLoad(ctx);
+    }
+    if (plugin.registerCommands) {
+      const commands = plugin.registerCommands();
+      for (const cmd of commands) {
+        this.commands.set(cmd.name, cmd);
+        this.logger.debug(`Registered command '${cmd.name}' from plugin '${plugin.name}'`);
+      }
+    }
+    if (plugin.registerTasks) {
+      const tasks = plugin.registerTasks();
+      for (const task of tasks) {
+        this.tasks.set(task.name, task);
+        this.logger.debug(`Registered task '${task.name}' from plugin '${plugin.name}'`);
+      }
+    }
+    if (plugin.registerGenerators) {
+      const generators = plugin.registerGenerators();
+      for (const gen of generators) {
+        this.generators.set(gen.kind, gen);
+        this.logger.debug(`Registered generator '${gen.kind}' from plugin '${plugin.name}'`);
+      }
+    }
+    if (plugin.registerProviders) {
+      const providers = plugin.registerProviders();
+      for (const provider of providers) {
+        if (!this.providers.has(provider.command)) {
+          this.providers.set(provider.command, []);
+        }
+        this.providers.get(provider.command).push(provider);
+        this.logger.debug(
+          `Registered provider for '${provider.command}' from plugin '${plugin.name}'`
+        );
+      }
+    }
+    this.logger.debug(`Loaded plugin '${plugin.name}' v${plugin.version}`);
+  }
+  /**
+   * Get all loaded plugins
+   */
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Get command by name
+   */
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  /**
+   * Get all commands
+   */
+  getCommands() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get task by name
+   */
+  getTask(name) {
+    return this.tasks.get(name);
+  }
+  /**
+   * Get all tasks
+   */
+  getTasks() {
+    return Array.from(this.tasks.values());
+  }
+  /**
+   * Get generator by kind
+   */
+  getGenerator(kind) {
+    return this.generators.get(kind);
+  }
+  /**
+   * Get all generators
+   */
+  getGenerators() {
+    return Array.from(this.generators.values());
+  }
+  /**
+   * Get best provider for a command
+   */
+  getProvider(command, ctx) {
+    const providers = this.providers.get(command) || [];
+    const capable = providers.filter((p) => p.canHandle(ctx));
+    if (capable.length === 0) {
+      return void 0;
+    }
+    capable.sort((a, b) => b.priority - a.priority);
+    return capable[0];
+  }
+  /**
+   * Call beforeCommand hooks
+   */
+  async callBeforeCommand(command, ctx) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.beforeCommand) {
+        await plugin.beforeCommand(command, ctx);
+      }
+    }
+  }
+  /**
+   * Call afterCommand hooks
+   */
+  async callAfterCommand(command, ctx, result) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.afterCommand) {
+        await plugin.afterCommand(command, ctx, result);
+      }
+    }
+  }
+  /**
+   * Call beforeTask hooks
+   */
+  async callBeforeTask(task, ctx) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.beforeTask) {
+        await plugin.beforeTask(task, ctx);
+      }
+    }
+  }
+  /**
+   * Call afterTask hooks
+   */
+  async callAfterTask(task, ctx, result) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.afterTask) {
+        await plugin.afterTask(task, ctx, result);
+      }
+    }
+  }
+  /**
+   * Search for plugins in registry
+   */
+  async searchPlugins(query, options) {
+    return this.registry.search(query, options);
+  }
+  /**
+   * Get plugin info from registry
+   */
+  async getPluginInfo(name) {
+    return this.registry.getInfo(name);
+  }
+  /**
+   * Get featured plugins
+   */
+  async getFeaturedPlugins() {
+    return this.registry.getFeatured();
+  }
+  /**
+   * Check if plugin is loaded
+   */
+  isLoaded(pluginName) {
+    return this.plugins.has(pluginName);
+  }
+  /**
+   * Get loaded plugin by name
+   */
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  /**
+   * Unload a plugin
+   */
+  async unloadPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      return;
+    }
+    if (plugin.registerCommands) {
+      const commands = plugin.registerCommands();
+      for (const cmd of commands) {
+        this.commands.delete(cmd.name);
+      }
+    }
+    if (plugin.registerTasks) {
+      const tasks = plugin.registerTasks();
+      for (const task of tasks) {
+        this.tasks.delete(task.name);
+      }
+    }
+    if (plugin.registerGenerators) {
+      const generators = plugin.registerGenerators();
+      for (const gen of generators) {
+        this.generators.delete(gen.kind);
+      }
+    }
+    if (plugin.registerProviders) {
+      const providers = plugin.registerProviders();
+      for (const provider of providers) {
+        const list = this.providers.get(provider.command);
+        if (list) {
+          const index = list.indexOf(provider);
+          if (index !== -1) {
+            list.splice(index, 1);
+          }
+        }
+      }
+    }
+    this.plugins.delete(pluginName);
+    this.logger.debug(`Unloaded plugin '${pluginName}'`);
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    return {
+      commands: this.commands.size,
+      dependencies: this.dependencyResolver.getStats(),
+      generators: this.generators.size,
+      plugins: this.plugins.size,
+      providers: Array.from(this.providers.values()).reduce((sum, list) => sum + list.length, 0),
+      tasks: this.tasks.size,
+      versions: this.versionManager.getStats()
+    };
+  }
+  /**
+   * Get version manager
+   */
+  getVersionManager() {
+    return this.versionManager;
+  }
+  /**
+   * Get dependency resolver
+   */
+  getDependencyResolver() {
+    return this.dependencyResolver;
+  }
+  /**
+   * Get sandbox manager
+   */
+  getSandboxManager() {
+    return this.sandboxManager;
+  }
+  /**
+   * Register plugin metadata for dependency resolution
+   */
+  registerPluginMetadata(metadata) {
+    this.dependencyResolver.register(metadata);
+  }
+  /**
+   * Check plugin updates
+   */
+  async checkUpdates() {
+    const updates = [];
+    for (const plugin of this.plugins.values()) {
+      try {
+        const info = await this.registry.getInfo(plugin.name);
+        if (info && info.version) {
+          this.versionManager.setLatest(plugin.name, info.version);
+          if (this.versionManager.hasUpdate(plugin.name)) {
+            updates.push({
+              current: plugin.version,
+              latest: info.version,
+              name: plugin.name
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return updates;
+  }
+};
+
+// src/types/index.ts
+import { z } from "zod";
+var KubitConfigSchema = z.object({
+  commands: z.object({
+    buildProvider: z.string().optional(),
+    devProvider: z.string().optional()
+  }).optional(),
+  env: z.object({
+    required: z.array(z.string()).optional(),
+    schema: z.string().optional()
+  }).optional(),
+  kubit: z.object({
+    cliVersion: z.string().optional()
+  }).optional(),
+  paths: z.object({
+    dist: z.string().default("dist"),
+    envExample: z.string().default(".env.example"),
+    envLocal: z.string().default(".env.local"),
+    src: z.string().default("src")
+  }).optional(),
+  plugins: z.object({
+    enabled: z.array(z.string()).optional()
+  }).optional(),
+  project: z.object({
+    devPort: z.number().default(5173),
+    language: z.enum(["ts", "js"]).default("ts"),
+    name: z.string(),
+    nodeVersion: z.string().default("20"),
+    packageManager: z.enum(["pnpm", "npm", "yarn"]).default("pnpm"),
+    stack: z.enum(["react", "vanilla"]),
+    type: z.enum(["web", "library"]).default("web")
+  }),
+  quality: z.object({
+    format: z.boolean().default(true),
+    lint: z.boolean().default(true),
+    typecheck: z.boolean().default(true),
+    unitTest: z.boolean().default(true)
+  }).optional()
+});
+
+// src/utils/config-loader.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { parse as parseToml } from "smol-toml";
+
+// src/templates/config/defaults.ts
+var PROJECT_DEFAULTS = {
+  nodeVersion: "20",
+  devPort: 5173,
+  packageManager: "pnpm"
+};
+var PATHS_DEFAULTS = {
+  src: "src",
+  dist: "dist",
+  envExample: ".env.example",
+  envLocal: ".env.local"
+};
+var QUALITY_DEFAULTS = {
+  lint: true,
+  format: true,
+  typecheck: true,
+  unitTest: true
+};
+var QUALITY_MINIMAL = {
+  lint: false,
+  format: false,
+  typecheck: false,
+  unitTest: false
+};
+var PLUGIN_DEFAULTS = {
+  enabled: []
+};
+
+// src/templates/config/config-templates.ts
+var ConfigTemplateLoader = class {
+  /**
+   * Build a complete default configuration
+   */
+  static buildDefault(options = {}) {
+    return {
+      kubit: {
+        cliVersion: "^4.0.0"
+      },
+      project: this.buildProjectConfig(options),
+      paths: this.buildPathsConfig(),
+      quality: this.buildQualityConfig(options),
+      plugins: this.buildPluginsConfig()
+    };
+  }
+  /**
+   * Build project configuration with defaults
+   */
+  static buildProjectConfig(options = {}) {
+    return {
+      name: options.name || "my-project",
+      type: options.type || "web",
+      stack: options.stack || "vanilla",
+      language: options.language || "js",
+      packageManager: options.packageManager || PROJECT_DEFAULTS.packageManager,
+      nodeVersion: options.nodeVersion || PROJECT_DEFAULTS.nodeVersion,
+      devPort: options.devPort || PROJECT_DEFAULTS.devPort
+    };
+  }
+  /**
+   * Build paths configuration with defaults
+   */
+  static buildPathsConfig(overrides) {
+    return {
+      ...PATHS_DEFAULTS,
+      ...overrides
+    };
+  }
+  /**
+   * Build quality configuration with defaults
+   */
+  static buildQualityConfig(options = {}) {
+    const baseDefaults = options.minimal ? QUALITY_MINIMAL : QUALITY_DEFAULTS;
+    return {
+      ...baseDefaults,
+      // Auto-adjust typecheck based on language
+      typecheck: options.language === "ts" ? baseDefaults.typecheck : false
+    };
+  }
+  /**
+   * Build plugins configuration with defaults
+   */
+  static buildPluginsConfig(plugins) {
+    return {
+      enabled: plugins || PLUGIN_DEFAULTS.enabled
+    };
+  }
+  /**
+   * Get project defaults
+   */
+  static getProjectDefaults() {
+    return { ...PROJECT_DEFAULTS };
+  }
+  /**
+   * Get paths defaults
+   */
+  static getPathsDefaults() {
+    return { ...PATHS_DEFAULTS };
+  }
+  /**
+   * Get quality defaults
+   */
+  static getQualityDefaults(minimal = false) {
+    return minimal ? { ...QUALITY_MINIMAL } : { ...QUALITY_DEFAULTS };
+  }
+  /**
+   * Get plugin defaults
+   */
+  static getPluginDefaults() {
+    return { ...PLUGIN_DEFAULTS };
+  }
+  /**
+   * Merge partial config with defaults
+   */
+  static mergeWithDefaults(partial, options = {}) {
+    const defaults = this.buildDefault(options);
+    return {
+      kubit: partial.kubit || defaults.kubit,
+      project: { ...defaults.project, ...partial.project || {} },
+      paths: { ...defaults.paths, ...partial.paths || {} },
+      quality: { ...defaults.quality, ...partial.quality || {} },
+      plugins: { ...defaults.plugins, ...partial.plugins || {} }
+    };
+  }
+};
+
+// src/utils/config-loader.ts
+var ConfigLoader = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Load kubit config from project
+   * Supports: kubit.config.toml, kubit.config.json
+   */
+  async load(configPath) {
+    const configFile = configPath ? join3(this.cwd, configPath) : this.findConfigFile();
+    if (!configFile) {
+      return null;
+    }
+    try {
+      const content = readFileSync2(configFile, "utf-8");
+      let rawConfig;
+      if (configFile.endsWith(".toml")) {
+        rawConfig = parseToml(content);
+      } else if (configFile.endsWith(".json")) {
+        rawConfig = JSON.parse(content);
+      } else {
+        throw new Error(`Unsupported config format: ${configFile}`);
+      }
+      const config = KubitConfigSchema.parse(rawConfig);
+      return config;
+    } catch (error) {
+      throw new Error(
+        `Failed to load config from ${configFile}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Auto-detect project configuration when no config file exists
+   */
+  async autoDetect() {
+    const packageJsonPath = join3(this.cwd, "package.json");
+    if (!existsSync3(packageJsonPath)) {
+      const projectName = this.cwd.split("/").pop() || "my-project";
+      return ConfigTemplateLoader.buildDefault({
+        minimal: true,
+        name: projectName
+      });
+    }
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    let stack = "vanilla";
+    if (deps.react) {
+      stack = "react";
+    }
+    const language = existsSync3(join3(this.cwd, "tsconfig.json")) ? "ts" : "js";
+    let packageManager = "npm";
+    if (existsSync3(join3(this.cwd, "pnpm-lock.yaml"))) {
+      packageManager = "pnpm";
+    } else if (existsSync3(join3(this.cwd, "yarn.lock"))) {
+      packageManager = "yarn";
+    } else if (existsSync3(join3(this.cwd, "package-lock.json"))) {
+      packageManager = "npm";
+    }
+    const config = ConfigTemplateLoader.buildDefault({
+      language,
+      name: packageJson.name || "my-app",
+      packageManager,
+      stack,
+      type: "web"
+    });
+    config.quality = {
+      ...config.quality,
+      format: true,
+      lint: true,
+      typecheck: language === "ts",
+      unitTest: !!deps.vitest || !!deps.jest
+    };
+    return config;
+  }
+  findConfigFile() {
+    const candidates = ["kubit.config.toml", "kubit.config.json"];
+    for (const candidate of candidates) {
+      const path = join3(this.cwd, candidate);
+      if (existsSync3(path)) {
+        return path;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/logger.ts
+import chalk2 from "chalk";
+
+// src/utils/theme.ts
+import chalk from "chalk";
+var colors = {
+  bold: chalk.bold,
+  boolean: chalk.hex("#06b6d4"),
+  // Cyan
+  code: chalk.hex("#e879f9"),
+  dim: chalk.dim,
+  error: chalk.hex("#ef4444"),
+  // Red
+  info: chalk.hex("#3b82f6"),
+  // Blue
+  keyword: chalk.hex("#a855f7"),
+  // Purple
+  // Special
+  link: chalk.hex("#3b82f6").underline,
+  // UI colors
+  muted: chalk.hex("#6b7280"),
+  // Gray
+  number: chalk.hex("#f97316"),
+  // Orange
+  // Primary brand colors
+  primary: chalk.hex("#6366f1"),
+  // Indigo - main brand color
+  secondary: chalk.hex("#8b5cf6"),
+  // Purple - accent color
+  // Syntax highlighting
+  string: chalk.hex("#22c55e"),
+  // Green
+  // Semantic colors
+  success: chalk.hex("#10b981"),
+  // Green
+  warning: chalk.hex("#f59e0b")
+  // Amber
+};
+var symbols = {
+  bullet: "\u2022",
+  ellipsis: "...",
+  error: "\u2717",
+  info: "i",
+  line: "\u2500",
+  pointer: "\u203A",
+  step: "\u2192",
+  success: "\u2713",
+  warning: "!"
+};
+
+// src/utils/logger.ts
+var ConsoleLogger = class {
+  useColor;
+  isVerbose;
+  isQuiet;
+  useJson;
+  constructor(options = {}) {
+    this.useColor = !options.noColor;
+    this.isVerbose = options.verbose || false;
+    this.isQuiet = options.quiet || false;
+    this.useJson = options.json || false;
+  }
+  info(message) {
+    if (this.isQuiet) {
+      return;
+    }
+    if (this.useJson) {
+      console.log(JSON.stringify({ level: "info", message }));
+      return;
+    }
+    console.log(this.useColor ? colors.info(symbols.info) : "i", message);
+  }
+  success(message) {
+    if (this.isQuiet) {
+      return;
+    }
+    if (this.useJson) {
+      console.log(JSON.stringify({ level: "success", message }));
+      return;
+    }
+    console.log(this.useColor ? colors.success(symbols.success) : symbols.success, message);
+  }
+  warn(message) {
+    if (this.useJson) {
+      console.log(JSON.stringify({ level: "warning", message }));
+      return;
+    }
+    console.warn(this.useColor ? colors.warning(symbols.warning) : symbols.warning, message);
+  }
+  error(message, error) {
+    if (this.useJson) {
+      console.log(
+        JSON.stringify({
+          error: error?.message,
+          level: "error",
+          message,
+          stack: error?.stack
+        })
+      );
+      return;
+    }
+    console.error(this.useColor ? colors.error(symbols.error) : symbols.error, message);
+    if (error && this.isVerbose) {
+      console.error(chalk2.gray(error.stack || error.message));
+    }
+  }
+  debug(message) {
+    if (!this.isVerbose) {
+      return;
+    }
+    if (this.useJson) {
+      console.log(JSON.stringify({ level: "debug", message }));
+      return;
+    }
+    console.log(this.useColor ? colors.muted(symbols.pointer) : symbols.pointer, message);
+  }
+  step(message) {
+    if (this.isQuiet) {
+      return;
+    }
+    if (this.useJson) {
+      console.log(JSON.stringify({ level: "step", message }));
+      return;
+    }
+    console.log(this.useColor ? colors.primary(symbols.step) : symbols.step, message);
+  }
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+};
+
+// src/utils/task-runner.ts
+import { execa } from "execa";
+var DefaultTaskRunner = class {
+  tasks = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  registerTask(name, task) {
+    this.tasks.set(name, task);
+  }
+  async run(command, args = [], options = {}) {
+    const startTime = Date.now();
+    const cwd = options.cwd || process.cwd();
+    try {
+      if (!options.silent) {
+        this.logger.debug(`Running: ${command} ${args.join(" ")}`);
+      }
+      const result = await execa(command, args, {
+        all: true,
+        cwd,
+        env: { ...process.env, ...options.env },
+        reject: false
+      });
+      const duration = Date.now() - startTime;
+      if (result.exitCode === 0) {
+        return {
+          duration,
+          exitCode: result.exitCode,
+          output: options.captureOutput ? result.all : void 0,
+          status: "ok"
+        };
+      }
+      return {
+        duration,
+        exitCode: result.exitCode,
+        message: `Command failed with exit code ${result.exitCode}`,
+        output: result.all,
+        status: "error"
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      return {
+        duration,
+        message: error instanceof Error ? error.message : "Unknown error",
+        status: "error"
+      };
+    }
+  }
+  async runTask(taskName) {
+    const task = this.tasks.get(taskName);
+    if (!task) {
+      return {
+        message: `Task '${taskName}' not found`,
+        status: "error"
+      };
+    }
+    return await task();
+  }
+};
+export {
+  ConfigLoader,
+  ConsoleLogger,
+  DefaultTaskRunner,
+  KubitConfigSchema,
+  PluginManager
+};
+//# sourceMappingURL=index.js.map