@involvex/super-agent-cli 0.0.61 → 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,
@@ -536,16 +863,130 @@ var init_indexer = __esm(() => {
   init_settings_manager();
 });
 
+// src/utils/session-manager.ts
+var exports_session_manager = {};
+__export(exports_session_manager, {
+  getSessionManager: () => getSessionManager,
+  SessionManager: () => SessionManager
+});
+import * as fs15 from "fs-extra";
+import * as path14 from "path";
+
+class SessionManager {
+  static instance;
+  sessionsDir;
+  currentSession = null;
+  constructor() {
+    const settingsManager = getSettingsManager();
+    this.sessionsDir = path14.join(settingsManager.getStorageDirectory(), "sessions");
+    fs15.ensureDirSync(this.sessionsDir);
+  }
+  static getInstance() {
+    if (!SessionManager.instance) {
+      SessionManager.instance = new SessionManager;
+    }
+    return SessionManager.instance;
+  }
+  generateSessionId(workingDir) {
+    const normalized = path14.normalize(workingDir).toLowerCase();
+    return Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
+  }
+  getSessionFilePath(sessionId) {
+    return path14.join(this.sessionsDir, `${sessionId}.json`);
+  }
+  async getOrCreateSession(workingDirectory, name) {
+    const sessionId = this.generateSessionId(workingDirectory);
+    const sessionFile = this.getSessionFilePath(sessionId);
+    try {
+      if (await fs15.pathExists(sessionFile)) {
+        const session = await fs15.readJson(sessionFile);
+        session.lastAccessed = Date.now();
+        this.currentSession = session;
+        await this.saveSession(session);
+        return session;
+      }
+    } catch (error) {}
+    const newSession = {
+      id: sessionId,
+      workingDirectory,
+      name: name || path14.basename(workingDirectory),
+      messages: [],
+      lastAccessed: Date.now(),
+      createdAt: Date.now()
+    };
+    this.currentSession = newSession;
+    await this.saveSession(newSession);
+    return newSession;
+  }
+  async saveSession(session) {
+    const sessionFile = this.getSessionFilePath(session.id);
+    await fs15.outputJson(sessionFile, session, { spaces: 2 });
+  }
+  async addMessage(message) {
+    if (!this.currentSession) {
+      throw new Error("No active session");
+    }
+    this.currentSession.messages.push(message);
+    this.currentSession.lastAccessed = Date.now();
+    await this.saveSession(this.currentSession);
+  }
+  async listSessions() {
+    const sessionFiles = await fs15.readdir(this.sessionsDir);
+    const sessions = [];
+    for (const file of sessionFiles) {
+      if (file.endsWith(".json")) {
+        try {
+          const session = await fs15.readJson(path14.join(this.sessionsDir, file));
+          sessions.push(session);
+        } catch (error) {}
+      }
+    }
+    sessions.sort((a, b) => b.lastAccessed - a.lastAccessed);
+    return sessions;
+  }
+  async deleteSession(sessionId) {
+    const sessionFile = this.getSessionFilePath(sessionId);
+    if (await fs15.pathExists(sessionFile)) {
+      await fs15.remove(sessionFile);
+    }
+  }
+  getCurrentSession() {
+    return this.currentSession;
+  }
+  async switchSession(sessionId) {
+    const sessionFile = this.getSessionFilePath(sessionId);
+    try {
+      if (await fs15.pathExists(sessionFile)) {
+        const session = await fs15.readJson(sessionFile);
+        session.lastAccessed = Date.now();
+        this.currentSession = session;
+        await this.saveSession(session);
+        return session;
+      }
+    } catch (error) {}
+    return null;
+  }
+}
+function getSessionManager() {
+  return SessionManager.getInstance();
+}
+var init_session_manager = __esm(() => {
+  init_settings_manager();
+});
+
 // package.json
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@involvex/super-agent-cli",
-    version: "0.0.61",
+    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/",
@@ -592,6 +1033,7 @@ var require_package = __commonJS((exports, module) => {
     dependencies: {
       "@google/generative-ai": "^0.24.1",
       "@modelcontextprotocol/sdk": "^1.25.3",
+      "@types/mime": "^4.0.0",
       axios: "^1.13.4",
       cfonts: "^3.3.1",
       chalk: "^5.6.2",
@@ -600,7 +1042,9 @@ var require_package = __commonJS((exports, module) => {
       dotenv: "^17.2.3",
       enquirer: "^2.4.1",
       "fs-extra": "^11.3.3",
+      ignore: "^7.0.5",
       ink: "^6.6.0",
+      inquirer: "^13.2.2",
       marked: "^17.0.1",
       "marked-terminal": "^7.3.0",
       mime: "^4.1.0",
@@ -638,46 +1082,14 @@ var require_package = __commonJS((exports, module) => {
   };
 });
 
-// src/utils/banner.ts
-var exports_banner = {};
-__export(exports_banner, {
-  HELP_BANNER: () => HELP_BANNER,
-  BANNER: () => BANNER
-});
-var BANNER = `
-╔═══════════════════════════════════════════════════════════════╗
-║                                                               ║
-║   ███████╗██╗   ██╗██████╗ ███████╗██████╗                   ║
-║   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔══██╗                  ║
-║   ███████╗██║   ██║██████╔╝█████╗  ██████╔╝                  ║
-║   ╚════██║██║   ██║██╔═══╝ ██╔══╝  ██╔══██╗                  ║
-║   ███████║╚██████╔╝██║     ███████╗██║  ██║                  ║
-║   ╚══════╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝                  ║
-║                                                               ║
-║    █████╗  ██████╗ ███████╗███╗   ██╗████████╗               ║
-║   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝               ║
-║   ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║                  ║
-║   ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║                  ║
-║   ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║                  ║
-║   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝                  ║
-║                                                               ║
-║            \uD83E\uDD16 AI-Powered Terminal Assistant                   ║
-║                                                               ║
-╚═══════════════════════════════════════════════════════════════╝
-`, HELP_BANNER = `
-╔═══════════════════════════════════════════╗
-║      \uD83E\uDD16 SUPER AGENT - Help & Usage       ║
-╚═══════════════════════════════════════════╝
-`;
-
 // src/utils/update-checker.ts
 var exports_update_checker = {};
 __export(exports_update_checker, {
   getUpdateChecker: () => getUpdateChecker,
   UpdateChecker: () => UpdateChecker
 });
-import * as fs13 from "fs-extra";
-import * as path12 from "path";
+import * as fs16 from "fs-extra";
+import * as path15 from "path";
 import axios3 from "axios";
 
 class UpdateChecker {
@@ -686,7 +1098,7 @@ class UpdateChecker {
   currentVersion;
   constructor(currentVersion) {
     const settingsManager = getSettingsManager();
-    this.cacheFile = path12.join(settingsManager.getStorageDirectory(), "update-cache.json");
+    this.cacheFile = path15.join(settingsManager.getStorageDirectory(), "update-cache.json");
     this.currentVersion = currentVersion;
   }
   static getInstance(currentVersion) {
@@ -697,8 +1109,8 @@ class UpdateChecker {
   }
   async loadCache() {
     try {
-      if (await fs13.pathExists(this.cacheFile)) {
-        const cache = await fs13.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;
@@ -709,7 +1121,7 @@ class UpdateChecker {
   }
   async saveCache(info) {
     try {
-      await fs13.outputJson(this.cacheFile, info);
+      await fs16.outputJson(this.cacheFile, info);
     } catch (error) {}
   }
   compareVersions(v1, v2) {
@@ -778,724 +1190,333 @@ var init_update_checker = __esm(() => {
   CACHE_DURATION = 24 * 60 * 60 * 1000;
 });
 
-// src/utils/session-manager.ts
-var exports_session_manager = {};
-__export(exports_session_manager, {
-  getSessionManager: () => getSessionManager,
-  SessionManager: () => SessionManager
+// src/utils/banner.ts
+var exports_banner = {};
+__export(exports_banner, {
+  HELP_BANNER: () => HELP_BANNER,
+  BANNER: () => BANNER
 });
-import * as fs14 from "fs-extra";
-import * as path13 from "path";
+var BANNER = `
+╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║   ███████╗██╗   ██╗██████╗ ███████╗██████╗                   ║
+║   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔══██╗                  ║
+║   ███████╗██║   ██║██████╔╝█████╗  ██████╔╝                  ║
+║   ╚════██║██║   ██║██╔═══╝ ██╔══╝  ██╔══██╗                  ║
+║   ███████║╚██████╔╝██║     ███████╗██║  ██║                  ║
+║   ╚══════╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝                  ║
+║                                                               ║
+║    █████╗  ██████╗ ███████╗███╗   ██╗████████╗               ║
+║   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝               ║
+║   ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║                  ║
+║   ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║                  ║
+║   ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║                  ║
+║   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝                  ║
+║                                                               ║
+║            \uD83E\uDD16 AI-Powered Terminal Assistant                   ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+`, HELP_BANNER = `
+╔═══════════════════════════════════════════╗
+║      \uD83E\uDD16 SUPER AGENT - Help & Usage       ║
+╚═══════════════════════════════════════════╝
+`;
 
-class SessionManager {
+// src/utils/confirmation-service.ts
+import { EventEmitter } from "events";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+class ConfirmationService extends EventEmitter {
   static instance;
-  sessionsDir;
-  currentSession = null;
-  constructor() {
-    const settingsManager = getSettingsManager();
-    this.sessionsDir = path13.join(settingsManager.getStorageDirectory(), "sessions");
-    fs14.ensureDirSync(this.sessionsDir);
-  }
+  skipConfirmationThisSession = false;
+  pendingConfirmation = null;
+  resolveConfirmation = null;
+  sessionFlags = {
+    fileOperations: false,
+    bashCommands: false,
+    allOperations: false
+  };
   static getInstance() {
-    if (!SessionManager.instance) {
-      SessionManager.instance = new SessionManager;
+    if (!ConfirmationService.instance) {
+      ConfirmationService.instance = new ConfirmationService;
     }
-    return SessionManager.instance;
-  }
-  generateSessionId(workingDir) {
-    const normalized = path13.normalize(workingDir).toLowerCase();
-    return Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
+    return ConfirmationService.instance;
   }
-  getSessionFilePath(sessionId) {
-    return path13.join(this.sessionsDir, `${sessionId}.json`);
+  constructor() {
+    super();
   }
-  async getOrCreateSession(workingDirectory, name) {
-    const sessionId = this.generateSessionId(workingDirectory);
-    const sessionFile = this.getSessionFilePath(sessionId);
-    try {
-      if (await fs14.pathExists(sessionFile)) {
-        const session = await fs14.readJson(sessionFile);
-        session.lastAccessed = Date.now();
-        this.currentSession = session;
-        await this.saveSession(session);
-        return session;
+  async requestConfirmation(options, operationType = "file") {
+    if (this.sessionFlags.allOperations || operationType === "file" && this.sessionFlags.fileOperations || operationType === "bash" && this.sessionFlags.bashCommands) {
+      return { confirmed: true };
+    }
+    if (options.showVSCodeOpen) {
+      try {
+        await this.openInVSCode(options.filename);
+      } catch (error) {
+        options.showVSCodeOpen = false;
       }
-    } catch (error) {}
-    const newSession = {
-      id: sessionId,
-      workingDirectory,
-      name: name || path13.basename(workingDirectory),
-      messages: [],
-      lastAccessed: Date.now(),
-      createdAt: Date.now()
-    };
-    this.currentSession = newSession;
-    await this.saveSession(newSession);
-    return newSession;
+    }
+    this.pendingConfirmation = new Promise((resolve) => {
+      this.resolveConfirmation = resolve;
+    });
+    setImmediate(() => {
+      this.emit("confirmation-requested", options);
+    });
+    const result = await this.pendingConfirmation;
+    if (result.dontAskAgain) {
+      if (operationType === "file") {
+        this.sessionFlags.fileOperations = true;
+      } else if (operationType === "bash") {
+        this.sessionFlags.bashCommands = true;
+      }
+    }
+    return result;
   }
-  async saveSession(session) {
-    const sessionFile = this.getSessionFilePath(session.id);
-    await fs14.outputJson(sessionFile, session, { spaces: 2 });
+  confirmOperation(confirmed, dontAskAgain) {
+    if (this.resolveConfirmation) {
+      this.resolveConfirmation({ confirmed, dontAskAgain });
+      this.resolveConfirmation = null;
+      this.pendingConfirmation = null;
+    }
   }
-  async addMessage(message) {
-    if (!this.currentSession) {
-      throw new Error("No active session");
+  rejectOperation(feedback) {
+    if (this.resolveConfirmation) {
+      this.resolveConfirmation({ confirmed: false, feedback });
+      this.resolveConfirmation = null;
+      this.pendingConfirmation = null;
     }
-    this.currentSession.messages.push(message);
-    this.currentSession.lastAccessed = Date.now();
-    await this.saveSession(this.currentSession);
   }
-  async listSessions() {
-    const sessionFiles = await fs14.readdir(this.sessionsDir);
-    const sessions = [];
-    for (const file of sessionFiles) {
-      if (file.endsWith(".json")) {
-        try {
-          const session = await fs14.readJson(path13.join(this.sessionsDir, file));
-          sessions.push(session);
-        } catch (error) {}
+  async openInVSCode(filename) {
+    const commands = ["code", "code-insiders", "codium"];
+    for (const cmd of commands) {
+      try {
+        await execAsync(`which ${cmd}`);
+        await execAsync(`${cmd} "${filename}"`);
+        return;
+      } catch (error) {
+        continue;
       }
     }
-    sessions.sort((a, b) => b.lastAccessed - a.lastAccessed);
-    return sessions;
+    throw new Error("VS Code not found");
   }
-  async deleteSession(sessionId) {
-    const sessionFile = this.getSessionFilePath(sessionId);
-    if (await fs14.pathExists(sessionFile)) {
-      await fs14.remove(sessionFile);
-    }
+  isPending() {
+    return this.pendingConfirmation !== null;
   }
-  getCurrentSession() {
-    return this.currentSession;
+  resetSession() {
+    this.sessionFlags = {
+      fileOperations: false,
+      bashCommands: false,
+      allOperations: false
+    };
   }
-  async switchSession(sessionId) {
-    const sessionFile = this.getSessionFilePath(sessionId);
-    try {
-      if (await fs14.pathExists(sessionFile)) {
-        const session = await fs14.readJson(sessionFile);
-        session.lastAccessed = Date.now();
-        this.currentSession = session;
-        await this.saveSession(session);
-        return session;
-      }
-    } catch (error) {}
-    return null;
+  getSessionFlags() {
+    return { ...this.sessionFlags };
+  }
+  setSessionFlag(flagType, value) {
+    this.sessionFlags[flagType] = value;
   }
 }
-function getSessionManager() {
-  return SessionManager.getInstance();
-}
-var init_session_manager = __esm(() => {
-  init_settings_manager();
-});
 
-// src/web/server.ts
-var exports_server = {};
-__export(exports_server, {
-  WebServer: () => WebServer
-});
-import { createServer } from "http";
-import { WebSocketServer } from "ws";
-import * as fs15 from "fs-extra";
-import * as path14 from "path";
-import open from "open";
-import mime from "mime";
+// src/index.ts
+init_settings_manager();
 
-class WebServer {
-  httpServer;
-  wss;
-  agent;
-  hostname;
-  port;
-  clients = new Set;
-  constructor(options) {
-    this.hostname = options.hostname || "localhost";
-    this.port = options.port || 3000;
-    this.agent = options.agent;
-    this.httpServer = createServer((req, res) => {
-      this.handleHttpRequest(req, res);
-    });
-    this.wss = new WebSocketServer({ server: this.httpServer });
-    this.wss.on("connection", (ws) => {
-      this.handleWebSocketConnection(ws);
-    });
+// src/hooks/use-input-handler.ts
+init_file_utils();
+
+// src/utils/text-utils.ts
+function isWordBoundary(char) {
+  if (!char) {
+    return true;
   }
-  async handleHttpRequest(req, res) {
-    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));
-    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);
-        let filePath = absolutePath;
-        if (stat5.isDirectory()) {
-          filePath = path14.join(absolutePath, "index.html");
-        }
-        const content = await fs15.readFile(filePath);
-        const mimeType = mime.getType(filePath) || "application/octet-stream";
-        res.writeHead(200, { "Content-Type": mimeType });
-        res.end(content);
-      } else {
-        res.writeHead(404);
-        res.end("Not Found");
-      }
-    } catch (error) {
-      console.error("Error serving file:", error);
-      res.writeHead(500);
-      res.end("Internal Server Error");
-    }
+  return /\s/.test(char) || /[^\w]/.test(char);
+}
+function moveToPreviousWord(text, position) {
+  if (position <= 0) {
+    return 0;
   }
-  handleWebSocketConnection(ws) {
-    this.clients.add(ws);
-    console.log(`\uD83D\uDCE1 Web client connected (${this.clients.size} total)`);
-    this.checkAndSendUpdateNotification(ws);
-    ws.on("message", async (data) => {
-      try {
-        const message = JSON.parse(data.toString());
-        if (message.type === "prompt") {
-          await this.handlePrompt(message.content, ws);
-        } else if (message.type === "get_file_tree") {
-          await this.handleGetFileTree(ws);
-        } else if (message.type === "get_file_content") {
-          await this.handleGetFileContent(message.path, ws);
-        } else if (message.type === "list_sessions") {
-          await this.handleListSessions(ws);
-        } else if (message.type === "switch_session") {
-          await this.handleSwitchSession(message.sessionId, ws);
-        }
-      } catch (error) {
-        console.error("WebSocket message error:", error);
-        ws.send(JSON.stringify({ type: "error", content: "Invalid message format" }));
-      }
-    });
-    ws.on("close", () => {
-      this.clients.delete(ws);
-      console.log(`\uD83D\uDCE1 Web client disconnected (${this.clients.size} remaining)`);
-    });
-    ws.on("error", (error) => {
-      console.error("WebSocket error:", error);
-    });
+  let pos = position - 1;
+  while (pos > 0 && isWordBoundary(text[pos])) {
+    pos--;
   }
-  async handlePrompt(prompt, ws) {
-    try {
-      ws.send(JSON.stringify({ type: "user_message", content: prompt }));
-      const entries = await this.agent.processUserMessage(prompt);
-      for (const entry of entries) {
-        if (entry.type === "assistant") {
-          ws.send(JSON.stringify({
-            type: "assistant_message",
-            content: entry.content
-          }));
-        } else if (entry.type === "tool_call") {
-          ws.send(JSON.stringify({
-            type: "tool_call",
-            tool: entry.toolCall?.function.name,
-            content: "Executing..."
-          }));
-        } else if (entry.type === "tool_result") {
-          ws.send(JSON.stringify({
-            type: "tool_result",
-            tool: entry.toolCall?.function.name,
-            content: entry.content
-          }));
-        }
-      }
-      ws.send(JSON.stringify({ type: "done" }));
-    } catch (error) {
-      ws.send(JSON.stringify({
-        type: "error",
-        content: error.message
-      }));
-    }
+  while (pos > 0 && !isWordBoundary(text[pos - 1])) {
+    pos--;
   }
-  async handleGetFileTree(ws) {
-    try {
-      const { getFileIndexer: getFileIndexer2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
-      const indexer = getFileIndexer2();
-      const index = indexer.getIndex();
-      if (!index) {
-        ws.send(JSON.stringify({ type: "file_tree", tree: [] }));
-        return;
-      }
-      const tree = index.entries.filter((e) => !e.path.includes("node_modules") && !e.path.startsWith(".")).map((e) => ({
-        path: e.path,
-        name: path14.basename(e.path),
-        isDirectory: e.isDirectory,
-        size: e.size
-      })).slice(0, 500);
-      ws.send(JSON.stringify({ type: "file_tree", tree }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
+  return pos;
+}
+function moveToNextWord(text, position) {
+  if (position >= text.length) {
+    return text.length;
   }
-  async handleGetFileContent(filePath, ws) {
-    try {
-      const fullPath = path14.join(process.cwd(), filePath);
-      if (!fullPath.startsWith(process.cwd())) {
-        throw new Error("Access denied");
-      }
-      const content = await fs15.readFile(fullPath, "utf-8");
-      ws.send(JSON.stringify({
-        type: "file_content",
-        path: filePath,
-        content: content.slice(0, 1e4)
-      }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
+  let pos = position;
+  while (pos < text.length && !isWordBoundary(text[pos])) {
+    pos++;
   }
-  async handleListSessions(ws) {
-    try {
-      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
-      const sessionManager = getSessionManager2();
-      const sessions = await sessionManager.listSessions();
-      ws.send(JSON.stringify({
-        type: "sessions_list",
-        sessions: sessions.map((s) => ({
-          id: s.id,
-          name: s.name,
-          workingDirectory: s.workingDirectory,
-          messageCount: s.messages.length,
-          lastAccessed: s.lastAccessed
-        }))
-      }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
+  while (pos < text.length && isWordBoundary(text[pos])) {
+    pos++;
   }
-  async handleSwitchSession(sessionId, ws) {
-    try {
-      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
-      const sessionManager = getSessionManager2();
-      const session = await sessionManager.switchSession(sessionId);
-      if (session) {
-        ws.send(JSON.stringify({
-          type: "session_switched",
-          session: {
-            id: session.id,
-            name: session.name,
-            workingDirectory: session.workingDirectory,
-            messages: session.messages
-          }
-        }));
-      } else {
-        throw new Error("Session not found");
-      }
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
+  return pos;
+}
+function deleteWordBefore(text, position) {
+  const wordStart = moveToPreviousWord(text, position);
+  const newText = text.slice(0, wordStart) + text.slice(position);
+  return {
+    text: newText,
+    position: wordStart
+  };
+}
+function deleteWordAfter(text, position) {
+  const wordEnd = moveToNextWord(text, position);
+  const newText = text.slice(0, position) + text.slice(wordEnd);
+  return {
+    text: newText,
+    position
+  };
+}
+function moveToLineStart(text, position) {
+  const beforeCursor = text.slice(0, position);
+  const lastNewlineIndex = beforeCursor.lastIndexOf(`
+`);
+  return lastNewlineIndex === -1 ? 0 : lastNewlineIndex + 1;
+}
+function moveToLineEnd(text, position) {
+  const afterCursor = text.slice(position);
+  const nextNewlineIndex = afterCursor.indexOf(`
+`);
+  return nextNewlineIndex === -1 ? text.length : position + nextNewlineIndex;
+}
+function deleteCharBefore(text, position) {
+  if (position <= 0) {
+    return { text, position };
+  }
+  let deleteCount = 1;
+  const charBefore = text.charAt(position - 1);
+  if (position >= 2) {
+    const charBeforeBefore = text.charAt(position - 2);
+    if (charBeforeBefore >= "\uD800" && charBeforeBefore <= "\uDBFF" && charBefore >= "\uDC00" && charBefore <= "\uDFFF") {
+      deleteCount = 2;
     }
   }
-  async checkAndSendUpdateNotification(ws) {
-    try {
-      const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
-      const { getUpdateChecker: getUpdateChecker2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
-      const updateChecker = getUpdateChecker2(pkg.version);
-      const updateInfo = await updateChecker.checkForUpdates();
-      if (updateInfo?.updateAvailable) {
-        ws.send(JSON.stringify({
-          type: "update_available",
-          currentVersion: updateInfo.currentVersion,
-          latestVersion: updateInfo.latestVersion
-        }));
-      }
-    } catch (error) {}
+  const newText = text.slice(0, position - deleteCount) + text.slice(position);
+  return {
+    text: newText,
+    position: position - deleteCount
+  };
+}
+function deleteCharAfter(text, position) {
+  if (position >= text.length) {
+    return { text, position };
   }
-  async start() {
-    return new Promise((resolve5, reject) => {
-      this.httpServer.listen(this.port, this.hostname, () => {
-        const url = `http://${this.hostname}:${this.port}`;
-        console.log(`\uD83C\uDF10 Web interface available at ${url}`);
-        resolve5();
-      });
-      this.httpServer.on("error", (error) => {
-        reject(error);
-      });
-    });
-  }
-  async openBrowser() {
-    const url = `http://${this.hostname}:${this.port}`;
-    try {
-      await open(url);
-      console.log(`\uD83D\uDE80 Opened browser at ${url}`);
-    } catch (error) {
-      console.warn(`Could not open browser automatically. Please visit ${url}`);
-    }
-  }
-  stop() {
-    this.clients.forEach((client) => {
-      client.close();
-    });
-    this.wss.close();
-    this.httpServer.close();
-    console.log("\uD83D\uDED1 Web server stopped");
+  let deleteCount = 1;
+  const charAfter = text.charAt(position);
+  if (position + 1 < text.length) {
+    const charAfterAfter = text.charAt(position + 1);
+    if (charAfter >= "\uD800" && charAfter <= "\uDBFF" && charAfterAfter >= "\uDC00" && charAfterAfter <= "\uDFFF") {
+      deleteCount = 2;
+    }
   }
+  const newText = text.slice(0, position) + text.slice(position + deleteCount);
+  return {
+    text: newText,
+    position
+  };
 }
-var __dirname = "/home/runner/work/super-agent-cli/super-agent-cli/src/web";
-var init_server = () => {};
-
-// src/utils/confirmation-service.ts
-import { EventEmitter } from "events";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-
-class ConfirmationService extends EventEmitter {
-  static instance;
-  skipConfirmationThisSession = false;
-  pendingConfirmation = null;
-  resolveConfirmation = null;
-  sessionFlags = {
-    fileOperations: false,
-    bashCommands: false,
-    allOperations: false
+function insertText(text, position, insert) {
+  const newText = text.slice(0, position) + insert + text.slice(position);
+  return {
+    text: newText,
+    position: position + insert.length
   };
-  static getInstance() {
-    if (!ConfirmationService.instance) {
-      ConfirmationService.instance = new ConfirmationService;
+}
+
+// src/hooks/use-input-history.ts
+import { useState, useCallback } from "react";
+function useInputHistory() {
+  const [history, setHistory] = useState([]);
+  const [currentIndex, setCurrentIndex] = useState(-1);
+  const [originalInput, setOriginalInput] = useState("");
+  const addToHistory = useCallback((input) => {
+    if (input.trim() && !history.includes(input.trim())) {
+      setHistory((prev) => [...prev, input.trim()]);
     }
-    return ConfirmationService.instance;
-  }
-  constructor() {
-    super();
-  }
-  async requestConfirmation(options, operationType = "file") {
-    if (this.sessionFlags.allOperations || operationType === "file" && this.sessionFlags.fileOperations || operationType === "bash" && this.sessionFlags.bashCommands) {
-      return { confirmed: true };
+    setCurrentIndex(-1);
+    setOriginalInput("");
+  }, [history]);
+  const navigateHistory = useCallback((direction) => {
+    if (history.length === 0) {
+      return null;
     }
-    if (options.showVSCodeOpen) {
-      try {
-        await this.openInVSCode(options.filename);
-      } catch (error) {
-        options.showVSCodeOpen = false;
+    let newIndex;
+    if (direction === "up") {
+      if (currentIndex === -1) {
+        newIndex = history.length - 1;
+      } else {
+        newIndex = Math.max(0, currentIndex - 1);
       }
-    }
-    this.pendingConfirmation = new Promise((resolve) => {
-      this.resolveConfirmation = resolve;
-    });
-    setImmediate(() => {
-      this.emit("confirmation-requested", options);
-    });
-    const result = await this.pendingConfirmation;
-    if (result.dontAskAgain) {
-      if (operationType === "file") {
-        this.sessionFlags.fileOperations = true;
-      } else if (operationType === "bash") {
-        this.sessionFlags.bashCommands = true;
+    } else {
+      if (currentIndex === -1) {
+        return null;
+      } else if (currentIndex === history.length - 1) {
+        newIndex = -1;
+        return originalInput;
+      } else {
+        newIndex = Math.min(history.length - 1, currentIndex + 1);
       }
     }
-    return result;
-  }
-  confirmOperation(confirmed, dontAskAgain) {
-    if (this.resolveConfirmation) {
-      this.resolveConfirmation({ confirmed, dontAskAgain });
-      this.resolveConfirmation = null;
-      this.pendingConfirmation = null;
-    }
-  }
-  rejectOperation(feedback) {
-    if (this.resolveConfirmation) {
-      this.resolveConfirmation({ confirmed: false, feedback });
-      this.resolveConfirmation = null;
-      this.pendingConfirmation = null;
-    }
-  }
-  async openInVSCode(filename) {
-    const commands = ["code", "code-insiders", "codium"];
-    for (const cmd of commands) {
-      try {
-        await execAsync(`which ${cmd}`);
-        await execAsync(`${cmd} "${filename}"`);
-        return;
-      } catch (error) {
-        continue;
-      }
+    setCurrentIndex(newIndex);
+    return newIndex === -1 ? originalInput : history[newIndex];
+  }, [history, currentIndex, originalInput]);
+  const getCurrentHistoryIndex = useCallback(() => currentIndex, [currentIndex]);
+  const resetHistory = useCallback(() => {
+    setHistory([]);
+    setCurrentIndex(-1);
+    setOriginalInput("");
+  }, []);
+  const isNavigatingHistory = useCallback(() => currentIndex !== -1, [currentIndex]);
+  const setOriginalInputCallback = useCallback((input) => {
+    if (currentIndex === -1) {
+      setOriginalInput(input);
     }
-    throw new Error("VS Code not found");
-  }
-  isPending() {
-    return this.pendingConfirmation !== null;
-  }
-  resetSession() {
-    this.sessionFlags = {
-      fileOperations: false,
-      bashCommands: false,
-      allOperations: false
-    };
-  }
-  getSessionFlags() {
-    return { ...this.sessionFlags };
-  }
-  setSessionFlag(flagType, value) {
-    this.sessionFlags[flagType] = value;
-  }
+  }, [currentIndex]);
+  return {
+    addToHistory,
+    navigateHistory,
+    getCurrentHistoryIndex,
+    resetHistory,
+    isNavigatingHistory,
+    setOriginalInput: setOriginalInputCallback
+  };
 }
 
-// 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;
+// src/hooks/use-enhanced-input.ts
+import { useCallback as useCallback2, useRef, useState as useState2 } from "react";
+function useEnhancedInput({
+  onSubmit,
+  onEscape,
+  onSpecialKey,
+  disabled = false,
+  multiline = false
+} = {}) {
+  const [input, setInputState] = useState2("");
+  const [cursorPosition, setCursorPositionState] = useState2(0);
+  const isMultilineRef = useRef(multiline);
+  const {
+    addToHistory,
+    navigateHistory,
+    resetHistory,
+    setOriginalInput,
+    isNavigatingHistory
+  } = useInputHistory();
+  const setInput = useCallback2((text, newCursorPos) => {
+    setInputState(text);
+    if (newCursorPos !== undefined) {
+      setCursorPositionState(Math.max(0, Math.min(text.length, newCursorPos)));
+    } else {
+      setCursorPositionState(Math.min(text.length, cursorPosition));
     }
-    if (bPathLower.startsWith(lowerQuery) && !aPathLower.startsWith(lowerQuery)) {
-      return 1;
-    }
-    return a.path.length - b.path.length;
-  }).slice(0, 20);
-}
-
-// src/utils/text-utils.ts
-function isWordBoundary(char) {
-  if (!char) {
-    return true;
-  }
-  return /\s/.test(char) || /[^\w]/.test(char);
-}
-function moveToPreviousWord(text, position) {
-  if (position <= 0) {
-    return 0;
-  }
-  let pos = position - 1;
-  while (pos > 0 && isWordBoundary(text[pos])) {
-    pos--;
-  }
-  while (pos > 0 && !isWordBoundary(text[pos - 1])) {
-    pos--;
-  }
-  return pos;
-}
-function moveToNextWord(text, position) {
-  if (position >= text.length) {
-    return text.length;
-  }
-  let pos = position;
-  while (pos < text.length && !isWordBoundary(text[pos])) {
-    pos++;
-  }
-  while (pos < text.length && isWordBoundary(text[pos])) {
-    pos++;
-  }
-  return pos;
-}
-function deleteWordBefore(text, position) {
-  const wordStart = moveToPreviousWord(text, position);
-  const newText = text.slice(0, wordStart) + text.slice(position);
-  return {
-    text: newText,
-    position: wordStart
-  };
-}
-function deleteWordAfter(text, position) {
-  const wordEnd = moveToNextWord(text, position);
-  const newText = text.slice(0, position) + text.slice(wordEnd);
-  return {
-    text: newText,
-    position
-  };
-}
-function moveToLineStart(text, position) {
-  const beforeCursor = text.slice(0, position);
-  const lastNewlineIndex = beforeCursor.lastIndexOf(`
-`);
-  return lastNewlineIndex === -1 ? 0 : lastNewlineIndex + 1;
-}
-function moveToLineEnd(text, position) {
-  const afterCursor = text.slice(position);
-  const nextNewlineIndex = afterCursor.indexOf(`
-`);
-  return nextNewlineIndex === -1 ? text.length : position + nextNewlineIndex;
-}
-function deleteCharBefore(text, position) {
-  if (position <= 0) {
-    return { text, position };
-  }
-  let deleteCount = 1;
-  const charBefore = text.charAt(position - 1);
-  if (position >= 2) {
-    const charBeforeBefore = text.charAt(position - 2);
-    if (charBeforeBefore >= "\uD800" && charBeforeBefore <= "\uDBFF" && charBefore >= "\uDC00" && charBefore <= "\uDFFF") {
-      deleteCount = 2;
-    }
-  }
-  const newText = text.slice(0, position - deleteCount) + text.slice(position);
-  return {
-    text: newText,
-    position: position - deleteCount
-  };
-}
-function deleteCharAfter(text, position) {
-  if (position >= text.length) {
-    return { text, position };
-  }
-  let deleteCount = 1;
-  const charAfter = text.charAt(position);
-  if (position + 1 < text.length) {
-    const charAfterAfter = text.charAt(position + 1);
-    if (charAfter >= "\uD800" && charAfter <= "\uDBFF" && charAfterAfter >= "\uDC00" && charAfterAfter <= "\uDFFF") {
-      deleteCount = 2;
-    }
-  }
-  const newText = text.slice(0, position) + text.slice(position + deleteCount);
-  return {
-    text: newText,
-    position
-  };
-}
-function insertText(text, position, insert) {
-  const newText = text.slice(0, position) + insert + text.slice(position);
-  return {
-    text: newText,
-    position: position + insert.length
-  };
-}
-
-// src/hooks/use-input-history.ts
-import { useState, useCallback } from "react";
-function useInputHistory() {
-  const [history, setHistory] = useState([]);
-  const [currentIndex, setCurrentIndex] = useState(-1);
-  const [originalInput, setOriginalInput] = useState("");
-  const addToHistory = useCallback((input) => {
-    if (input.trim() && !history.includes(input.trim())) {
-      setHistory((prev) => [...prev, input.trim()]);
-    }
-    setCurrentIndex(-1);
-    setOriginalInput("");
-  }, [history]);
-  const navigateHistory = useCallback((direction) => {
-    if (history.length === 0) {
-      return null;
-    }
-    let newIndex;
-    if (direction === "up") {
-      if (currentIndex === -1) {
-        newIndex = history.length - 1;
-      } else {
-        newIndex = Math.max(0, currentIndex - 1);
-      }
-    } else {
-      if (currentIndex === -1) {
-        return null;
-      } else if (currentIndex === history.length - 1) {
-        newIndex = -1;
-        return originalInput;
-      } else {
-        newIndex = Math.min(history.length - 1, currentIndex + 1);
-      }
-    }
-    setCurrentIndex(newIndex);
-    return newIndex === -1 ? originalInput : history[newIndex];
-  }, [history, currentIndex, originalInput]);
-  const getCurrentHistoryIndex = useCallback(() => currentIndex, [currentIndex]);
-  const resetHistory = useCallback(() => {
-    setHistory([]);
-    setCurrentIndex(-1);
-    setOriginalInput("");
-  }, []);
-  const isNavigatingHistory = useCallback(() => currentIndex !== -1, [currentIndex]);
-  const setOriginalInputCallback = useCallback((input) => {
-    if (currentIndex === -1) {
-      setOriginalInput(input);
-    }
-  }, [currentIndex]);
-  return {
-    addToHistory,
-    navigateHistory,
-    getCurrentHistoryIndex,
-    resetHistory,
-    isNavigatingHistory,
-    setOriginalInput: setOriginalInputCallback
-  };
-}
-
-// src/hooks/use-enhanced-input.ts
-import { useCallback as useCallback2, useRef, useState as useState2 } from "react";
-function useEnhancedInput({
-  onSubmit,
-  onEscape,
-  onSpecialKey,
-  disabled = false,
-  multiline = false
-} = {}) {
-  const [input, setInputState] = useState2("");
-  const [cursorPosition, setCursorPositionState] = useState2(0);
-  const isMultilineRef = useRef(multiline);
-  const {
-    addToHistory,
-    navigateHistory,
-    resetHistory,
-    setOriginalInput,
-    isNavigatingHistory
-  } = useInputHistory();
-  const setInput = useCallback2((text, newCursorPos) => {
-    setInputState(text);
-    if (newCursorPos !== undefined) {
-      setCursorPositionState(Math.max(0, Math.min(text.length, newCursorPos)));
-    } else {
-      setCursorPositionState(Math.min(text.length, cursorPosition));
-    }
-    if (!isNavigatingHistory()) {
-      setOriginalInput(text);
+    if (!isNavigatingHistory()) {
+      setOriginalInput(text);
     }
   }, [cursorPosition, isNavigatingHistory, setOriginalInput]);
   const setCursorPosition = useCallback2((position) => {
@@ -1747,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()
   }));
@@ -2721,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,
@@ -2863,6 +2884,7 @@ function useInputHandler({
         if (providers.length > 0) {
           const selectedProviderId = providers[selectedProviderIndex];
           manager.updateUserSetting("active_provider", selectedProviderId);
+          setActiveProvider(selectedProviderId);
           setChatHistory((prev) => [
             ...prev,
             {
@@ -2879,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) {
@@ -3074,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();
@@ -3146,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();
@@ -3319,10 +3421,153 @@ ${chats.length ? chats.map((c) => `- ${c}`).join(`
       clearInput();
       return true;
     }
-    if (trimmedInput.startsWith("/plugin ")) {
-      const args = trimmedInput.replace("/plugin ", "").split(" ");
-      const action = args[0];
-      const pluginManager = getPluginManager();
+    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];
+      const pluginManager = getPluginManager();
       try {
         if (action === "list") {
           const plugins = pluginManager.getPlugins();
@@ -3735,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} ---
@@ -3888,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";
@@ -4665,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";
@@ -5303,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 {
@@ -5319,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}`
@@ -5332,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({
@@ -5352,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(`
@@ -5535,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}:
@@ -5547,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) {
@@ -5593,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();
@@ -5628,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;
@@ -5656,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}
 `;
@@ -5678,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);
       }
     }
@@ -5692,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();
@@ -5722,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 {
@@ -5846,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;
           }
@@ -5951,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}:
@@ -5971,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) {
@@ -6011,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(`
 `)) {
@@ -6086,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(`
@@ -6112,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",
@@ -6137,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) {
@@ -6207,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);
@@ -6250,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);
@@ -6707,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;
@@ -8422,39 +8669,852 @@ function ChatInterface({
   }, undefined, false, undefined, this);
 }
 
+// src/commands/web.ts
+init_settings_manager();
+
+// src/web/server.ts
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+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";
+
+class WebServer {
+  httpServer;
+  wss;
+  agent;
+  hostname;
+  port;
+  clients = new Set;
+  constructor(options) {
+    this.hostname = options.hostname || "localhost";
+    this.port = options.port || 3000;
+    this.agent = options.agent;
+    this.httpServer = createServer((req, res) => {
+      this.handleHttpRequest(req, res);
+    });
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.wss.on("connection", (ws) => {
+      this.handleWebSocketConnection(ws);
+    });
+  }
+  async handleHttpRequest(req, res) {
+    const url = req.url || "/";
+    const requestedPath = url === "/" ? "index.html" : url;
+    const sanitizedPath = requestedPath.split("?")[0].split("#")[0];
+    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 fs17.pathExists(absolutePath)) {
+        const stat5 = await fs17.stat(absolutePath);
+        let filePath = absolutePath;
+        if (stat5.isDirectory()) {
+          filePath = path16.join(absolutePath, "index.html");
+        }
+        const content = await fs17.readFile(filePath);
+        const mimeType = mime.getType(filePath) || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": mimeType });
+        res.end(content);
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    } catch (error) {
+      console.error("Error serving file:", error);
+      res.writeHead(500);
+      res.end("Internal Server Error");
+    }
+  }
+  handleWebSocketConnection(ws) {
+    this.clients.add(ws);
+    console.log(`\uD83D\uDCE1 Web client connected (${this.clients.size} total)`);
+    this.checkAndSendUpdateNotification(ws);
+    ws.on("message", async (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "prompt") {
+          await this.handlePrompt(message.content, ws);
+        } else if (message.type === "get_file_tree") {
+          await this.handleGetFileTree(ws);
+        } else if (message.type === "get_file_content") {
+          await this.handleGetFileContent(message.path, ws);
+        } else if (message.type === "list_sessions") {
+          await this.handleListSessions(ws);
+        } else if (message.type === "switch_session") {
+          await this.handleSwitchSession(message.sessionId, ws);
+        }
+      } catch (error) {
+        console.error("WebSocket message error:", error);
+        ws.send(JSON.stringify({ type: "error", content: "Invalid message format" }));
+      }
+    });
+    ws.on("close", () => {
+      this.clients.delete(ws);
+      console.log(`\uD83D\uDCE1 Web client disconnected (${this.clients.size} remaining)`);
+    });
+    ws.on("error", (error) => {
+      console.error("WebSocket error:", error);
+    });
+  }
+  async handlePrompt(prompt, ws) {
+    try {
+      ws.send(JSON.stringify({ type: "user_message", content: prompt }));
+      const entries = await this.agent.processUserMessage(prompt);
+      for (const entry of entries) {
+        if (entry.type === "assistant") {
+          ws.send(JSON.stringify({
+            type: "assistant_message",
+            content: entry.content
+          }));
+        } else if (entry.type === "tool_call") {
+          ws.send(JSON.stringify({
+            type: "tool_call",
+            tool: entry.toolCall?.function.name,
+            content: "Executing..."
+          }));
+        } else if (entry.type === "tool_result") {
+          ws.send(JSON.stringify({
+            type: "tool_result",
+            tool: entry.toolCall?.function.name,
+            content: entry.content
+          }));
+        }
+      }
+      ws.send(JSON.stringify({ type: "done" }));
+    } catch (error) {
+      ws.send(JSON.stringify({
+        type: "error",
+        content: error.message
+      }));
+    }
+  }
+  async handleGetFileTree(ws) {
+    try {
+      const { getFileIndexer: getFileIndexer2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const indexer = getFileIndexer2();
+      const index = indexer.getIndex();
+      if (!index) {
+        ws.send(JSON.stringify({ type: "file_tree", tree: [] }));
+        return;
+      }
+      const tree = index.entries.filter((e) => !e.path.includes("node_modules") && !e.path.startsWith(".")).map((e) => ({
+        path: e.path,
+        name: path16.basename(e.path),
+        isDirectory: e.isDirectory,
+        size: e.size
+      })).slice(0, 500);
+      ws.send(JSON.stringify({ type: "file_tree", tree }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleGetFileContent(filePath, ws) {
+    try {
+      const fullPath = path16.join(process.cwd(), filePath);
+      if (!fullPath.startsWith(process.cwd())) {
+        throw new Error("Access denied");
+      }
+      const content = await fs17.readFile(fullPath, "utf-8");
+      ws.send(JSON.stringify({
+        type: "file_content",
+        path: filePath,
+        content: content.slice(0, 1e4)
+      }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleListSessions(ws) {
+    try {
+      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
+      const sessionManager = getSessionManager2();
+      const sessions = await sessionManager.listSessions();
+      ws.send(JSON.stringify({
+        type: "sessions_list",
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          name: s.name,
+          workingDirectory: s.workingDirectory,
+          messageCount: s.messages.length,
+          lastAccessed: s.lastAccessed
+        }))
+      }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleSwitchSession(sessionId, ws) {
+    try {
+      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
+      const sessionManager = getSessionManager2();
+      const session = await sessionManager.switchSession(sessionId);
+      if (session) {
+        ws.send(JSON.stringify({
+          type: "session_switched",
+          session: {
+            id: session.id,
+            name: session.name,
+            workingDirectory: session.workingDirectory,
+            messages: session.messages
+          }
+        }));
+      } else {
+        throw new Error("Session not found");
+      }
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async checkAndSendUpdateNotification(ws) {
+    try {
+      const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+      const { getUpdateChecker: getUpdateChecker2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
+      const updateChecker = getUpdateChecker2(pkg.version);
+      const updateInfo = await updateChecker.checkForUpdates();
+      if (updateInfo?.updateAvailable) {
+        ws.send(JSON.stringify({
+          type: "update_available",
+          currentVersion: updateInfo.currentVersion,
+          latestVersion: updateInfo.latestVersion
+        }));
+      }
+    } catch (error) {}
+  }
+  async start() {
+    return new Promise((resolve5, reject) => {
+      this.httpServer.listen(this.port, this.hostname, () => {
+        const url = `http://${this.hostname}:${this.port}`;
+        console.log(`\uD83C\uDF10 Web interface available at ${url}`);
+        resolve5();
+      });
+      this.httpServer.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  async openBrowser() {
+    const url = `http://${this.hostname}:${this.port}`;
+    try {
+      await open(url);
+      console.log(`\uD83D\uDE80 Opened browser at ${url}`);
+    } catch (error) {
+      console.warn(`Could not open browser automatically. Please visit ${url}`);
+    }
+  }
+  stop() {
+    this.clients.forEach((client) => {
+      client.close();
+    });
+    this.wss.close();
+    this.httpServer.close();
+    console.log("\uD83D\uDED1 Web server stopped");
+  }
+}
+
+// src/commands/web.ts
+import { Command } from "commander";
+import chalk from "chalk";
+function createWebCommand() {
+  const webCommand = new Command("web").description("Start the web interface").option("-p, --port <number>", "Port to run server on", "3000").option("--no-browser", "Do not open browser automatically").action(async (options) => {
+    const port = parseInt(options.port);
+    const settingsManager = getSettingsManager();
+    const apiKey = settingsManager.getApiKey();
+    const baseURL = settingsManager.getBaseURL() || "https://api.openai.com/v1";
+    const model = settingsManager.getCurrentModel();
+    if (!apiKey) {
+      console.error(chalk.red("API Key not found. Please configure it first."));
+      process.exit(1);
+    }
+    console.log(chalk.blue(`Starting web server on port ${port}...`));
+    const agent = new SuperAgent(apiKey, baseURL, model);
+    const server = new WebServer({
+      port,
+      agent,
+      openBrowser: options.browser
+    });
+    try {
+      await server.start();
+      if (options.browser) {
+        await server.openBrowser();
+      }
+      process.on("SIGINT", () => {
+        console.log(chalk.yellow(`
+Stopping server...`));
+        server.stop();
+        process.exit(0);
+      });
+    } catch (error) {
+      console.error(chalk.red(`Failed to start server: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return webCommand;
+}
+function createServeCommand() {
+  const serveCommand = new Command("serve").description("Start the web interface and CLI together").option("-p, --port <number>", "Port to run server on", "3000").action(async (options) => {
+    console.log(chalk.yellow("Serve mode is currently an alias for 'web' mode with background persistence capabilities."));
+    const port = parseInt(options.port);
+    const settingsManager = getSettingsManager();
+    const apiKey = settingsManager.getApiKey();
+    if (!apiKey) {
+      console.error(chalk.red("API Key not found."));
+      process.exit(1);
+    }
+    const agent = new SuperAgent(apiKey, settingsManager.getBaseURL() || "", settingsManager.getCurrentModel());
+    const server = new WebServer({ port, agent, openBrowser: true });
+    await server.start();
+    await server.openBrowser();
+  });
+  return serveCommand;
+}
+
+// src/commands/provider.ts
+init_settings_manager();
+import { Command as Command2 } from "commander";
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+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",
+  "dist",
+  "build",
+  "coverage",
+  ".env",
+  "*.log",
+  ".DS_Store",
+  "Thumbs.db"
+];
+function createIndexCommand() {
+  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 = path17.resolve(directory);
+      const outputFile2 = options.output ? path17.resolve(options.output) : path17.join(rootDir, "index.md");
+      const maxDepth = parseInt(options.depth);
+      console.log(chalk3.blue(`Indexing directory: ${rootDir}`));
+      const ig = ignore().add(DEFAULT_IGNORES);
+      if (options.ignore !== false) {
+        try {
+          const gitignorePath = path17.join(rootDir, ".gitignore");
+          const gitignoreContent = await fs18.readFile(gitignorePath, "utf-8");
+          ig.add(gitignoreContent);
+        } catch (e) {}
+      }
+      let outputContent = `# Directory Index
+
+Generated for: ${rootDir}
+Date: ${new Date().toISOString()}
+
+`;
+      outputContent += "## File Structure\n\n```\n";
+      async function buildTree(currentPath, depth, prefix = "") {
+        if (depth > maxDepth) {
+          return;
+        }
+        const relativePath = path17.relative(rootDir, currentPath);
+        if (relativePath && ig.ignores(relativePath)) {
+          return;
+        }
+        const stats = await fs18.stat(currentPath);
+        const isDir = stats.isDirectory();
+        const name = path17.basename(currentPath);
+        if (isDir) {
+          if (relativePath) {
+            outputContent += `${prefix}${name}/
+`;
+          }
+          const entries = await fs18.readdir(currentPath, {
+            withFileTypes: true
+          });
+          const sortedEntries = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) {
+              return -1;
+            }
+            if (!a.isDirectory() && b.isDirectory()) {
+              return 1;
+            }
+            return a.name.localeCompare(b.name);
+          });
+          for (let i = 0;i < sortedEntries.length; i++) {
+            const entry = sortedEntries[i];
+            const isLast = i === sortedEntries.length - 1;
+            const newPrefix = relativePath ? prefix + "  " : "";
+            await buildTree(path17.join(currentPath, entry.name), depth + 1, newPrefix);
+          }
+        } else {
+          outputContent += `${prefix}${name}
+`;
+        }
+      }
+      const files = [];
+      async function walk(dir, currentDepth) {
+        if (currentDepth > maxDepth) {
+          return;
+        }
+        const entries = await fs18.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path17.join(dir, entry.name);
+          const relPath = path17.relative(rootDir, fullPath);
+          if (ig.ignores(relPath)) {
+            continue;
+          }
+          if (entry.isDirectory()) {
+            await walk(fullPath, currentDepth + 1);
+          } else {
+            files.push(relPath);
+          }
+        }
+      }
+      await walk(rootDir, 0);
+      console.log(chalk3.blue(`Found ${files.length} files.`));
+      outputContent = `# Project Index: ${path17.basename(rootDir)}
+
+`;
+      outputContent += `Total Files: ${files.length}
+
+`;
+      outputContent += `## Files
+
+`;
+      for (const file of files) {
+        outputContent += `### ${file}
+`;
+        const stats = await fs18.stat(path17.join(rootDir, file));
+        outputContent += `- Size: ${stats.size} bytes
+`;
+        outputContent += `- Modified: ${stats.mtime.toISOString()}
+
+`;
+      }
+      await fs18.writeFile(outputFile2, outputContent);
+      console.log(chalk3.green(`✓ Index generated at: ${outputFile2}`));
+    } catch (error) {
+      console.error(chalk3.red(`Error indexing directory: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return indexCommand;
+}
+
+// src/commands/plugins.ts
+init_settings_manager();
+import { Command as Command4 } from "commander";
+function createPluginsCommand() {
+  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();
+    const plugins = settings.plugins || [];
+    if (plugins.length === 0) {
+      console.log("No plugins installed.");
+      return;
+    }
+    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 (path18) => {
+    try {
+      const manager = PluginManager.getInstance();
+      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 (path18) => {
+    try {
+      const manager = PluginManager.getInstance();
+      await manager.removePlugin(path18);
+      console.log(`✅ Plugin uninstalled: ${path18}`);
+    } catch (error) {
+      console.error(`❌ Error uninstalling plugin: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return pluginsCommand;
+}
+
+// src/commands/skills.ts
+init_settings_manager();
+init_manager2();
+import { Command as Command5 } from "commander";
+import inquirer2 from "inquirer";
+import chalk4 from "chalk";
+function createSkillsCommand() {
+  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();
+    if (skills.length === 0) {
+      console.log("No skills found.");
+    } else {
+      console.log("Available skills:");
+      skills.forEach((skill) => console.log(`- ${skill}`));
+    }
+  });
+  skillsCommand.command("create <name>").description("Create a new skill with AI assistance").option("-d, --description <description>", "Description of the skill").action(async (name, options) => {
+    try {
+      const manager = SkillsManager.getInstance();
+      const settingsManager = getSettingsManager();
+      let description = options.description;
+      if (!description) {
+        const answer = await inquirer2.prompt([
+          {
+            type: "input",
+            name: "description",
+            message: "Describe what this skill should do:"
+          }
+        ]);
+        description = answer.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(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(chalk4.green(`✓ Skill '${name}' created successfully.`));
+    } catch (error) {
+      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(chalk4.green(`✓ Skill '${name}' deleted.`));
+    } catch (error) {
+      console.error(chalk4.red(`Error deleting skill: ${error.message}`));
+    }
+  });
+  return skillsCommand;
+}
+
+// src/commands/import.ts
+init_settings_manager();
+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;
+    }
+    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}`));
+        }
+      }
+    }
+    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;
+    }
+    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}`));
+        }
+      }
+    }
+    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;
+    }
+    try {
+      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) {
+      console.error(chalk5.red(`Failed to import hooks: ${error.message}`));
+    }
+  });
+  return cmd;
+}
+
+// src/commands/agents.ts
+init_settings_manager();
+init_manager();
+import { Command as Command7 } from "commander";
+import inquirer3 from "inquirer";
+import chalk6 from "chalk";
+function createAgentsCommand() {
+  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();
+    if (agents.length === 0) {
+      console.log("No agents found.");
+    } else {
+      console.log("Available agents:");
+      agents.forEach((agent) => {
+        console.log(`- ${chalk6.bold(agent.name)} (${agent.role})`);
+        console.log(`  ${chalk6.dim(agent.description)}`);
+      });
+    }
+  });
+  agentsCommand.command("create <name>").description("Create a new agent with AI assistance").option("-d, --description <description>", "Description of the agent's role and purpose").action(async (name, options) => {
+    try {
+      const manager = AgentsManager.getInstance();
+      const settingsManager = getSettingsManager();
+      let description = options.description;
+      if (!description) {
+        const answer = await inquirer3.prompt([
+          {
+            type: "input",
+            name: "description",
+            message: "Describe the agent's role and purpose:"
+          }
+        ]);
+        description = answer.description;
+      }
+      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(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(chalk6.green(`✓ Agent '${name}' created successfully.`));
+    } catch (error) {
+      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(chalk6.green(`✓ Agent '${name}' deleted.`));
+    } catch (error) {
+      console.error(chalk6.red(`Error deleting agent: ${error.message}`));
+    }
+  });
+  return agentsCommand;
+}
+
 // src/commands/mcp.ts
 init_config();
-import { Command } from "commander";
-import chalk from "chalk";
+import { Command as Command8 } from "commander";
+import chalk7 from "chalk";
 function createMCPCommand() {
-  const mcpCommand = new Command("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(chalk.green(`✓ Added predefined MCP server: ${name}`));
+        console.log(chalk7.green(`✓ Added predefined MCP server: ${name}`));
         const manager2 = getMCPManager();
         await manager2.addServer(config2);
-        console.log(chalk.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(chalk.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(chalk.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(chalk.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(chalk.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 = {};
@@ -8483,14 +9543,14 @@ function createMCPCommand() {
         }
       };
       addMCPServer(config);
-      console.log(chalk.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(config);
-      console.log(chalk.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(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk7.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8500,7 +9560,7 @@ function createMCPCommand() {
       try {
         config = JSON.parse(jsonConfig);
       } catch (error) {
-        console.error(chalk.red("Error: Invalid JSON configuration"));
+        console.error(chalk7.red("Error: Invalid JSON configuration"));
         process.exit(1);
       }
       const serverConfig = {
@@ -8525,14 +9585,14 @@ function createMCPCommand() {
         }
       }
       addMCPServer(serverConfig);
-      console.log(chalk.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
-      console.log(chalk.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(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk7.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8541,9 +9601,9 @@ function createMCPCommand() {
       const manager = getMCPManager();
       await manager.removeServer(name);
       removeMCPServer(name);
-      console.log(chalk.green(`✓ Removed MCP server: ${name}`));
+      console.log(chalk7.green(`✓ Removed MCP server: ${name}`));
     } catch (error) {
-      console.error(chalk.red(`Error removing MCP server: ${error.message}`));
+      console.error(chalk7.red(`Error removing MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8551,15 +9611,15 @@ function createMCPCommand() {
     const config = loadMCPConfig();
     const manager = getMCPManager();
     if (config.servers.length === 0) {
-      console.log(chalk.yellow("No MCP servers configured"));
+      console.log(chalk7.yellow("No MCP servers configured"));
       return;
     }
-    console.log(chalk.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 ? chalk.green("✓ Connected") : chalk.red("✗ Disconnected");
-      console.log(`${chalk.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") {
@@ -8592,15 +9652,15 @@ function createMCPCommand() {
       const config = loadMCPConfig();
       const serverConfig = config.servers.find((s) => s.name === name);
       if (!serverConfig) {
-        console.error(chalk.red(`Server ${name} not found`));
+        console.error(chalk7.red(`Server ${name} not found`));
         process.exit(1);
       }
-      console.log(chalk.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(chalk.green(`✓ Successfully connected to ${name}`));
-      console.log(chalk.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) => {
@@ -8609,82 +9669,44 @@ function createMCPCommand() {
         });
       }
     } catch (error) {
-      console.error(chalk.red(`✗ Failed to connect to ${name}: ${error.message}`));
+      console.error(chalk7.red(`✗ Failed to connect to ${name}: ${error.message}`));
       process.exit(1);
     }
   });
   return mcpCommand;
 }
 
-// src/index.ts
-var import__package = __toESM(require_package(), 1);
-import { program } from "commander";
-import * as dotenv from "dotenv";
-import { render } from "ink";
-import React4 from "react";
-dotenv.config();
-process.on("SIGTERM", () => {
-  if (process.stdin.isTTY && process.stdin.setRawMode) {
-    try {
-      process.stdin.setRawMode(false);
-    } catch (e) {}
-  }
-  console.log(`
-Gracefully shutting down...`);
-  process.exit(0);
-});
-process.on("uncaughtException", (error) => {
-  console.error("Uncaught exception:", error);
-  process.exit(1);
-});
-process.on("unhandledRejection", (reason, promise) => {
-  console.error("Unhandled rejection at:", promise, "reason:", reason);
-  process.exit(1);
-});
-function ensureUserSettingsDirectory() {
-  try {
-    const manager = getSettingsManager();
-    manager.loadUserSettings();
-  } catch (error) {}
-}
-function loadApiKey() {
+// src/commands/git.ts
+init_settings_manager();
+import { Command as Command9 } from "commander";
+async function loadApiKey() {
   const manager = getSettingsManager();
   return manager.getApiKey();
 }
-function loadBaseURL() {
+async function loadBaseURL() {
   const manager = getSettingsManager();
   return manager.getBaseURL();
 }
+async function loadModel() {
+  const manager = getSettingsManager();
+  return process.env.SUPER_AGENT_MODEL || manager.getCurrentModel();
+}
 async function saveCommandLineSettings(apiKey, baseURL) {
-  try {
-    const manager = getSettingsManager();
-    const settings = manager.loadUserSettings();
-    const activeProviderId = settings.active_provider;
-    if (!settings.providers[activeProviderId]) {
-      return;
-    }
+  if (!apiKey && !baseURL) {
+    return;
+  }
+  const manager = getSettingsManager();
+  const settings = manager.loadUserSettings();
+  const activeProviderId = settings.active_provider;
+  if (settings.providers[activeProviderId]) {
     if (apiKey) {
       settings.providers[activeProviderId].api_key = apiKey;
-      console.log(`✅ API key saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
     }
     if (baseURL) {
       settings.providers[activeProviderId].base_url = baseURL;
-      console.log(`✅ Base URL saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
     }
     manager.saveUserSettings(settings);
-  } catch (error) {
-    console.warn("⚠️ Could not save settings to file:", error instanceof Error ? error.message : "Unknown error");
-  }
-}
-function loadModel() {
-  let model = process.env.SUPER_AGENT_MODEL;
-  if (!model) {
-    try {
-      const manager = getSettingsManager();
-      model = manager.getCurrentModel();
-    } catch (error) {}
   }
-  return model;
 }
 async function handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds) {
   try {
@@ -8759,6 +9781,122 @@ Respond with ONLY the commit message, no additional text.`;
     process.exit(1);
   }
 }
+function createGitCommand() {
+  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 {
+        process.chdir(options.directory);
+      } catch (error) {
+        console.error(`Error changing directory to ${options.directory}:`, error.message);
+        process.exit(1);
+      }
+    }
+    try {
+      const apiKey = options.apiKey || await loadApiKey();
+      const baseURL = options.baseUrl || await loadBaseURL();
+      const model = options.model || await loadModel();
+      const maxToolRounds = parseInt(options.maxToolRounds) || 400;
+      if (!apiKey) {
+        console.error("❌ Error: API key required for git operations. Set SUPER_AGENT_API_KEY environment variable.");
+        process.exit(1);
+      }
+      if (options.apiKey || options.baseUrl) {
+        await saveCommandLineSettings(options.apiKey, options.baseUrl);
+      }
+      await handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds);
+    } catch (error) {
+      console.error("❌ Error during git commit-and-push:", error.message);
+      process.exit(1);
+    }
+  });
+  return gitCommand;
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  program.addCommand(createMCPCommand());
+  program.addCommand(createPluginsCommand());
+  program.addCommand(createGitCommand());
+  program.addCommand(createWebCommand());
+  program.addCommand(createServeCommand());
+  program.addCommand(createSkillsCommand());
+  program.addCommand(createAgentsCommand());
+  program.addCommand(createImportCommand());
+  program.addCommand(createProviderCommand());
+  program.addCommand(createIndexCommand());
+}
+
+// src/index.ts
+var import__package = __toESM(require_package(), 1);
+import { program } from "commander";
+import * as dotenv from "dotenv";
+import { render } from "ink";
+import React4 from "react";
+dotenv.config();
+process.on("SIGTERM", () => {
+  if (process.stdin.isTTY && process.stdin.setRawMode) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch (e) {}
+  }
+  console.log(`
+Gracefully shutting down...`);
+  process.exit(0);
+});
+process.on("uncaughtException", (error) => {
+  console.error("Uncaught exception:", error);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled rejection at:", promise, "reason:", reason);
+  process.exit(1);
+});
+function ensureUserSettingsDirectory() {
+  try {
+    const manager = getSettingsManager();
+    manager.loadUserSettings();
+  } catch (error) {}
+}
+function loadApiKey2() {
+  const manager = getSettingsManager();
+  return manager.getApiKey();
+}
+function loadBaseURL2() {
+  const manager = getSettingsManager();
+  return manager.getBaseURL();
+}
+async function saveCommandLineSettings2(apiKey, baseURL) {
+  try {
+    const manager = getSettingsManager();
+    const settings = manager.loadUserSettings();
+    const activeProviderId = settings.active_provider;
+    if (!settings.providers[activeProviderId]) {
+      return;
+    }
+    if (apiKey) {
+      settings.providers[activeProviderId].api_key = apiKey;
+      console.log(`✅ API key saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
+    }
+    if (baseURL) {
+      settings.providers[activeProviderId].base_url = baseURL;
+      console.log(`✅ Base URL saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
+    }
+    manager.saveUserSettings(settings);
+  } catch (error) {
+    console.warn("⚠️ Could not save settings to file:", error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function loadModel2() {
+  let model = process.env.SUPER_AGENT_MODEL;
+  if (!model) {
+    try {
+      const manager = getSettingsManager();
+      model = manager.getCurrentModel();
+    } catch (error) {}
+  }
+  return model;
+}
 async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRounds) {
   try {
     const agent = new SuperAgent(apiKey, baseURL, model, maxToolRounds);
@@ -8823,9 +9961,9 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
     }
   }
   try {
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
+    const apiKey = options.apiKey || loadApiKey2();
+    const baseURL = options.baseUrl || loadBaseURL2();
+    const model = options.model || loadModel2();
     const maxToolRounds = parseInt(options.maxToolRounds) || 400;
     if (!apiKey && !options.prompt) {
       console.warn("⚠️  Warning: No API key found. Some features may not work. Use /config or set SUPER_AGENT_API_KEY.");
@@ -8834,7 +9972,7 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
       process.exit(1);
     }
     if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
+      await saveCommandLineSettings2(options.apiKey, options.baseUrl);
     }
     if (options.prompt) {
       await processPromptHeadless(options.prompt, apiKey, baseURL, model, maxToolRounds);
@@ -8862,141 +10000,6 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
     process.exit(1);
   }
 });
-var aboutCommand = program.command("about").description("Show information about the Super Agent CLI").action(() => {
-  console.log(import__package.default.name + " " + import__package.default.version);
-  console.log(import__package.default.description);
-  console.log(`
-Maintained by: ` + import__package.default.author);
-  console.log(`
-Source code: ` + import__package.default.repository.url);
-  console.log(`
-Funding: ` + import__package.default.funding);
-  process.exit(0);
-});
-var pluginsCommand = program.command("plugins list/install/uninstall <name> / <path>").description("Manage plugins for Super Agent CLI");
-pluginsCommand.command("list").description("List installed plugins").action(() => {
-  console.log("List installed plugins");
-  process.exit(0);
-});
-pluginsCommand.command("install <name> / <path>").description("Install a plugin").action(() => {
-  console.log("Install a plugin");
-  process.exit(0);
-});
-pluginsCommand.command("uninstall <name>").description("Uninstall a plugin").action(() => {
-  console.log("Uninstall a plugin");
-  process.exit(0);
-});
-var gitCommand = program.command("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 {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.error("❌ Error: API key required for git operations. Set SUPER_AGENT_API_KEY environment variable.");
-      process.exit(1);
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    await handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds);
-  } catch (error) {
-    console.error("❌ Error during git commit-and-push:", error.message);
-    process.exit(1);
-  }
-});
-var webCommand = program.command("web").description("Start web server interface").option("--hostname <hostname>", "Server hostname", "localhost").option("--port <port>", "Server port", "3000").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").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  if (options.directory) {
-    try {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const { WebServer: WebServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.warn("⚠️  Warning: No API key found. Web interface may not work properly.");
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    const agent = new SuperAgent(apiKey || "", baseURL, model, maxToolRounds);
-    const server = new WebServer2({
-      hostname: options.hostname,
-      port: parseInt(options.port),
-      agent
-    });
-    await server.start();
-    if (options.open !== false) {
-      await server.openBrowser();
-    }
-    process.on("SIGINT", () => {
-      server.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error("❌ Error starting web server:", error.message);
-    process.exit(1);
-  }
-});
-var serveCommand = program.command("serve").description("Run both CLI and web interface simultaneously").option("--hostname <hostname>", "Server hostname", "localhost").option("--port <port>", "Server port", "3000").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").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  if (options.directory) {
-    try {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const { WebServer: WebServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.warn("⚠️  Warning: No API key found. Some features may not work.");
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    const agent = new SuperAgent(apiKey || "", baseURL, model, maxToolRounds);
-    const server = new WebServer2({
-      hostname: options.hostname,
-      port: parseInt(options.port),
-      agent
-    });
-    await server.start();
-    if (options.open !== false) {
-      await server.openBrowser();
-    }
-    console.log(`\uD83E\uDD16 Starting CLI interface...
-`);
-    ensureUserSettingsDirectory();
-    render(React4.createElement(ChatInterface, { agent }));
-    process.on("SIGINT", () => {
-      server.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error("❌ Error starting serve mode:", error.message);
-    process.exit(1);
-  }
-});
-program.addCommand(createMCPCommand());
+registerCommands(program);
+program.parse();
 program.parse();