@involvex/super-agent-cli 0.0.62 → 0.0.63

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -41,12 +42,14 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/utils/settings-manager.ts
 var exports_settings_manager = {};
 __export(exports_settings_manager, {
   getSettingsManager: () => getSettingsManager,
-  SettingsManager: () => SettingsManager
+  SettingsManager: () => SettingsManager,
+  PROVIDER_MODELS: () => PROVIDER_MODELS
 });
 import * as path from "path";
 import * as os from "os";
@@ -87,7 +90,20 @@ class SettingsManager {
       }
       const content = fs.readFileSync(this.userSettingsPath, "utf-8");
       const settings = JSON.parse(content);
-      return { ...DEFAULT_USER_SETTINGS, ...settings };
+      const mergedProviders = { ...DEFAULT_USER_SETTINGS.providers };
+      if (settings.providers) {
+        for (const [key, value] of Object.entries(settings.providers)) {
+          mergedProviders[key] = {
+            ...mergedProviders[key] || {},
+            ...value
+          };
+        }
+      }
+      return {
+        ...DEFAULT_USER_SETTINGS,
+        ...settings,
+        providers: mergedProviders
+      };
     } catch (error) {
       console.warn("Failed to load user settings:", error);
       return { ...DEFAULT_USER_SETTINGS };
@@ -175,6 +191,12 @@ class SettingsManager {
     if (models) {
       return models;
     }
+    if (activeProvider) {
+      const config = this.getEffectiveSettings().providers[activeProvider];
+      if (config && config.model) {
+        return [config.model];
+      }
+    }
     return [
       "grok-beta",
       "grok-vision-beta",
@@ -336,6 +358,94 @@ var init_settings_manager = __esm(() => {
   DEFAULT_PROJECT_SETTINGS = {};
 });
 
+// src/utils/file-utils.ts
+var exports_file_utils = {};
+__export(exports_file_utils, {
+  resolveSourcePath: () => resolveSourcePath,
+  listFilesRecursive: () => listFilesRecursive,
+  filterFileEntries: () => filterFileEntries,
+  expandHome: () => expandHome
+});
+import * as fs2 from "fs-extra";
+import * as path2 from "path";
+import * as os2 from "os";
+function expandHome(filepath) {
+  if (filepath.startsWith("~")) {
+    return path2.join(os2.homedir(), filepath.slice(1));
+  }
+  return filepath;
+}
+function resolveSourcePath(source) {
+  const defaults = {
+    gemini: "~/.gemini",
+    claude: "~/.claude",
+    kilo: "~/.kilocode"
+  };
+  const rawPath = defaults[source.toLowerCase()] || source;
+  return expandHome(rawPath);
+}
+async function listFilesRecursive(dir, baseDir = dir, maxDepth = 3) {
+  const result = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      const relativePath = path2.relative(baseDir, fullPath);
+      const isIgnored = [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        "target",
+        "vendor"
+      ].includes(entry.name);
+      if (isIgnored) {
+        continue;
+      }
+      if (entry.name.startsWith(".") && entry.name !== ".env") {
+        continue;
+      }
+      result.push({
+        name: entry.name,
+        path: relativePath,
+        isDirectory: entry.isDirectory()
+      });
+      if (entry.isDirectory() && maxDepth > 0) {
+        const subFiles = await listFilesRecursive(fullPath, baseDir, maxDepth - 1);
+        result.push(...subFiles);
+      }
+    }
+  } catch (error) {}
+  return result;
+}
+function filterFileEntries(entries, query) {
+  if (!query) {
+    return entries.slice(0, 20);
+  }
+  const lowerQuery = query.toLowerCase();
+  return entries.filter((e) => e.path.toLowerCase().includes(lowerQuery)).sort((a, b) => {
+    const aLower = a.name.toLowerCase();
+    const bLower = b.name.toLowerCase();
+    if (aLower === lowerQuery && bLower !== lowerQuery) {
+      return -1;
+    }
+    if (bLower === lowerQuery && aLower !== lowerQuery) {
+      return 1;
+    }
+    const aPathLower = a.path.toLowerCase();
+    const bPathLower = b.path.toLowerCase();
+    if (aPathLower.startsWith(lowerQuery) && !bPathLower.startsWith(lowerQuery)) {
+      return -1;
+    }
+    if (bPathLower.startsWith(lowerQuery) && !aPathLower.startsWith(lowerQuery)) {
+      return 1;
+    }
+    return a.path.length - b.path.length;
+  }).slice(0, 20);
+}
+var init_file_utils = () => {};
+
 // src/mcp/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -412,14 +522,231 @@ var init_config = __esm(() => {
   PREDEFINED_SERVERS = {};
 });
 
+// src/agents/manager.ts
+var exports_manager = {};
+__export(exports_manager, {
+  AgentsManager: () => AgentsManager
+});
+import fs6 from "fs/promises";
+import path6 from "path";
+
+class AgentsManager {
+  static instance;
+  agentsPath;
+  constructor() {
+    this.agentsPath = path6.join(getSettingsManager().getStorageDirectory(), "agents");
+  }
+  static getInstance() {
+    if (!AgentsManager.instance) {
+      AgentsManager.instance = new AgentsManager;
+    }
+    return AgentsManager.instance;
+  }
+  async ensureAgentsDirectory() {
+    try {
+      await fs6.mkdir(this.agentsPath, { recursive: true });
+    } catch (error) {}
+  }
+  async listAgents() {
+    await this.ensureAgentsDirectory();
+    try {
+      const files = await fs6.readdir(this.agentsPath);
+      const agents = [];
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          try {
+            const content = await fs6.readFile(path6.join(this.agentsPath, file), "utf-8");
+            agents.push(JSON.parse(content));
+          } catch (e) {}
+        }
+      }
+      return agents;
+    } catch (error) {
+      return [];
+    }
+  }
+  async getAgent(name) {
+    try {
+      const content = await fs6.readFile(path6.join(this.agentsPath, `${name}.json`), "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+  async createAgent(config) {
+    await this.ensureAgentsDirectory();
+    const filePath = path6.join(this.agentsPath, `${config.name}.json`);
+    await fs6.writeFile(filePath, JSON.stringify(config, null, 2));
+  }
+  async generateAgent(name, description, agent) {
+    const prompt = `Create a configuration for an AI agent named "${name}" based on this description: "${description}".
+    
+    The configuration should be a JSON object matching this interface:
+    interface AgentConfig {
+      name: string;
+      role: string;
+      description: string;
+      model?: string; // suggest a model if appropriate, or leave undefined
+      tools?: string[]; // suggest relevant tools/skills names
+      temperature?: number;
+      systemPrompt?: string; // a detailed system prompt for this agent
+    }
+    
+    Return ONLY the JSON object.`;
+    const response = await agent.processUserMessage(prompt);
+    let jsonData = "";
+    for (const entry of response) {
+      if (entry.type === "assistant") {
+        const match = entry.content.match(/```(?:json)?\n([\s\S]*?)```/);
+        if (match) {
+          jsonData = match[1];
+          break;
+        } else {
+          if (entry.content.trim().startsWith("{")) {
+            jsonData = entry.content;
+          }
+        }
+      }
+    }
+    if (!jsonData) {
+      throw new Error("Failed to generate agent configuration");
+    }
+    try {
+      const config = JSON.parse(jsonData);
+      config.name = name;
+      await this.createAgent(config);
+    } catch (e) {
+      throw new Error(`Failed to parse generated agent config: ${e.message}`);
+    }
+  }
+  async deleteAgent(name) {
+    try {
+      const filePath = path6.join(this.agentsPath, `${name}.json`);
+      await fs6.unlink(filePath);
+    } catch (error) {
+      throw new Error(`Failed to delete agent '${name}'`);
+    }
+  }
+}
+var init_manager = __esm(() => {
+  init_settings_manager();
+});
+
+// src/skills/manager.ts
+var exports_manager2 = {};
+__export(exports_manager2, {
+  SkillsManager: () => SkillsManager
+});
+import fs7 from "fs/promises";
+import path7 from "path";
+
+class SkillsManager {
+  static instance;
+  skillsPath;
+  constructor() {
+    this.skillsPath = path7.join(getSettingsManager().getStorageDirectory(), "skills");
+  }
+  static getInstance() {
+    if (!SkillsManager.instance) {
+      SkillsManager.instance = new SkillsManager;
+    }
+    return SkillsManager.instance;
+  }
+  async ensureSkillsDirectory() {
+    try {
+      await fs7.mkdir(this.skillsPath, { recursive: true });
+    } catch (error) {}
+  }
+  async listSkills() {
+    await this.ensureSkillsDirectory();
+    try {
+      const files = await fs7.readdir(this.skillsPath);
+      return files.filter((file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".json")).map((file) => path7.parse(file).name);
+    } catch (error) {
+      return [];
+    }
+  }
+  async getSkillPath(name) {
+    const extensions = [".ts", ".js", ".json"];
+    for (const ext of extensions) {
+      const fullPath = path7.join(this.skillsPath, `${name}${ext}`);
+      try {
+        await fs7.access(fullPath);
+        return fullPath;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`Skill '${name}' not found`);
+  }
+  async getSkillContent(name) {
+    const skillPath = await this.getSkillPath(name);
+    return await fs7.readFile(skillPath, "utf-8");
+  }
+  async createSkill(name, description, agent) {
+    await this.ensureSkillsDirectory();
+    const prompt = `Create a robust TypeScript skill for the Super Agent CLI named "${name}".
+    
+    Description: ${description}
+    
+    The skill should be a module that exports a default function or class that implements the desired functionality.
+    It should valid standalone TypeScript code.
+    Include comments explaining how it works.
+    
+    Structure:
+    \`\`\`typescript
+    // ${name} skill
+    export default async function(args: any) {
+      // implementation
+    }
+    \`\`\`
+    
+    Return ONLY the code block.`;
+    const response = await agent.processUserMessage(prompt);
+    let code = "";
+    for (const entry of response) {
+      if (entry.type === "assistant") {
+        const match = entry.content.match(/```(?:typescript|ts)?\n([\s\S]*?)```/);
+        if (match) {
+          code = match[1];
+          break;
+        } else {
+          code = entry.content;
+        }
+      }
+    }
+    if (!code) {
+      throw new Error("Failed to generate skill code");
+    }
+    const filePath = path7.join(this.skillsPath, `${name}.ts`);
+    await fs7.writeFile(filePath, code);
+  }
+  async deleteSkill(name) {
+    try {
+      const skillPath = await this.getSkillPath(name);
+      await fs7.unlink(skillPath);
+    } catch (error) {
+      throw new Error(`Failed to delete skill '${name}': ${error.message}`);
+    }
+  }
+  async saveSkill(name, content) {
+    await this.ensureSkillsDirectory();
+    const filePath = path7.join(this.skillsPath, name.endsWith(".ts") ? name : `${name}.ts`);
+    await fs7.writeFile(filePath, content);
+  }
+}
+var init_manager2 = __esm(() => {
+  init_settings_manager();
+});
+
 // src/indexing/indexer.ts
 var exports_indexer = {};
 __export(exports_indexer, {
   getFileIndexer: () => getFileIndexer,
   FileIndexer: () => FileIndexer
 });
-import * as fs9 from "fs-extra";
-import * as path8 from "path";
+import * as fs11 from "fs-extra";
+import * as path10 from "path";
 
 class FileIndexer {
   static instance;
@@ -429,7 +756,7 @@ class FileIndexer {
   isScanning = false;
   constructor() {
     const settingsManager = getSettingsManager();
-    this.storagePath = path8.join(settingsManager.getStorageDirectory(), INDEX_FILENAME);
+    this.storagePath = path10.join(settingsManager.getStorageDirectory(), INDEX_FILENAME);
     this.rootPath = process.cwd();
   }
   static getInstance() {
@@ -440,8 +767,8 @@ class FileIndexer {
   }
   async loadIndex() {
     try {
-      if (fs9.existsSync(this.storagePath)) {
-        const content = await fs9.readFile(this.storagePath, "utf-8");
+      if (fs11.existsSync(this.storagePath)) {
+        const content = await fs11.readFile(this.storagePath, "utf-8");
         this.index = JSON.parse(content);
         if (!this.index || this.index.metadata.version !== INDEX_VERSION || this.index.metadata.rootPath !== this.rootPath) {
           this.index = null;
@@ -457,7 +784,7 @@ class FileIndexer {
       return;
     }
     try {
-      await fs9.outputFile(this.storagePath, JSON.stringify(this.index, null, 2));
+      await fs11.outputFile(this.storagePath, JSON.stringify(this.index, null, 2));
     } catch (error) {
       console.error("Failed to save file index:", error);
     }
@@ -483,15 +810,15 @@ class FileIndexer {
       ];
       const entries = [];
       const scanDir = async (dir) => {
-        const files = await fs9.readdir(dir, { withFileTypes: true });
+        const files = await fs11.readdir(dir, { withFileTypes: true });
         for (const file of files) {
           if (ignoreList.includes(file.name) || file.name.startsWith(".")) {
             if (file.name !== ".env") {
               continue;
             }
           }
-          const fullPath = path8.join(dir, file.name);
-          const relativePath = path8.relative(this.rootPath, fullPath);
+          const fullPath = path10.join(dir, file.name);
+          const relativePath = path10.relative(this.rootPath, fullPath);
           if (file.isDirectory()) {
             entries.push({
               path: relativePath,
@@ -501,7 +828,7 @@ class FileIndexer {
             });
             await scanDir(fullPath);
           } else {
-            const stats = await fs9.stat(fullPath);
+            const stats = await fs11.stat(fullPath);
             entries.push({
               path: relativePath,
               size: stats.size,
@@ -542,8 +869,8 @@ __export(exports_session_manager, {
   getSessionManager: () => getSessionManager,
   SessionManager: () => SessionManager
 });
-import * as fs13 from "fs-extra";
-import * as path12 from "path";
+import * as fs15 from "fs-extra";
+import * as path14 from "path";
 
 class SessionManager {
   static instance;
@@ -551,8 +878,8 @@ class SessionManager {
   currentSession = null;
   constructor() {
     const settingsManager = getSettingsManager();
-    this.sessionsDir = path12.join(settingsManager.getStorageDirectory(), "sessions");
-    fs13.ensureDirSync(this.sessionsDir);
+    this.sessionsDir = path14.join(settingsManager.getStorageDirectory(), "sessions");
+    fs15.ensureDirSync(this.sessionsDir);
   }
   static getInstance() {
     if (!SessionManager.instance) {
@@ -561,18 +888,18 @@ class SessionManager {
     return SessionManager.instance;
   }
   generateSessionId(workingDir) {
-    const normalized = path12.normalize(workingDir).toLowerCase();
+    const normalized = path14.normalize(workingDir).toLowerCase();
     return Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
   }
   getSessionFilePath(sessionId) {
-    return path12.join(this.sessionsDir, `${sessionId}.json`);
+    return path14.join(this.sessionsDir, `${sessionId}.json`);
   }
   async getOrCreateSession(workingDirectory, name) {
     const sessionId = this.generateSessionId(workingDirectory);
     const sessionFile = this.getSessionFilePath(sessionId);
     try {
-      if (await fs13.pathExists(sessionFile)) {
-        const session = await fs13.readJson(sessionFile);
+      if (await fs15.pathExists(sessionFile)) {
+        const session = await fs15.readJson(sessionFile);
         session.lastAccessed = Date.now();
         this.currentSession = session;
         await this.saveSession(session);
@@ -582,7 +909,7 @@ class SessionManager {
     const newSession = {
       id: sessionId,
       workingDirectory,
-      name: name || path12.basename(workingDirectory),
+      name: name || path14.basename(workingDirectory),
       messages: [],
       lastAccessed: Date.now(),
       createdAt: Date.now()
@@ -593,7 +920,7 @@ class SessionManager {
   }
   async saveSession(session) {
     const sessionFile = this.getSessionFilePath(session.id);
-    await fs13.outputJson(sessionFile, session, { spaces: 2 });
+    await fs15.outputJson(sessionFile, session, { spaces: 2 });
   }
   async addMessage(message) {
     if (!this.currentSession) {
@@ -604,12 +931,12 @@ class SessionManager {
     await this.saveSession(this.currentSession);
   }
   async listSessions() {
-    const sessionFiles = await fs13.readdir(this.sessionsDir);
+    const sessionFiles = await fs15.readdir(this.sessionsDir);
     const sessions = [];
     for (const file of sessionFiles) {
       if (file.endsWith(".json")) {
         try {
-          const session = await fs13.readJson(path12.join(this.sessionsDir, file));
+          const session = await fs15.readJson(path14.join(this.sessionsDir, file));
           sessions.push(session);
         } catch (error) {}
       }
@@ -619,8 +946,8 @@ class SessionManager {
   }
   async deleteSession(sessionId) {
     const sessionFile = this.getSessionFilePath(sessionId);
-    if (await fs13.pathExists(sessionFile)) {
-      await fs13.remove(sessionFile);
+    if (await fs15.pathExists(sessionFile)) {
+      await fs15.remove(sessionFile);
     }
   }
   getCurrentSession() {
@@ -629,8 +956,8 @@ class SessionManager {
   async switchSession(sessionId) {
     const sessionFile = this.getSessionFilePath(sessionId);
     try {
-      if (await fs13.pathExists(sessionFile)) {
-        const session = await fs13.readJson(sessionFile);
+      if (await fs15.pathExists(sessionFile)) {
+        const session = await fs15.readJson(sessionFile);
         session.lastAccessed = Date.now();
         this.currentSession = session;
         await this.saveSession(session);
@@ -651,12 +978,15 @@ var init_session_manager = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@involvex/super-agent-cli",
-    version: "0.0.62",
+    version: "0.0.63",
     description: "An open-source AI agent that brings the power of Super Agent directly into your terminal.",
     keywords: [
       "cli",
       "agent",
-      "text-editor",
+      "cli-agent",
+      "ai-cli",
+      "coding-cli",
+      "ai-coding-cli",
       "ai"
     ],
     homepage: "https://involvex.github.io/super-agent-cli/",
@@ -758,8 +1088,8 @@ __export(exports_update_checker, {
   getUpdateChecker: () => getUpdateChecker,
   UpdateChecker: () => UpdateChecker
 });
-import * as fs14 from "fs-extra";
-import * as path13 from "path";
+import * as fs16 from "fs-extra";
+import * as path15 from "path";
 import axios3 from "axios";
 
 class UpdateChecker {
@@ -768,7 +1098,7 @@ class UpdateChecker {
   currentVersion;
   constructor(currentVersion) {
     const settingsManager = getSettingsManager();
-    this.cacheFile = path13.join(settingsManager.getStorageDirectory(), "update-cache.json");
+    this.cacheFile = path15.join(settingsManager.getStorageDirectory(), "update-cache.json");
     this.currentVersion = currentVersion;
   }
   static getInstance(currentVersion) {
@@ -779,8 +1109,8 @@ class UpdateChecker {
   }
   async loadCache() {
     try {
-      if (await fs14.pathExists(this.cacheFile)) {
-        const cache = await fs14.readJson(this.cacheFile);
+      if (await fs16.pathExists(this.cacheFile)) {
+        const cache = await fs16.readJson(this.cacheFile);
         const now = Date.now();
         if (cache.lastChecked && now - cache.lastChecked < CACHE_DURATION) {
           return cache;
@@ -791,7 +1121,7 @@ class UpdateChecker {
   }
   async saveCache(info) {
     try {
-      await fs14.outputJson(this.cacheFile, info);
+      await fs16.outputJson(this.cacheFile, info);
     } catch (error) {}
   }
   compareVersions(v1, v2) {
@@ -992,69 +1322,8 @@ class ConfirmationService extends EventEmitter {
 // src/index.ts
 init_settings_manager();
 
-// src/utils/file-utils.ts
-import * as fs2 from "fs-extra";
-import * as path2 from "path";
-async function listFilesRecursive(dir, baseDir = dir, maxDepth = 3) {
-  const result = [];
-  try {
-    const entries = await fs2.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      const relativePath = path2.relative(baseDir, fullPath);
-      const isIgnored = [
-        "node_modules",
-        ".git",
-        "dist",
-        "build",
-        ".next",
-        "target",
-        "vendor"
-      ].includes(entry.name);
-      if (isIgnored) {
-        continue;
-      }
-      if (entry.name.startsWith(".") && entry.name !== ".env") {
-        continue;
-      }
-      result.push({
-        name: entry.name,
-        path: relativePath,
-        isDirectory: entry.isDirectory()
-      });
-      if (entry.isDirectory() && maxDepth > 0) {
-        const subFiles = await listFilesRecursive(fullPath, baseDir, maxDepth - 1);
-        result.push(...subFiles);
-      }
-    }
-  } catch (error) {}
-  return result;
-}
-function filterFileEntries(entries, query) {
-  if (!query) {
-    return entries.slice(0, 20);
-  }
-  const lowerQuery = query.toLowerCase();
-  return entries.filter((e) => e.path.toLowerCase().includes(lowerQuery)).sort((a, b) => {
-    const aLower = a.name.toLowerCase();
-    const bLower = b.name.toLowerCase();
-    if (aLower === lowerQuery && bLower !== lowerQuery) {
-      return -1;
-    }
-    if (bLower === lowerQuery && aLower !== lowerQuery) {
-      return 1;
-    }
-    const aPathLower = a.path.toLowerCase();
-    const bPathLower = b.path.toLowerCase();
-    if (aPathLower.startsWith(lowerQuery) && !bPathLower.startsWith(lowerQuery)) {
-      return -1;
-    }
-    if (bPathLower.startsWith(lowerQuery) && !aPathLower.startsWith(lowerQuery)) {
-      return 1;
-    }
-    return a.path.length - b.path.length;
-  }).slice(0, 20);
-}
+// src/hooks/use-input-handler.ts
+init_file_utils();
 
 // src/utils/text-utils.ts
 function isWordBoundary(char) {
@@ -1499,9 +1768,9 @@ function CommandSuggestions({
 
 // src/utils/model-config.ts
 init_settings_manager();
-function loadModelConfig() {
+function loadModelConfig(providerId) {
   const manager = getSettingsManager();
-  const models = manager.getAvailableModels();
+  const models = manager.getAvailableModels(providerId);
   return models.map((model) => ({
     model: model.trim()
   }));
@@ -2473,7 +2742,7 @@ function getChatManager() {
 }
 
 // src/hooks/use-input-handler.ts
-import * as fs6 from "fs-extra";
+import * as fs8 from "fs-extra";
 function useInputHandler({
   agent,
   chatHistory,
@@ -2615,6 +2884,7 @@ function useInputHandler({
         if (providers.length > 0) {
           const selectedProviderId = providers[selectedProviderIndex];
           manager.updateUserSetting("active_provider", selectedProviderId);
+          setActiveProvider(selectedProviderId);
           setChatHistory((prev) => [
             ...prev,
             {
@@ -2631,6 +2901,24 @@ function useInputHandler({
         setShowProviderSelection(false);
         return true;
       }
+      if (char === "e" || char === "E") {
+        if (providers.length > 0) {
+          const selectedProviderId = providers[selectedProviderIndex];
+          const manager2 = getSettingsManager();
+          const currentKey = manager2.getUserSetting("providers")?.[selectedProviderId]?.api_key || "";
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `\uD83D\uDCDD Editing API key for ${selectedProviderId}. Press Enter after pasting key.`,
+              timestamp: new Date
+            }
+          ]);
+          setShowProviderSelection(false);
+          setInput(`/provider set-key ${selectedProviderId} `);
+        }
+        return true;
+      }
       return true;
     }
     if (showConfigViewer) {
@@ -2826,13 +3114,17 @@ function useInputHandler({
       description: "Manage plugins (list, install, remove)"
     },
     { command: "/commit-and-push", description: "AI commit & push to remote" },
+    {
+      command: "/import <type> <source>",
+      description: "Import resources (agents, skills, hooks)"
+    },
     { command: "/exit", description: "Exit the application" }
   ];
   const [activeProvider, setActiveProvider] = useState3(() => {
     return getSettingsManager().loadUserSettings().active_provider;
   });
   const availableModels = useMemo2(() => {
-    return loadModelConfig();
+    return loadModelConfig(activeProvider);
   }, [activeProvider]);
   const handleDirectCommand = async (input2) => {
     const trimmedInput = input2.trim();
@@ -2898,6 +3190,64 @@ Config Commands:
       clearInput();
       return true;
     }
+    if (trimmedInput === "/provider config") {
+      setChatHistory((prev) => [
+        ...prev,
+        {
+          type: "assistant",
+          content: "⚠️ Interactive configuration cannot be run inside the chat session.\n\nPlease run `super-agent provider config` in a separate terminal, or use:\n`/provider set-key <provider> <key>` to set an API key directly.",
+          timestamp: new Date
+        }
+      ]);
+      clearInput();
+      return true;
+    }
+    if (trimmedInput.startsWith("/provider set-key ")) {
+      const args = trimmedInput.replace("/provider set-key ", "").trim().split(" ");
+      const providerId = args[0];
+      const key = args.slice(1).join(" ");
+      if (!providerId || !key) {
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: "❌ Usage: /provider set-key <provider> <api_key>",
+            timestamp: new Date
+          }
+        ]);
+        clearInput();
+        return true;
+      }
+      const manager = getSettingsManager();
+      const settings = manager.loadUserSettings();
+      if (settings.providers && settings.providers[providerId]) {
+        const newProviders = { ...settings.providers };
+        newProviders[providerId] = {
+          ...newProviders[providerId],
+          api_key: key
+        };
+        manager.updateUserSetting("providers", newProviders);
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: `✅ API Key for ${providerId} updated.`,
+            timestamp: new Date
+          }
+        ]);
+      } else {
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: `❌ Provider '${providerId}' not found.`,
+            timestamp: new Date
+          }
+        ]);
+      }
+      clearInput();
+      return true;
+    }
     if (trimmedInput.startsWith("/provider use ")) {
       const providerId = trimmedInput.replace("/provider use ", "").trim();
       const manager = getSettingsManager();
@@ -3071,6 +3421,149 @@ ${chats.length ? chats.map((c) => `- ${c}`).join(`
       clearInput();
       return true;
     }
+    if (trimmedInput.startsWith("/import ")) {
+      const args = trimmedInput.replace("/import ", "").split(" ");
+      const type = args[0];
+      const source = args[1];
+      if (!type || !source) {
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: `❌ Usage: /import <type> <source>
+Types: agents, skills, hooks
+Sources: gemini, claude, kilo, or path`,
+            timestamp: new Date
+          }
+        ]);
+        clearInput();
+        return true;
+      }
+      setIsProcessing(true);
+      setChatHistory((prev) => [
+        ...prev,
+        {
+          type: "assistant",
+          content: `Importing ${type} from ${source}...`,
+          timestamp: new Date
+        }
+      ]);
+      try {
+        const { resolveSourcePath: resolveSourcePath2 } = await Promise.resolve().then(() => (init_file_utils(), exports_file_utils));
+        const { AgentsManager: AgentsManager2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+        const { SkillsManager: SkillsManager2 } = await Promise.resolve().then(() => (init_manager2(), exports_manager2));
+        const { getSettingsManager: getSettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), exports_settings_manager));
+        const fs9 = await import("fs-extra");
+        const path8 = await import("path");
+        const sourcePath = resolveSourcePath2(source);
+        if (type === "agents") {
+          const agentsDir = path8.join(sourcePath, "agents");
+          if (!await fs9.pathExists(agentsDir)) {
+            throw new Error(`Agents directory not found at ${agentsDir}`);
+          }
+          const files = await fs9.readdir(agentsDir);
+          const manager = AgentsManager2.getInstance();
+          let count = 0;
+          for (const file of files) {
+            if (file.endsWith(".json")) {
+              try {
+                const content = await fs9.readJson(path8.join(agentsDir, file));
+                const agentConfig = {
+                  name: content.name || path8.parse(file).name,
+                  role: content.role || "Assistant",
+                  description: content.description || "Imported agent",
+                  model: content.model,
+                  tools: content.tools,
+                  temperature: content.temperature,
+                  systemPrompt: content.systemPrompt || content.system_prompt || content.prompt
+                };
+                await manager.createAgent(agentConfig);
+                count++;
+              } catch (e) {}
+            }
+          }
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✅ Imported ${count} agents.`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (type === "skills") {
+          const skillsDir = path8.join(sourcePath, "skills");
+          if (!await fs9.pathExists(skillsDir)) {
+            throw new Error(`Skills directory not found at ${skillsDir}`);
+          }
+          const files = await fs9.readdir(skillsDir);
+          const manager = SkillsManager2.getInstance();
+          let count = 0;
+          for (const file of files) {
+            if (file.endsWith(".ts") || file.endsWith(".js")) {
+              try {
+                const content = await fs9.readFile(path8.join(skillsDir, file), "utf-8");
+                const name = path8.parse(file).name;
+                await manager.saveSkill(name, content);
+                count++;
+              } catch (e) {}
+            }
+          }
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✅ Imported ${count} skills.`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (type === "hooks") {
+          const settingsFile = source.toLowerCase() === "claude" ? "settings.local.json" : "settings.json";
+          const fullPath = path8.join(sourcePath, settingsFile);
+          if (!await fs9.pathExists(fullPath)) {
+            throw new Error(`Settings file not found at ${fullPath}`);
+          }
+          const settings = await fs9.readJson(fullPath);
+          if (settings.hooks) {
+            const manager = getSettingsManager2();
+            const currentHooks = manager.getUserSetting("hooks") || {};
+            const mergedHooks = { ...currentHooks, ...settings.hooks };
+            manager.updateUserSetting("hooks", mergedHooks);
+            setChatHistory((prev) => [
+              ...prev,
+              {
+                type: "assistant",
+                content: `✅ Imported ${Object.keys(settings.hooks).length} hooks.`,
+                timestamp: new Date
+              }
+            ]);
+          } else {
+            setChatHistory((prev) => [
+              ...prev,
+              {
+                type: "assistant",
+                content: "⚠️ No hooks found in settings file.",
+                timestamp: new Date
+              }
+            ]);
+          }
+        } else {
+          throw new Error(`Unknown import type: ${type}`);
+        }
+      } catch (error) {
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: `❌ Import failed: ${error.message}`,
+            timestamp: new Date
+          }
+        ]);
+      } finally {
+        setIsProcessing(false);
+      }
+      clearInput();
+      return true;
+    }
     if (trimmedInput.startsWith("/plugin ")) {
       const args = trimmedInput.replace("/plugin ", "").split(" ");
       const action = args[0];
@@ -3487,9 +3980,9 @@ ${commitMessage}`
       for (const mention of mentionMatches) {
         const filePath = mention.slice(1);
         try {
-          const stats = await fs6.stat(filePath);
+          const stats = await fs8.stat(filePath);
           if (stats.isFile()) {
-            const content = await fs6.readFile(filePath, "utf-8");
+            const content = await fs8.readFile(filePath, "utf-8");
             resolvedInput = resolvedInput.replace(mention, `
 
 --- FILE: ${filePath} ---
@@ -3640,6 +4133,7 @@ ${structure}
 }
 
 // src/ui/components/mention-suggestions.tsx
+init_file_utils();
 import { useMemo as useMemo3 } from "react";
 import { Box as Box2, Text as Text2 } from "ink";
 import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
@@ -4417,6 +4911,7 @@ function LoadingSpinner({
 }
 
 // src/ui/components/command-palette.tsx
+init_file_utils();
 import { useMemo as useMemo4 } from "react";
 import { Box as Box9, Text as Text8 } from "ink";
 import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
@@ -5055,8 +5550,8 @@ class ConfirmationTool {
   }
 }
 // src/tools/morph-editor.ts
-import * as path6 from "path";
-import fs7 from "fs-extra";
+import * as path8 from "path";
+import fs9 from "fs-extra";
 import axios2 from "axios";
 
 class MorphEditorTool {
@@ -5071,8 +5566,8 @@ class MorphEditorTool {
   }
   async editFile(targetFile, instructions, codeEdit) {
     try {
-      const resolvedPath = path6.resolve(targetFile);
-      if (!await fs7.pathExists(resolvedPath)) {
+      const resolvedPath = path8.resolve(targetFile);
+      if (!await fs9.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${targetFile}`
@@ -5084,7 +5579,7 @@ class MorphEditorTool {
           error: "MORPH_API_KEY not configured. Please set your Morph API key."
         };
       }
-      const initialCode = await fs7.readFile(resolvedPath, "utf-8");
+      const initialCode = await fs9.readFile(resolvedPath, "utf-8");
       const sessionFlags = this.confirmationService.getSessionFlags();
       if (!sessionFlags.fileOperations && !sessionFlags.allOperations) {
         const confirmationResult = await this.confirmationService.requestConfirmation({
@@ -5104,7 +5599,7 @@ ${codeEdit}`
         }
       }
       const mergedCode = await this.callMorphApply(instructions, initialCode, codeEdit);
-      await fs7.writeFile(resolvedPath, mergedCode, "utf-8");
+      await fs9.writeFile(resolvedPath, mergedCode, "utf-8");
       const oldLines = initialCode.split(`
 `);
       const newLines = mergedCode.split(`
@@ -5287,11 +5782,11 @@ ${codeEdit}`
   }
   async view(filePath, viewRange) {
     try {
-      const resolvedPath = path6.resolve(filePath);
-      if (await fs7.pathExists(resolvedPath)) {
-        const stats = await fs7.stat(resolvedPath);
+      const resolvedPath = path8.resolve(filePath);
+      if (await fs9.pathExists(resolvedPath)) {
+        const stats = await fs9.stat(resolvedPath);
         if (stats.isDirectory()) {
-          const files = await fs7.readdir(resolvedPath);
+          const files = await fs9.readdir(resolvedPath);
           return {
             success: true,
             output: `Directory contents of ${filePath}:
@@ -5299,7 +5794,7 @@ ${files.join(`
 `)}`
           };
         }
-        const content = await fs7.readFile(resolvedPath, "utf-8");
+        const content = await fs9.readFile(resolvedPath, "utf-8");
         const lines = content.split(`
 `);
         if (viewRange) {
@@ -5345,8 +5840,8 @@ ${numberedLines}${additionalLinesMessage}`
   }
 }
 // src/tools/project-map.ts
-import * as path7 from "path";
-import fs8 from "fs-extra";
+import * as path9 from "path";
+import fs10 from "fs-extra";
 
 class ProjectMapTool {
   currentDirectory = process.cwd();
@@ -5380,7 +5875,7 @@ Important Files:
     }
     let result = "";
     try {
-      const entries = await fs8.readdir(dir, { withFileTypes: true });
+      const entries = await fs10.readdir(dir, { withFileTypes: true });
       const sortedEntries = entries.sort((a, b) => {
         if (a.isDirectory() && !b.isDirectory()) {
           return -1;
@@ -5408,7 +5903,7 @@ Important Files:
         if (entry.isDirectory()) {
           result += `${indent}\uD83D\uDCC1 ${entry.name}/
 `;
-          result += await this.generateTree(path7.join(dir, entry.name), maxDepth, currentDepth + 1);
+          result += await this.generateTree(path9.join(dir, entry.name), maxDepth, currentDepth + 1);
         } else {
           result += `${indent}\uD83D\uDCC4 ${entry.name}
 `;
@@ -5430,8 +5925,8 @@ Important Files:
     ];
     const found = [];
     for (const pattern of importantPatterns) {
-      const fullPath = path7.join(this.currentDirectory, pattern);
-      if (await fs8.pathExists(fullPath)) {
+      const fullPath = path9.join(this.currentDirectory, pattern);
+      if (await fs10.pathExists(fullPath)) {
         found.push(pattern);
       }
     }
@@ -5444,8 +5939,8 @@ Important Files:
 // src/tools/search.ts
 init_indexer();
 import { spawn } from "child_process";
-import * as path9 from "path";
-import fs10 from "fs-extra";
+import * as path11 from "path";
+import fs12 from "fs-extra";
 
 class SearchTool {
   confirmationService = ConfirmationService.getInstance();
@@ -5474,7 +5969,7 @@ class SearchTool {
           const searchPattern = query.toLowerCase();
           fileResults = entries.filter((e) => e.path.toLowerCase().includes(searchPattern)).map((e) => ({
             path: e.path,
-            name: path9.basename(e.path),
+            name: path11.basename(e.path),
             score: 10
           }));
         } else {
@@ -5598,13 +6093,13 @@ class SearchTool {
         return;
       }
       try {
-        const entries = await fs10.readdir(dir, { withFileTypes: true });
+        const entries = await fs12.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (files.length >= maxResults) {
             break;
           }
-          const fullPath = path9.join(dir, entry.name);
-          const relativePath = path9.relative(this.currentDirectory, fullPath);
+          const fullPath = path11.join(dir, entry.name);
+          const relativePath = path11.relative(this.currentDirectory, fullPath);
           if (!options.includeHidden && entry.name.startsWith(".")) {
             continue;
           }
@@ -5703,19 +6198,19 @@ class SearchTool {
 }
 // src/tools/text-editor.ts
 import { writeFile as writeFilePromise } from "fs/promises";
-import * as path10 from "path";
-import fs11 from "fs-extra";
+import * as path12 from "path";
+import fs13 from "fs-extra";
 
 class TextEditorTool {
   editHistory = [];
   confirmationService = ConfirmationService.getInstance();
   async view(filePath, viewRange) {
     try {
-      const resolvedPath = path10.resolve(filePath);
-      if (await fs11.pathExists(resolvedPath)) {
-        const stats = await fs11.stat(resolvedPath);
+      const resolvedPath = path12.resolve(filePath);
+      if (await fs13.pathExists(resolvedPath)) {
+        const stats = await fs13.stat(resolvedPath);
         if (stats.isDirectory()) {
-          const files = await fs11.readdir(resolvedPath);
+          const files = await fs13.readdir(resolvedPath);
           return {
             success: true,
             output: `Directory contents of ${filePath}:
@@ -5723,7 +6218,7 @@ ${files.join(`
 `)}`
           };
         }
-        const content = await fs11.readFile(resolvedPath, "utf-8");
+        const content = await fs13.readFile(resolvedPath, "utf-8");
         const lines = content.split(`
 `);
         if (viewRange) {
@@ -5763,14 +6258,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async strReplace(filePath, oldStr, newStr, replaceAll = false) {
     try {
-      const resolvedPath = path10.resolve(filePath);
-      if (!await fs11.pathExists(resolvedPath)) {
+      const resolvedPath = path12.resolve(filePath);
+      if (!await fs13.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const content = await fs11.readFile(resolvedPath, "utf-8");
+      const content = await fs13.readFile(resolvedPath, "utf-8");
       if (!content.includes(oldStr)) {
         if (oldStr.includes(`
 `)) {
@@ -5838,7 +6333,7 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async create(filePath, content) {
     try {
-      const resolvedPath = path10.resolve(filePath);
+      const resolvedPath = path12.resolve(filePath);
       const sessionFlags = this.confirmationService.getSessionFlags();
       if (!sessionFlags.fileOperations && !sessionFlags.allOperations) {
         const contentLines = content.split(`
@@ -5864,8 +6359,8 @@ ${numberedLines}${additionalLinesMessage}`
           };
         }
       }
-      const dir = path10.dirname(resolvedPath);
-      await fs11.ensureDir(dir);
+      const dir = path12.dirname(resolvedPath);
+      await fs13.ensureDir(dir);
       await writeFilePromise(resolvedPath, content, "utf-8");
       this.editHistory.push({
         command: "create",
@@ -5889,14 +6384,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async replaceLines(filePath, startLine, endLine, newContent) {
     try {
-      const resolvedPath = path10.resolve(filePath);
-      if (!await fs11.pathExists(resolvedPath)) {
+      const resolvedPath = path12.resolve(filePath);
+      if (!await fs13.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const fileContent = await fs11.readFile(resolvedPath, "utf-8");
+      const fileContent = await fs13.readFile(resolvedPath, "utf-8");
       const lines = fileContent.split(`
 `);
       if (startLine < 1 || startLine > lines.length) {
@@ -5959,14 +6454,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async insert(filePath, insertLine, content) {
     try {
-      const resolvedPath = path10.resolve(filePath);
-      if (!await fs11.pathExists(resolvedPath)) {
+      const resolvedPath = path12.resolve(filePath);
+      if (!await fs13.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const fileContent = await fs11.readFile(resolvedPath, "utf-8");
+      const fileContent = await fs13.readFile(resolvedPath, "utf-8");
       const lines = fileContent.split(`
 `);
       lines.splice(insertLine - 1, 0, content);
@@ -6002,19 +6497,19 @@ ${numberedLines}${additionalLinesMessage}`
       switch (lastEdit.command) {
         case "str_replace":
           if (lastEdit.path && lastEdit.old_str && lastEdit.new_str) {
-            const content = await fs11.readFile(lastEdit.path, "utf-8");
+            const content = await fs13.readFile(lastEdit.path, "utf-8");
             const revertedContent = content.replace(lastEdit.new_str, lastEdit.old_str);
             await writeFilePromise(lastEdit.path, revertedContent, "utf-8");
           }
           break;
         case "create":
           if (lastEdit.path) {
-            await fs11.remove(lastEdit.path);
+            await fs13.remove(lastEdit.path);
           }
           break;
         case "insert":
           if (lastEdit.path && lastEdit.insert_line) {
-            const content = await fs11.readFile(lastEdit.path, "utf-8");
+            const content = await fs13.readFile(lastEdit.path, "utf-8");
             const lines = content.split(`
 `);
             lines.splice(lastEdit.insert_line - 1, 1);
@@ -6459,19 +6954,19 @@ class OpenAICompatibleProvider {
 }
 
 // src/utils/custom-instructions.ts
-import * as path11 from "path";
-import * as os2 from "os";
-import * as fs12 from "fs";
+import * as path13 from "path";
+import * as os3 from "os";
+import * as fs14 from "fs";
 function loadCustomInstructions(workingDirectory = process.cwd()) {
   try {
-    let instructionsPath = path11.join(workingDirectory, ".super-agent", "SUPER_AGENT.md");
-    if (fs12.existsSync(instructionsPath)) {
-      const customInstructions = fs12.readFileSync(instructionsPath, "utf-8");
+    let instructionsPath = path13.join(workingDirectory, ".super-agent", "SUPER_AGENT.md");
+    if (fs14.existsSync(instructionsPath)) {
+      const customInstructions = fs14.readFileSync(instructionsPath, "utf-8");
       return customInstructions.trim();
     }
-    instructionsPath = path11.join(os2.homedir(), ".super-agent", "SUPER_AGENT.md");
-    if (fs12.existsSync(instructionsPath)) {
-      const customInstructions = fs12.readFileSync(instructionsPath, "utf-8");
+    instructionsPath = path13.join(os3.homedir(), ".super-agent", "SUPER_AGENT.md");
+    if (fs14.existsSync(instructionsPath)) {
+      const customInstructions = fs14.readFileSync(instructionsPath, "utf-8");
       return customInstructions.trim();
     }
     return null;
@@ -8180,8 +8675,8 @@ init_settings_manager();
 // src/web/server.ts
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
-import * as fs15 from "fs-extra";
-import * as path14 from "path";
+import * as fs17 from "fs-extra";
+import * as path16 from "path";
 import open from "open";
 import mime from "mime";
 var __dirname = "/home/runner/work/super-agent-cli/super-agent-cli/src/web";
@@ -8209,21 +8704,21 @@ class WebServer {
     const url = req.url || "/";
     const requestedPath = url === "/" ? "index.html" : url;
     const sanitizedPath = requestedPath.split("?")[0].split("#")[0];
-    const clientDir = path14.join(__dirname, "../web/client");
-    const absolutePath = path14.resolve(clientDir, sanitizedPath.substring(1));
+    const clientDir = path16.join(__dirname, "../web/client");
+    const absolutePath = path16.resolve(clientDir, sanitizedPath.substring(1));
     if (!absolutePath.startsWith(clientDir)) {
       res.writeHead(403, { "Content-Type": "text/plain" });
       res.end("Forbidden");
       return;
     }
     try {
-      if (await fs15.pathExists(absolutePath)) {
-        const stat5 = await fs15.stat(absolutePath);
+      if (await fs17.pathExists(absolutePath)) {
+        const stat5 = await fs17.stat(absolutePath);
         let filePath = absolutePath;
         if (stat5.isDirectory()) {
-          filePath = path14.join(absolutePath, "index.html");
+          filePath = path16.join(absolutePath, "index.html");
         }
-        const content = await fs15.readFile(filePath);
+        const content = await fs17.readFile(filePath);
         const mimeType = mime.getType(filePath) || "application/octet-stream";
         res.writeHead(200, { "Content-Type": mimeType });
         res.end(content);
@@ -8311,7 +8806,7 @@ class WebServer {
       }
       const tree = index.entries.filter((e) => !e.path.includes("node_modules") && !e.path.startsWith(".")).map((e) => ({
         path: e.path,
-        name: path14.basename(e.path),
+        name: path16.basename(e.path),
         isDirectory: e.isDirectory,
         size: e.size
       })).slice(0, 500);
@@ -8322,11 +8817,11 @@ class WebServer {
   }
   async handleGetFileContent(filePath, ws) {
     try {
-      const fullPath = path14.join(process.cwd(), filePath);
+      const fullPath = path16.join(process.cwd(), filePath);
       if (!fullPath.startsWith(process.cwd())) {
         throw new Error("Access denied");
       }
-      const content = await fs15.readFile(fullPath, "utf-8");
+      const content = await fs17.readFile(fullPath, "utf-8");
       ws.send(JSON.stringify({
         type: "file_content",
         path: filePath,
@@ -8480,12 +8975,133 @@ function createServeCommand() {
   return serveCommand;
 }
 
-// src/commands/index-cmd.ts
+// src/commands/provider.ts
+init_settings_manager();
 import { Command as Command2 } from "commander";
-import fs16 from "fs/promises";
-import ignore from "ignore";
+import inquirer from "inquirer";
 import chalk2 from "chalk";
-import path15 from "path";
+function createProviderCommand() {
+  const cmd = new Command2("provider").description("Manage LLM provider configuration");
+  cmd.command("config").description("Interactive provider configuration").action(async () => {
+    const manager = getSettingsManager();
+    const settings = manager.loadUserSettings();
+    const providers = Object.keys(settings.providers);
+    const { selectedProvider } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selectedProvider",
+        message: "Select a provider to configure:",
+        choices: providers,
+        default: settings.active_provider
+      }
+    ]);
+    const currentConfig = settings.providers[selectedProvider];
+    if (!currentConfig) {
+      console.error(chalk2.red(`Configuration for ${selectedProvider} not found.`));
+      return;
+    }
+    const models = PROVIDER_MODELS[currentConfig.provider] || [];
+    const { apiKey } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "apiKey",
+        message: `Enter API Key for ${selectedProvider} (leave empty to keep current):`,
+        mask: "*"
+      }
+    ]);
+    let selectedModel = currentConfig.model;
+    if (models.length > 0) {
+      const { model } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "model",
+          message: "Select default model:",
+          choices: [...models, "Custom..."],
+          default: currentConfig.model
+        }
+      ]);
+      selectedModel = model;
+    }
+    if (selectedModel === "Custom..." || models.length === 0) {
+      const { customModel } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "customModel",
+          message: "Enter model ID:",
+          default: currentConfig.model
+        }
+      ]);
+      selectedModel = customModel;
+    }
+    const { baseURL } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "baseURL",
+        message: "Enter Base URL (optional, leave empty for default):",
+        default: currentConfig.base_url
+      }
+    ]);
+    console.log(chalk2.blue(`
+New Configuration:`));
+    console.log(`Provider: ${chalk2.bold(selectedProvider)}`);
+    console.log(`Model: ${chalk2.bold(selectedModel)}`);
+    console.log(`Base URL: ${baseURL || "Default"}`);
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Save these settings?",
+        default: true
+      }
+    ]);
+    if (confirm) {
+      const newProviders = { ...settings.providers };
+      newProviders[selectedProvider] = {
+        ...currentConfig,
+        model: selectedModel,
+        base_url: baseURL || currentConfig.base_url
+      };
+      if (apiKey) {
+        newProviders[selectedProvider].api_key = apiKey;
+      }
+      if (baseURL !== undefined && baseURL !== currentConfig.base_url) {
+        newProviders[selectedProvider].base_url = baseURL;
+      }
+      manager.updateUserSetting("providers", newProviders);
+      if (settings.active_provider !== selectedProvider) {
+        const { makeActive } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "makeActive",
+            message: `Set ${selectedProvider} as active provider?`,
+            default: true
+          }
+        ]);
+        if (makeActive) {
+          manager.updateUserSetting("active_provider", selectedProvider);
+          console.log(chalk2.green(`
+✅ Settings saved and ${selectedProvider} is now active.`));
+        } else {
+          console.log(chalk2.green(`
+✅ Settings saved.`));
+        }
+      } else {
+        console.log(chalk2.green(`
+✅ Settings saved.`));
+      }
+    } else {
+      console.log(chalk2.yellow("Configuration cancelled."));
+    }
+  });
+  return cmd;
+}
+
+// src/commands/index-cmd.ts
+import { Command as Command3 } from "commander";
+import fs18 from "fs/promises";
+import ignore from "ignore";
+import chalk3 from "chalk";
+import path17 from "path";
 var DEFAULT_IGNORES = [
   "node_modules",
   ".git",
@@ -8498,17 +9114,17 @@ var DEFAULT_IGNORES = [
   "Thumbs.db"
 ];
 function createIndexCommand() {
-  const indexCommand = new Command2("index").description(" recursively index a directory and save to a file").argument("[directory]", "Directory to index", ".").option("-o, --output <file>", "Output file path (default: index.md)").option("--no-ignore", "Disable .gitignore respecting").option("-d, --depth <depth>", "Max depth to traverse", "10").action(async (directory, options) => {
+  const indexCommand = new Command3("index").description(" recursively index a directory and save to a file").argument("[directory]", "Directory to index", ".").option("-o, --output <file>", "Output file path (default: index.md)").option("--no-ignore", "Disable .gitignore respecting").option("-d, --depth <depth>", "Max depth to traverse", "10").action(async (directory, options) => {
     try {
-      const rootDir = path15.resolve(directory);
-      const outputFile2 = options.output ? path15.resolve(options.output) : path15.join(rootDir, "index.md");
+      const rootDir = path17.resolve(directory);
+      const outputFile2 = options.output ? path17.resolve(options.output) : path17.join(rootDir, "index.md");
       const maxDepth = parseInt(options.depth);
-      console.log(chalk2.blue(`Indexing directory: ${rootDir}`));
+      console.log(chalk3.blue(`Indexing directory: ${rootDir}`));
       const ig = ignore().add(DEFAULT_IGNORES);
       if (options.ignore !== false) {
         try {
-          const gitignorePath = path15.join(rootDir, ".gitignore");
-          const gitignoreContent = await fs16.readFile(gitignorePath, "utf-8");
+          const gitignorePath = path17.join(rootDir, ".gitignore");
+          const gitignoreContent = await fs18.readFile(gitignorePath, "utf-8");
           ig.add(gitignoreContent);
         } catch (e) {}
       }
@@ -8523,19 +9139,19 @@ Date: ${new Date().toISOString()}
         if (depth > maxDepth) {
           return;
         }
-        const relativePath = path15.relative(rootDir, currentPath);
+        const relativePath = path17.relative(rootDir, currentPath);
         if (relativePath && ig.ignores(relativePath)) {
           return;
         }
-        const stats = await fs16.stat(currentPath);
+        const stats = await fs18.stat(currentPath);
         const isDir = stats.isDirectory();
-        const name = path15.basename(currentPath);
+        const name = path17.basename(currentPath);
         if (isDir) {
           if (relativePath) {
             outputContent += `${prefix}${name}/
 `;
           }
-          const entries = await fs16.readdir(currentPath, {
+          const entries = await fs18.readdir(currentPath, {
             withFileTypes: true
           });
           const sortedEntries = entries.sort((a, b) => {
@@ -8551,7 +9167,7 @@ Date: ${new Date().toISOString()}
             const entry = sortedEntries[i];
             const isLast = i === sortedEntries.length - 1;
             const newPrefix = relativePath ? prefix + "  " : "";
-            await buildTree(path15.join(currentPath, entry.name), depth + 1, newPrefix);
+            await buildTree(path17.join(currentPath, entry.name), depth + 1, newPrefix);
           }
         } else {
           outputContent += `${prefix}${name}
@@ -8563,10 +9179,10 @@ Date: ${new Date().toISOString()}
         if (currentDepth > maxDepth) {
           return;
         }
-        const entries = await fs16.readdir(dir, { withFileTypes: true });
+        const entries = await fs18.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path15.join(dir, entry.name);
-          const relPath = path15.relative(rootDir, fullPath);
+          const fullPath = path17.join(dir, entry.name);
+          const relPath = path17.relative(rootDir, fullPath);
           if (ig.ignores(relPath)) {
             continue;
           }
@@ -8578,8 +9194,8 @@ Date: ${new Date().toISOString()}
         }
       }
       await walk(rootDir, 0);
-      console.log(chalk2.blue(`Found ${files.length} files.`));
-      outputContent = `# Project Index: ${path15.basename(rootDir)}
+      console.log(chalk3.blue(`Found ${files.length} files.`));
+      outputContent = `# Project Index: ${path17.basename(rootDir)}
 
 `;
       outputContent += `Total Files: ${files.length}
@@ -8591,17 +9207,17 @@ Date: ${new Date().toISOString()}
       for (const file of files) {
         outputContent += `### ${file}
 `;
-        const stats = await fs16.stat(path15.join(rootDir, file));
+        const stats = await fs18.stat(path17.join(rootDir, file));
         outputContent += `- Size: ${stats.size} bytes
 `;
         outputContent += `- Modified: ${stats.mtime.toISOString()}
 
 `;
       }
-      await fs16.writeFile(outputFile2, outputContent);
-      console.log(chalk2.green(`✓ Index generated at: ${outputFile2}`));
+      await fs18.writeFile(outputFile2, outputContent);
+      console.log(chalk3.green(`✓ Index generated at: ${outputFile2}`));
     } catch (error) {
-      console.error(chalk2.red(`Error indexing directory: ${error.message}`));
+      console.error(chalk3.red(`Error indexing directory: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8610,9 +9226,9 @@ Date: ${new Date().toISOString()}
 
 // src/commands/plugins.ts
 init_settings_manager();
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 function createPluginsCommand() {
-  const pluginsCommand = new Command3("plugins").description("Manage plugins for Super Agent CLI").argument("[action]", "Action to perform (list, install, uninstall)").argument("[target]", "Plugin name or path");
+  const pluginsCommand = new Command4("plugins").description("Manage plugins for Super Agent CLI").argument("[action]", "Action to perform (list, install, uninstall)").argument("[target]", "Plugin name or path");
   pluginsCommand.command("list").description("List installed plugins").action(() => {
     const manager = getSettingsManager();
     const settings = manager.loadUserSettings();
@@ -8624,22 +9240,22 @@ function createPluginsCommand() {
     console.log("Installed plugins:");
     plugins.forEach((p) => console.log(`- ${p}`));
   });
-  pluginsCommand.command("install <path>").description("Install a plugin from a path, GitHub URL, or registry").action(async (path16) => {
+  pluginsCommand.command("install <path>").description("Install a plugin from a path, GitHub URL, or registry").action(async (path18) => {
     try {
       const manager = PluginManager.getInstance();
-      console.log(`Installing plugin from: ${path16}...`);
-      const installedPath = await manager.installPlugin(path16);
+      console.log(`Installing plugin from: ${path18}...`);
+      const installedPath = await manager.installPlugin(path18);
       console.log(`✅ Plugin installed successfully: ${installedPath}`);
     } catch (error) {
       console.error(`❌ Error installing plugin: ${error.message}`);
       process.exit(1);
     }
   });
-  pluginsCommand.command("uninstall <path>").description("Uninstall a plugin").action(async (path16) => {
+  pluginsCommand.command("uninstall <path>").description("Uninstall a plugin").action(async (path18) => {
     try {
       const manager = PluginManager.getInstance();
-      await manager.removePlugin(path16);
-      console.log(`✅ Plugin uninstalled: ${path16}`);
+      await manager.removePlugin(path18);
+      console.log(`✅ Plugin uninstalled: ${path18}`);
     } catch (error) {
       console.error(`❌ Error uninstalling plugin: ${error.message}`);
       process.exit(1);
@@ -8650,109 +9266,12 @@ function createPluginsCommand() {
 
 // src/commands/skills.ts
 init_settings_manager();
-
-// src/skills/manager.ts
-init_settings_manager();
-import fs17 from "fs/promises";
-import path16 from "path";
-
-class SkillsManager {
-  static instance;
-  skillsPath;
-  constructor() {
-    this.skillsPath = path16.join(getSettingsManager().getStorageDirectory(), "skills");
-  }
-  static getInstance() {
-    if (!SkillsManager.instance) {
-      SkillsManager.instance = new SkillsManager;
-    }
-    return SkillsManager.instance;
-  }
-  async ensureSkillsDirectory() {
-    try {
-      await fs17.mkdir(this.skillsPath, { recursive: true });
-    } catch (error) {}
-  }
-  async listSkills() {
-    await this.ensureSkillsDirectory();
-    try {
-      const files = await fs17.readdir(this.skillsPath);
-      return files.filter((file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".json")).map((file) => path16.parse(file).name);
-    } catch (error) {
-      return [];
-    }
-  }
-  async getSkillPath(name) {
-    const extensions = [".ts", ".js", ".json"];
-    for (const ext of extensions) {
-      const fullPath = path16.join(this.skillsPath, `${name}${ext}`);
-      try {
-        await fs17.access(fullPath);
-        return fullPath;
-      } catch {
-        continue;
-      }
-    }
-    throw new Error(`Skill '${name}' not found`);
-  }
-  async getSkillContent(name) {
-    const skillPath = await this.getSkillPath(name);
-    return await fs17.readFile(skillPath, "utf-8");
-  }
-  async createSkill(name, description, agent) {
-    await this.ensureSkillsDirectory();
-    const prompt = `Create a robust TypeScript skill for the Super Agent CLI named "${name}".
-    
-    Description: ${description}
-    
-    The skill should be a module that exports a default function or class that implements the desired functionality.
-    It should valid standalone TypeScript code.
-    Include comments explaining how it works.
-    
-    Structure:
-    \`\`\`typescript
-    // ${name} skill
-    export default async function(args: any) {
-      // implementation
-    }
-    \`\`\`
-    
-    Return ONLY the code block.`;
-    const response = await agent.processUserMessage(prompt);
-    let code = "";
-    for (const entry of response) {
-      if (entry.type === "assistant") {
-        const match = entry.content.match(/```(?:typescript|ts)?\n([\s\S]*?)```/);
-        if (match) {
-          code = match[1];
-          break;
-        } else {
-          code = entry.content;
-        }
-      }
-    }
-    if (!code) {
-      throw new Error("Failed to generate skill code");
-    }
-    const filePath = path16.join(this.skillsPath, `${name}.ts`);
-    await fs17.writeFile(filePath, code);
-  }
-  async deleteSkill(name) {
-    try {
-      const skillPath = await this.getSkillPath(name);
-      await fs17.unlink(skillPath);
-    } catch (error) {
-      throw new Error(`Failed to delete skill '${name}': ${error.message}`);
-    }
-  }
-}
-
-// src/commands/skills.ts
-import { Command as Command4 } from "commander";
-import inquirer from "inquirer";
-import chalk3 from "chalk";
+init_manager2();
+import { Command as Command5 } from "commander";
+import inquirer2 from "inquirer";
+import chalk4 from "chalk";
 function createSkillsCommand() {
-  const skillsCommand = new Command4("skills").description("Manage AI skills");
+  const skillsCommand = new Command5("skills").description("Manage AI skills");
   skillsCommand.command("list").description("List available skills").action(async () => {
     const manager = SkillsManager.getInstance();
     const skills = await manager.listSkills();
@@ -8769,7 +9288,7 @@ function createSkillsCommand() {
       const settingsManager = getSettingsManager();
       let description = options.description;
       if (!description) {
-        const answer = await inquirer.prompt([
+        const answer = await inquirer2.prompt([
           {
             type: "input",
             name: "description",
@@ -8778,146 +9297,136 @@ function createSkillsCommand() {
         ]);
         description = answer.description;
       }
-      console.log(chalk3.blue(`Generating skill '${name}' based on description: "${description}"...`));
+      console.log(chalk4.blue(`Generating skill '${name}' based on description: "${description}"...`));
       const apiKey = settingsManager.getApiKey();
       const baseURL = settingsManager.getBaseURL();
       const model = settingsManager.getCurrentModel();
       if (!apiKey) {
-        console.error(chalk3.red("API Key not found. Please configure it first."));
+        console.error(chalk4.red("API Key not found. Please configure it first."));
         return;
       }
       const agent = new SuperAgent(apiKey, baseURL, model);
       await manager.createSkill(name, description, agent);
-      console.log(chalk3.green(`✓ Skill '${name}' created successfully.`));
+      console.log(chalk4.green(`✓ Skill '${name}' created successfully.`));
     } catch (error) {
-      console.error(chalk3.red(`Error creating skill: ${error.message}`));
+      console.error(chalk4.red(`Error creating skill: ${error.message}`));
     }
   });
   skillsCommand.command("delete <name>").description("Delete a skill").action(async (name) => {
     try {
       const manager = SkillsManager.getInstance();
       await manager.deleteSkill(name);
-      console.log(chalk3.green(`✓ Skill '${name}' deleted.`));
+      console.log(chalk4.green(`✓ Skill '${name}' deleted.`));
     } catch (error) {
-      console.error(chalk3.red(`Error deleting skill: ${error.message}`));
+      console.error(chalk4.red(`Error deleting skill: ${error.message}`));
     }
   });
   return skillsCommand;
 }
 
-// src/commands/agents.ts
-init_settings_manager();
-
-// src/agents/manager.ts
+// src/commands/import.ts
 init_settings_manager();
-import fs18 from "fs/promises";
-import path17 from "path";
-
-class AgentsManager {
-  static instance;
-  agentsPath;
-  constructor() {
-    this.agentsPath = path17.join(getSettingsManager().getStorageDirectory(), "agents");
-  }
-  static getInstance() {
-    if (!AgentsManager.instance) {
-      AgentsManager.instance = new AgentsManager;
+init_file_utils();
+init_manager2();
+init_manager();
+import { Command as Command6 } from "commander";
+import fs19 from "fs-extra";
+import chalk5 from "chalk";
+import path18 from "path";
+function createImportCommand() {
+  const cmd = new Command6("import").description("Import resources from other AI assistants");
+  cmd.command("agents <source>").description("Import agents from source (gemini, claude, kilo)").action(async (source) => {
+    const sourcePath = resolveSourcePath(source);
+    const agentsDir = path18.join(sourcePath, "agents");
+    if (!await fs19.pathExists(agentsDir)) {
+      console.error(chalk5.red(`Agents directory not found at ${agentsDir}`));
+      return;
     }
-    return AgentsManager.instance;
-  }
-  async ensureAgentsDirectory() {
-    try {
-      await fs18.mkdir(this.agentsPath, { recursive: true });
-    } catch (error) {}
-  }
-  async listAgents() {
-    await this.ensureAgentsDirectory();
-    try {
-      const files = await fs18.readdir(this.agentsPath);
-      const agents = [];
-      for (const file of files) {
-        if (file.endsWith(".json")) {
-          try {
-            const content = await fs18.readFile(path17.join(this.agentsPath, file), "utf-8");
-            agents.push(JSON.parse(content));
-          } catch (e) {}
+    const files = await fs19.readdir(agentsDir);
+    const manager = AgentsManager.getInstance();
+    let count = 0;
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = await fs19.readJson(path18.join(agentsDir, file));
+          const agentConfig = {
+            name: content.name || path18.parse(file).name,
+            role: content.role || "Assistant",
+            description: content.description || "Imported agent",
+            model: content.model,
+            tools: content.tools,
+            temperature: content.temperature,
+            systemPrompt: content.systemPrompt || content.system_prompt || content.prompt
+          };
+          await manager.createAgent(agentConfig);
+          console.log(chalk5.green(`Imported agent: ${agentConfig.name}`));
+          count++;
+        } catch (error) {
+          console.warn(chalk5.yellow(`Failed to import ${file}: ${error.message}`));
         }
       }
-      return agents;
-    } catch (error) {
-      return [];
-    }
-  }
-  async getAgent(name) {
-    try {
-      const content = await fs18.readFile(path17.join(this.agentsPath, `${name}.json`), "utf-8");
-      return JSON.parse(content);
-    } catch (error) {
-      return null;
     }
-  }
-  async createAgent(config) {
-    await this.ensureAgentsDirectory();
-    const filePath = path17.join(this.agentsPath, `${config.name}.json`);
-    await fs18.writeFile(filePath, JSON.stringify(config, null, 2));
-  }
-  async generateAgent(name, description, agent) {
-    const prompt = `Create a configuration for an AI agent named "${name}" based on this description: "${description}".
-    
-    The configuration should be a JSON object matching this interface:
-    interface AgentConfig {
-      name: string;
-      role: string;
-      description: string;
-      model?: string; // suggest a model if appropriate, or leave undefined
-      tools?: string[]; // suggest relevant tools/skills names
-      temperature?: number;
-      systemPrompt?: string; // a detailed system prompt for this agent
+    console.log(chalk5.bold(`Imported ${count} agents.`));
+  });
+  cmd.command("skills <source>").description("Import skills from source (gemini, claude, kilo)").action(async (source) => {
+    const sourcePath = resolveSourcePath(source);
+    const skillsDir = path18.join(sourcePath, "skills");
+    if (!await fs19.pathExists(skillsDir)) {
+      console.error(chalk5.red(`Skills directory not found at ${skillsDir}`));
+      return;
     }
-    
-    Return ONLY the JSON object.`;
-    const response = await agent.processUserMessage(prompt);
-    let jsonData = "";
-    for (const entry of response) {
-      if (entry.type === "assistant") {
-        const match = entry.content.match(/```(?:json)?\n([\s\S]*?)```/);
-        if (match) {
-          jsonData = match[1];
-          break;
-        } else {
-          if (entry.content.trim().startsWith("{")) {
-            jsonData = entry.content;
-          }
+    const files = await fs19.readdir(skillsDir);
+    const manager = SkillsManager.getInstance();
+    let count = 0;
+    for (const file of files) {
+      if (file.endsWith(".ts") || file.endsWith(".js")) {
+        try {
+          const content = await fs19.readFile(path18.join(skillsDir, file), "utf-8");
+          const name = path18.parse(file).name;
+          await manager.saveSkill(name, content);
+          console.log(chalk5.green(`Imported skill: ${name}`));
+          count++;
+        } catch (error) {
+          console.warn(chalk5.yellow(`Failed to import ${file}: ${error.message}`));
         }
       }
     }
-    if (!jsonData) {
-      throw new Error("Failed to generate agent configuration");
-    }
-    try {
-      const config = JSON.parse(jsonData);
-      config.name = name;
-      await this.createAgent(config);
-    } catch (e) {
-      throw new Error(`Failed to parse generated agent config: ${e.message}`);
+    console.log(chalk5.bold(`Imported ${count} skills.`));
+  });
+  cmd.command("hooks <source>").description("Import hooks from source settings").action(async (source) => {
+    const sourcePath = resolveSourcePath(source);
+    const settingsFile = source.toLowerCase() === "claude" ? "settings.local.json" : "settings.json";
+    const fullPath = path18.join(sourcePath, settingsFile);
+    if (!await fs19.pathExists(fullPath)) {
+      console.error(chalk5.red(`Settings file not found at ${fullPath}`));
+      return;
     }
-  }
-  async deleteAgent(name) {
     try {
-      const filePath = path17.join(this.agentsPath, `${name}.json`);
-      await fs18.unlink(filePath);
+      const settings = await fs19.readJson(fullPath);
+      if (settings.hooks) {
+        const manager = getSettingsManager();
+        const currentHooks = manager.getUserSetting("hooks") || {};
+        const mergedHooks = { ...currentHooks, ...settings.hooks };
+        manager.updateUserSetting("hooks", mergedHooks);
+        console.log(chalk5.green(`Imported ${Object.keys(settings.hooks).length} hooks.`));
+      } else {
+        console.log(chalk5.yellow("No hooks found in settings file."));
+      }
     } catch (error) {
-      throw new Error(`Failed to delete agent '${name}'`);
+      console.error(chalk5.red(`Failed to import hooks: ${error.message}`));
     }
-  }
+  });
+  return cmd;
 }
 
 // src/commands/agents.ts
-import { Command as Command5 } from "commander";
-import inquirer2 from "inquirer";
-import chalk4 from "chalk";
+init_settings_manager();
+init_manager();
+import { Command as Command7 } from "commander";
+import inquirer3 from "inquirer";
+import chalk6 from "chalk";
 function createAgentsCommand() {
-  const agentsCommand = new Command5("agents").description("Manage AI agents");
+  const agentsCommand = new Command7("agents").description("Manage AI agents");
   agentsCommand.command("list").description("List available agents").action(async () => {
     const manager = AgentsManager.getInstance();
     const agents = await manager.listAgents();
@@ -8926,8 +9435,8 @@ function createAgentsCommand() {
     } else {
       console.log("Available agents:");
       agents.forEach((agent) => {
-        console.log(`- ${chalk4.bold(agent.name)} (${agent.role})`);
-        console.log(`  ${chalk4.dim(agent.description)}`);
+        console.log(`- ${chalk6.bold(agent.name)} (${agent.role})`);
+        console.log(`  ${chalk6.dim(agent.description)}`);
       });
     }
   });
@@ -8937,7 +9446,7 @@ function createAgentsCommand() {
       const settingsManager = getSettingsManager();
       let description = options.description;
       if (!description) {
-        const answer = await inquirer2.prompt([
+        const answer = await inquirer3.prompt([
           {
             type: "input",
             name: "description",
@@ -8946,28 +9455,28 @@ function createAgentsCommand() {
         ]);
         description = answer.description;
       }
-      console.log(chalk4.blue(`Generating agent configuration for '${name}'...`));
+      console.log(chalk6.blue(`Generating agent configuration for '${name}'...`));
       const apiKey = settingsManager.getApiKey();
       const baseURL = settingsManager.getBaseURL();
       const model = settingsManager.getCurrentModel();
       if (!apiKey) {
-        console.error(chalk4.red("API Key not found. Please configure it first."));
+        console.error(chalk6.red("API Key not found. Please configure it first."));
         return;
       }
       const agent = new SuperAgent(apiKey, baseURL, model);
       await manager.generateAgent(name, description, agent);
-      console.log(chalk4.green(`✓ Agent '${name}' created successfully.`));
+      console.log(chalk6.green(`✓ Agent '${name}' created successfully.`));
     } catch (error) {
-      console.error(chalk4.red(`Error creating agent: ${error.message}`));
+      console.error(chalk6.red(`Error creating agent: ${error.message}`));
     }
   });
   agentsCommand.command("delete <name>").description("Delete an agent").action(async (name) => {
     try {
       const manager = AgentsManager.getInstance();
       await manager.deleteAgent(name);
-      console.log(chalk4.green(`✓ Agent '${name}' deleted.`));
+      console.log(chalk6.green(`✓ Agent '${name}' deleted.`));
     } catch (error) {
-      console.error(chalk4.red(`Error deleting agent: ${error.message}`));
+      console.error(chalk6.red(`Error deleting agent: ${error.message}`));
     }
   });
   return agentsCommand;
@@ -8975,37 +9484,37 @@ function createAgentsCommand() {
 
 // src/commands/mcp.ts
 init_config();
-import { Command as Command6 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command8 } from "commander";
+import chalk7 from "chalk";
 function createMCPCommand() {
-  const mcpCommand = new Command6("mcp");
+  const mcpCommand = new Command8("mcp");
   mcpCommand.description("Manage MCP (Model Context Protocol) servers");
   mcpCommand.command("add <name>").description("Add an MCP server").option("-t, --transport <type>", "Transport type (stdio, http, sse, streamable_http)", "stdio").option("-c, --command <command>", "Command to run the server (for stdio transport)").option("-a, --args [args...]", "Arguments for the server command (for stdio transport)", []).option("-u, --url <url>", "URL for HTTP/SSE transport").option("-h, --headers [headers...]", "HTTP headers (key=value format)", []).option("-e, --env [env...]", "Environment variables (key=value format)", []).action(async (name, options) => {
     try {
       if (PREDEFINED_SERVERS[name]) {
         const config2 = PREDEFINED_SERVERS[name];
         addMCPServer(config2);
-        console.log(chalk5.green(`✓ Added predefined MCP server: ${name}`));
+        console.log(chalk7.green(`✓ Added predefined MCP server: ${name}`));
         const manager2 = getMCPManager();
         await manager2.addServer(config2);
-        console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
+        console.log(chalk7.green(`✓ Connected to MCP server: ${name}`));
         const tools2 = manager2.getTools().filter((t) => t.serverName === name);
-        console.log(chalk5.blue(`  Available tools: ${tools2.length}`));
+        console.log(chalk7.blue(`  Available tools: ${tools2.length}`));
         return;
       }
       const transportType = options.transport.toLowerCase();
       if (transportType === "stdio") {
         if (!options.command) {
-          console.error(chalk5.red("Error: --command is required for stdio transport"));
+          console.error(chalk7.red("Error: --command is required for stdio transport"));
           process.exit(1);
         }
       } else if (transportType === "http" || transportType === "sse" || transportType === "streamable_http") {
         if (!options.url) {
-          console.error(chalk5.red(`Error: --url is required for ${transportType} transport`));
+          console.error(chalk7.red(`Error: --url is required for ${transportType} transport`));
           process.exit(1);
         }
       } else {
-        console.error(chalk5.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
+        console.error(chalk7.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
         process.exit(1);
       }
       const env = {};
@@ -9034,14 +9543,14 @@ function createMCPCommand() {
         }
       };
       addMCPServer(config);
-      console.log(chalk5.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(config);
-      console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk7.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk5.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -9051,7 +9560,7 @@ function createMCPCommand() {
       try {
         config = JSON.parse(jsonConfig);
       } catch (error) {
-        console.error(chalk5.red("Error: Invalid JSON configuration"));
+        console.error(chalk7.red("Error: Invalid JSON configuration"));
         process.exit(1);
       }
       const serverConfig = {
@@ -9076,14 +9585,14 @@ function createMCPCommand() {
         }
       }
       addMCPServer(serverConfig);
-      console.log(chalk5.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
-      console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk7.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk5.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -9092,9 +9601,9 @@ function createMCPCommand() {
       const manager = getMCPManager();
       await manager.removeServer(name);
       removeMCPServer(name);
-      console.log(chalk5.green(`✓ Removed MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Removed MCP server: ${name}`));
     } catch (error) {
-      console.error(chalk5.red(`Error removing MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error removing MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -9102,15 +9611,15 @@ function createMCPCommand() {
     const config = loadMCPConfig();
     const manager = getMCPManager();
     if (config.servers.length === 0) {
-      console.log(chalk5.yellow("No MCP servers configured"));
+      console.log(chalk7.yellow("No MCP servers configured"));
       return;
     }
-    console.log(chalk5.bold("Configured MCP servers:"));
+    console.log(chalk7.bold("Configured MCP servers:"));
     console.log();
     for (const server of config.servers) {
       const isConnected = manager.getServers().includes(server.name);
-      const status = isConnected ? chalk5.green("✓ Connected") : chalk5.red("✗ Disconnected");
-      console.log(`${chalk5.bold(server.name)}: ${status}`);
+      const status = isConnected ? chalk7.green("✓ Connected") : chalk7.red("✗ Disconnected");
+      console.log(`${chalk7.bold(server.name)}: ${status}`);
       if (server.transport) {
         console.log(`  Transport: ${server.transport.type}`);
         if (server.transport.type === "stdio") {
@@ -9143,15 +9652,15 @@ function createMCPCommand() {
       const config = loadMCPConfig();
       const serverConfig = config.servers.find((s) => s.name === name);
       if (!serverConfig) {
-        console.error(chalk5.red(`Server ${name} not found`));
+        console.error(chalk7.red(`Server ${name} not found`));
         process.exit(1);
       }
-      console.log(chalk5.blue(`Testing connection to ${name}...`));
+      console.log(chalk7.blue(`Testing connection to ${name}...`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk5.green(`✓ Successfully connected to ${name}`));
-      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk7.green(`✓ Successfully connected to ${name}`));
+      console.log(chalk7.blue(`  Available tools: ${tools.length}`));
       if (tools.length > 0) {
         console.log("  Tools:");
         tools.forEach((tool) => {
@@ -9160,7 +9669,7 @@ function createMCPCommand() {
         });
       }
     } catch (error) {
-      console.error(chalk5.red(`✗ Failed to connect to ${name}: ${error.message}`));
+      console.error(chalk7.red(`✗ Failed to connect to ${name}: ${error.message}`));
       process.exit(1);
     }
   });
@@ -9169,7 +9678,7 @@ function createMCPCommand() {
 
 // src/commands/git.ts
 init_settings_manager();
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 async function loadApiKey() {
   const manager = getSettingsManager();
   return manager.getApiKey();
@@ -9273,7 +9782,7 @@ Respond with ONLY the commit message, no additional text.`;
   }
 }
 function createGitCommand() {
-  const gitCommand = new Command7("git").description("Git operations with AI assistance");
+  const gitCommand = new Command9("git").description("Git operations with AI assistance");
   gitCommand.command("commit-and-push").description("Generate AI commit message and push to remote").option("-d, --directory <dir>", "set working directory", process.cwd()).option("-k, --api-key <key>", "Super Agent API key (or set SUPER_AGENT_API_KEY env var)").option("-u, --base-url <url>", "Super Agent API base URL (or set SUPER_AGENT_BASE_URL env var)").option("-m, --model <model>", "AI model to use (e.g., GLM-4.7) (or set SUPER_AGENT_MODEL env var)").option("--max-tool-rounds <rounds>", "maximum number of tool execution rounds (default: 400)", "400").action(async (options) => {
     if (options.directory) {
       try {
@@ -9313,6 +9822,8 @@ function registerCommands(program) {
   program.addCommand(createServeCommand());
   program.addCommand(createSkillsCommand());
   program.addCommand(createAgentsCommand());
+  program.addCommand(createImportCommand());
+  program.addCommand(createProviderCommand());
   program.addCommand(createIndexCommand());
 }