devwing 0.1.0

package/dist/index.js

@@ -0,0 +1,2066 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk3 from 'chalk';
+import inquirer from 'inquirer';
+import axios2 from 'axios';
+import Conf from 'conf';
+import { AsyncEntry } from '@napi-rs/keyring';
+import { EventSourceParserStream } from 'eventsource-parser/stream';
+import ora from 'ora';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import terminalLink from 'terminal-link';
+import { readFileSync, promises } from 'fs';
+import path, { dirname, join } from 'path';
+import os from 'os';
+import { exec, execSync } from 'child_process';
+import { simpleGit } from 'simple-git';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+import fs2 from 'fs/promises';
+import util from 'util';
+import Table from 'cli-table3';
+import { fileURLToPath } from 'url';
+import semver from 'semver';
+
+var SERVICE_NAME = "DevWing CLI";
+var API_KEY_ACCOUNT = "api-key";
+var ConfigManager = class {
+  conf;
+  constructor() {
+    this.conf = new Conf({
+      projectName: "devwing",
+      defaults: {
+        apiUrl: process.env.DEVWING_API_URL || "https://api.devwing.ai"
+      }
+    });
+  }
+  /**
+   * Get API key from OS keychain
+   */
+  async getApiKey() {
+    try {
+      const entry = new AsyncEntry(SERVICE_NAME, API_KEY_ACCOUNT);
+      const password = await entry.getPassword();
+      return password || null;
+    } catch (error) {
+      console.error("Failed to retrieve API key from keychain:", error);
+      return null;
+    }
+  }
+  /**
+   * Store API key in OS keychain
+   */
+  async setApiKey(apiKey) {
+    try {
+      const entry = new AsyncEntry(SERVICE_NAME, API_KEY_ACCOUNT);
+      await entry.setPassword(apiKey);
+    } catch (error) {
+      throw new Error(`Failed to store API key in keychain: ${error}`);
+    }
+  }
+  /**
+   * Delete API key from OS keychain
+   */
+  async deleteApiKey() {
+    try {
+      const entry = new AsyncEntry(SERVICE_NAME, API_KEY_ACCOUNT);
+      await entry.deletePassword();
+    } catch (error) {
+      console.error("Failed to delete API key from keychain:", error);
+    }
+  }
+  /**
+   * Get API URL
+   */
+  getApiUrl() {
+    return this.conf.get("apiUrl");
+  }
+  /**
+   * Set API URL (for development/testing)
+   */
+  setApiUrl(url) {
+    this.conf.set("apiUrl", url);
+  }
+  /**
+   * Get current workspace ID
+   */
+  getWorkspaceId() {
+    return this.conf.get("workspaceId");
+  }
+  /**
+   * Set current workspace ID
+   */
+  setWorkspaceId(workspaceId) {
+    this.conf.set("workspaceId", workspaceId);
+  }
+  /**
+   * Get current project ID
+   */
+  getProjectId() {
+    return this.conf.get("projectId");
+  }
+  /**
+   * Set current project ID
+   */
+  setProjectId(projectId) {
+    this.conf.set("projectId", projectId);
+  }
+  /**
+   * Get preferred model
+   */
+  getModel() {
+    return this.conf.get("model");
+  }
+  /**
+   * Set preferred model
+   */
+  setModel(model) {
+    this.conf.set("model", model);
+  }
+  /**
+   * Get preferred AI mode
+   */
+  getMode() {
+    return this.conf.get("mode");
+  }
+  /**
+   * Set preferred AI mode
+   */
+  setMode(mode) {
+    this.conf.set("mode", mode);
+  }
+  /**
+   * Get all config
+   */
+  getAll() {
+    return {
+      apiUrl: this.getApiUrl(),
+      workspaceId: this.getWorkspaceId(),
+      projectId: this.getProjectId(),
+      model: this.getModel(),
+      mode: this.getMode()
+    };
+  }
+  /**
+   * Clear all config (except API key)
+   */
+  clear() {
+    this.conf.clear();
+  }
+  /**
+   * Get config file path (for debugging)
+   */
+  getPath() {
+    return this.conf.path;
+  }
+};
+var configManager = new ConfigManager();
+var APIClient = class {
+  client;
+  jwtToken = null;
+  constructor() {
+    this.client = axios2.create({
+      timeout: 12e4
+      // 2 minutes
+    });
+    this.client.interceptors.request.use(async (config) => {
+      const apiKey = await configManager.getApiKey();
+      const apiUrl = configManager.getApiUrl();
+      config.baseURL = apiUrl;
+      if (this.jwtToken) {
+        config.headers.Authorization = `Bearer ${this.jwtToken}`;
+      } else if (apiKey) {
+        config.headers.Authorization = `Bearer ${apiKey}`;
+      }
+      return config;
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (error.response?.data) {
+          throw new Error(error.response.data.message || error.response.data.error);
+        }
+        throw error;
+      }
+    );
+  }
+  /**
+   * Set JWT token for temporary authentication (login flow only)
+   */
+  setJwtToken(token) {
+    this.jwtToken = token;
+  }
+  /**
+   * Login with email and password
+   */
+  async login(email, password) {
+    const response = await this.client.post("/auth/login", { email, password });
+    return response.data;
+  }
+  /**
+   * Get current user profile
+   */
+  async getProfile() {
+    const response = await this.client.get("/users/me");
+    return response.data;
+  }
+  /**
+   * Create a new API key
+   */
+  async createApiKey(name) {
+    const response = await this.client.post("/api-keys", { name });
+    return response.data;
+  }
+  /**
+   * Initiate CLI browser authentication (device flow)
+   */
+  async initiateCliAuth(deviceInfo) {
+    const response = await this.client.post("/auth/cli/initiate", {
+      device_info: deviceInfo
+    });
+    return response.data;
+  }
+  /**
+   * Poll for CLI authentication status
+   */
+  async pollCliAuth(deviceCode) {
+    const response = await this.client.post("/auth/cli/poll", {
+      device_code: deviceCode
+    });
+    return response.data;
+  }
+  /**
+   * Stream AI completion
+   */
+  async *streamCompletion(request) {
+    const apiKey = await configManager.getApiKey();
+    const apiUrl = configManager.getApiUrl();
+    if (!apiKey) {
+      throw new Error('Not authenticated. Run "devwing login" first.');
+    }
+    const response = await fetch(`${apiUrl}/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || "Failed to get completion");
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
+    for await (const event of stream) {
+      if (event.data) {
+        try {
+          const message = JSON.parse(event.data);
+          yield message;
+        } catch (error) {
+          console.error("Failed to parse SSE message:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Continue completion with tool results
+   */
+  async *continueCompletion(sessionId, toolResults) {
+    const apiKey = await configManager.getApiKey();
+    const apiUrl = configManager.getApiUrl();
+    if (!apiKey) {
+      throw new Error('Not authenticated. Run "devwing login" first.');
+    }
+    const response = await fetch(`${apiUrl}/completions/continue`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        session_id: sessionId,
+        tool_results: toolResults
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || "Failed to continue completion");
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
+    for await (const event of stream) {
+      if (event.data) {
+        try {
+          const message = JSON.parse(event.data);
+          yield message;
+        } catch (error) {
+          console.error("Failed to parse SSE message:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Get project memory
+   */
+  async getProjectMemory(projectId) {
+    const response = await this.client.get(`/memory/${projectId}`);
+    return response.data;
+  }
+  /**
+   * Add project memory
+   */
+  async addProjectMemory(projectId, content, type) {
+    const response = await this.client.post(`/memory/${projectId}`, { content, type });
+    return response.data;
+  }
+  /**
+   * Delete project memory
+   */
+  async deleteProjectMemory(projectId, memoryId) {
+    await this.client.delete(`/memory/${projectId}/${memoryId}`);
+  }
+  /**
+   * Get available models
+   */
+  async getModels() {
+    const response = await this.client.get("/models");
+    return response.data;
+  }
+  /**
+   * Get usage stats
+   */
+  async getUsage(params) {
+    const response = await this.client.get("/analytics/overview", { params });
+    return response.data;
+  }
+};
+var apiClient = new APIClient();
+var Logger = class {
+  spinner = null;
+  /**
+   * Success message
+   */
+  success(message) {
+    console.log(chalk3.green("\u2713"), message);
+  }
+  /**
+   * Error message
+   */
+  error(message, error) {
+    console.log(chalk3.red("\u2717"), message);
+    if (error && process.env.DEBUG) {
+      console.error(chalk3.gray(error.stack || error));
+    }
+  }
+  /**
+   * Warning message
+   */
+  warn(message) {
+    console.log(chalk3.yellow("\u26A0"), message);
+  }
+  /**
+   * Info message
+   */
+  info(message) {
+    console.log(chalk3.blue("\u2139"), message);
+  }
+  /**
+   * Debug message (only shown if DEBUG env var is set)
+   */
+  debug(message, data) {
+    if (process.env.DEBUG) {
+      console.log(chalk3.gray("\u2699"), chalk3.gray(message));
+      if (data) {
+        console.log(chalk3.gray(JSON.stringify(data, null, 2)));
+      }
+    }
+  }
+  /**
+   * Start a spinner
+   */
+  startSpinner(text) {
+    this.spinner = ora({
+      text,
+      color: "cyan"
+    }).start();
+  }
+  /**
+   * Update spinner text
+   */
+  updateSpinner(text) {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+  }
+  /**
+   * Stop spinner with success
+   */
+  succeedSpinner(text) {
+    if (this.spinner) {
+      this.spinner.succeed(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with failure
+   */
+  failSpinner(text) {
+    if (this.spinner) {
+      this.spinner.fail(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner
+   */
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Print DevWing banner
+   */
+  printBanner() {
+    const banner = gradient.pastel.multiline([
+      "",
+      "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+      "  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D ",
+      "  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557",
+      "  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551",
+      "  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+      "  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D ",
+      "",
+      "  Your AI Wingman in the Terminal",
+      ""
+    ].join("\n"));
+    console.log(banner);
+  }
+  /**
+   * Print a box message
+   */
+  box(message, options) {
+    console.log(
+      boxen(message, {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: options?.color || "cyan",
+        title: options?.title,
+        titleAlignment: "center"
+      })
+    );
+  }
+  /**
+   * Print a newline
+   */
+  newline() {
+    console.log();
+  }
+};
+var logger = new Logger();
+async function loginCommand() {
+  try {
+    const existingKey = await configManager.getApiKey();
+    if (existingKey) {
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "You are already logged in. Do you want to log in with a different account?",
+          default: false
+        }
+      ]);
+      if (!overwrite) {
+        logger.info("Login cancelled");
+        return;
+      }
+    }
+    logger.printBanner();
+    logger.newline();
+    const { method } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "method",
+        message: "How would you like to authenticate?",
+        choices: [
+          { name: "Email & Password", value: "email" },
+          { name: "Via Browser (easiest)", value: "browser" },
+          { name: "API Key (from dashboard)", value: "apikey" }
+        ]
+      }
+    ]);
+    if (method === "email") {
+      await loginWithEmail();
+    } else if (method === "browser") {
+      await loginWithBrowser();
+    } else {
+      await loginWithApiKey();
+    }
+  } catch (error) {
+    logger.error("Login failed", error);
+    process.exit(1);
+  }
+}
+async function loginWithEmail() {
+  const { email, password } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "email",
+      message: "Email:",
+      validate: (input) => {
+        if (!input.includes("@")) {
+          return "Please enter a valid email address";
+        }
+        return true;
+      }
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Password:",
+      mask: "*"
+    }
+  ]);
+  logger.startSpinner("Authenticating...");
+  try {
+    const { access_token, user } = await apiClient.login(email, password);
+    apiClient.setJwtToken(access_token);
+    logger.updateSpinner("Creating API key...");
+    const { key } = await apiClient.createApiKey("CLI - Auto-generated");
+    apiClient.setJwtToken(null);
+    await configManager.setApiKey(key);
+    logger.succeedSpinner(`Welcome back, ${user.full_name || user.email}!`);
+    logger.success(`Plan: ${user.plan.toUpperCase()}`);
+    logger.newline();
+    showQuickStart();
+  } catch (error) {
+    logger.failSpinner("Authentication failed");
+    throw error;
+  }
+}
+async function loginWithBrowser() {
+  const os2 = await import('os');
+  const open = await import('open');
+  logger.startSpinner("Initiating browser authentication...");
+  try {
+    const deviceInfo = `DevWing CLI on ${os2.platform()}`;
+    const initResponse = await apiClient.initiateCliAuth(deviceInfo);
+    logger.succeedSpinner("Ready to authenticate!");
+    logger.newline();
+    logger.box(
+      [
+        "Browser Authentication",
+        "",
+        `Code: ${chalk3.bold.yellow(initResponse.user_code)}`,
+        "",
+        `Opening browser to ${chalk3.cyan(initResponse.verification_url)}`,
+        "",
+        `Enter the code above when prompted.`,
+        "",
+        `Expires in ${Math.floor(initResponse.expires_in / 60)} minutes.`
+      ].join("\n"),
+      { title: "Verify Device", color: "blue" }
+    );
+    logger.newline();
+    logger.info("Opening browser...");
+    try {
+      await open.default(initResponse.verification_url_complete);
+      logger.success("Browser opened! Please complete authentication.");
+    } catch (err) {
+      logger.warn("Could not open browser automatically");
+      logger.info(
+        `Please visit: ${chalk3.cyan(initResponse.verification_url_complete)}`
+      );
+    }
+    logger.newline();
+    logger.startSpinner("Waiting for authorization...");
+    const pollInterval = initResponse.interval * 1e3;
+    const maxAttempts = Math.floor(initResponse.expires_in / initResponse.interval);
+    let attempts = 0;
+    const pollForAuth = async () => {
+      return new Promise((resolve, reject) => {
+        const interval = setInterval(async () => {
+          attempts++;
+          if (attempts >= maxAttempts) {
+            clearInterval(interval);
+            reject(new Error("Authentication timed out. Please try again."));
+            return;
+          }
+          try {
+            const pollResponse = await apiClient.pollCliAuth(
+              initResponse.device_code
+            );
+            if (pollResponse.status === "authorized" && pollResponse.api_key) {
+              clearInterval(interval);
+              resolve(pollResponse.api_key);
+            } else if (pollResponse.status === "denied") {
+              clearInterval(interval);
+              reject(new Error("Authorization denied by user."));
+            } else if (pollResponse.status === "expired") {
+              clearInterval(interval);
+              reject(
+                new Error('Device code expired. Please run "devwing login" again.')
+              );
+            }
+          } catch (error) {
+            clearInterval(interval);
+            reject(error);
+          }
+        }, pollInterval);
+      });
+    };
+    const apiKey = await pollForAuth();
+    await configManager.setApiKey(apiKey);
+    logger.updateSpinner("Fetching profile...");
+    const user = await apiClient.getProfile();
+    logger.succeedSpinner(`Welcome, ${user.full_name || user.email}!`);
+    logger.success(`Plan: ${user.plan.toUpperCase()}`);
+    logger.newline();
+    showQuickStart();
+  } catch (error) {
+    logger.failSpinner("Browser authentication failed");
+    throw error;
+  }
+}
+async function loginWithApiKey() {
+  const dashboardUrl = terminalLink(
+    "dashboard",
+    "https://devwing.ai/dashboard/api-keys",
+    { fallback: () => "https://devwing.ai/dashboard/api-keys" }
+  );
+  logger.info(`Get your API key from the ${dashboardUrl}`);
+  logger.newline();
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "API Key:",
+      mask: "*",
+      validate: (input) => {
+        if (!input.startsWith("dw_sk_")) {
+          return 'Invalid API key format. Should start with "dw_sk_"';
+        }
+        if (input.length < 20) {
+          return "API key seems too short";
+        }
+        return true;
+      }
+    }
+  ]);
+  logger.startSpinner("Verifying API key...");
+  try {
+    await configManager.setApiKey(apiKey);
+    const user = await apiClient.getProfile();
+    logger.succeedSpinner(`Successfully authenticated as ${user.full_name || user.email}!`);
+    logger.success(`Plan: ${user.plan.toUpperCase()}`);
+    logger.newline();
+    showQuickStart();
+  } catch (error) {
+    await configManager.deleteApiKey();
+    logger.failSpinner("Invalid API key");
+    throw error;
+  }
+}
+async function logoutCommand() {
+  try {
+    const apiKey = await configManager.getApiKey();
+    if (!apiKey) {
+      logger.info("You are not logged in");
+      return;
+    }
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to log out?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Logout cancelled");
+      return;
+    }
+    await configManager.deleteApiKey();
+    const apiUrl = configManager.getApiUrl();
+    configManager.clear();
+    configManager.setApiUrl(apiUrl);
+    logger.success("Successfully logged out");
+  } catch (error) {
+    logger.error("Logout failed", error);
+    process.exit(1);
+  }
+}
+async function statusCommand() {
+  try {
+    const apiKey = await configManager.getApiKey();
+    if (!apiKey) {
+      logger.warn("Not authenticated");
+      logger.info('Run "devwing login" to get started');
+      return;
+    }
+    logger.startSpinner("Fetching profile...");
+    try {
+      const user = await apiClient.getProfile();
+      logger.succeedSpinner("Authenticated");
+      logger.newline();
+      console.log(chalk3.bold("User Profile:"));
+      console.log(`  Email: ${user.email}`);
+      console.log(`  Name: ${user.full_name || "Not set"}`);
+      console.log(`  Plan: ${user.plan.toUpperCase()}`);
+      console.log(
+        `  Tokens used today: ${user.tokens_used_today.toLocaleString()}`
+      );
+      const config = configManager.getAll();
+      if (config.workspaceId) {
+        console.log(`  Workspace: ${config.workspaceId}`);
+      }
+      if (config.projectId) {
+        console.log(`  Project: ${config.projectId}`);
+      }
+      logger.newline();
+    } catch (error) {
+      logger.failSpinner("Failed to fetch profile");
+      logger.error("API key may be invalid or expired");
+      logger.info('Run "devwing login" to re-authenticate');
+    }
+  } catch (error) {
+    logger.error("Failed to check status", error);
+    process.exit(1);
+  }
+}
+function showQuickStart() {
+  logger.box(
+    [
+      "Quick Start:",
+      "",
+      '  devwing "fix the auth bug"       Ask anything',
+      "  devwing scan                     Security scan",
+      "  devwing review                   Code review",
+      "  devwing explain file.js          Explain code",
+      "",
+      "For more commands, run: devwing --help"
+    ].join("\n"),
+    { title: "Ready to go!", color: "green" }
+  );
+}
+var DEFAULT_OPTIONS = {
+  maxFiles: 50,
+  maxFileSize: 100 * 1024,
+  // 100KB
+  maxTotalTokens: 1e5,
+  excludePatterns: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/.vscode/**",
+    "**/.idea/**",
+    "**/*.log",
+    "**/*.lock",
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml"
+  ]
+};
+var ContextCollector = class {
+  git;
+  cwd;
+  options;
+  constructor(cwd = process.cwd(), options = {}) {
+    this.cwd = cwd;
+    this.git = simpleGit(cwd);
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Collect all context for AI completion
+   */
+  async collect(prompt) {
+    logger.debug("Collecting context from:", this.cwd);
+    const context = {
+      files: [],
+      cwd: this.cwd,
+      shell: this.detectShell(),
+      os: os.platform()
+    };
+    try {
+      const isRepo = await this.git.checkIsRepo();
+      if (isRepo) {
+        context.git_branch = await this.getCurrentBranch();
+        context.git_diff = await this.getGitDiff();
+        context.git_log = await this.getRecentCommits();
+      }
+    } catch (error) {
+      logger.debug("Not a git repository or git not available");
+    }
+    context.node_version = this.getNodeVersion();
+    context.python_version = this.getPythonVersion();
+    context.framework = await this.detectFramework();
+    context.files = await this.collectFiles(prompt);
+    logger.debug(`Collected ${context.files.length} files`);
+    return context;
+  }
+  /**
+   * Collect relevant files based on prompt and project state
+   */
+  async collectFiles(prompt) {
+    const files = [];
+    const modifiedFiles = await this.getModifiedFiles();
+    const mentionedFiles = prompt ? this.extractFilePaths(prompt) : [];
+    const configFiles = await this.getConfigFiles();
+    const filePaths = Array.from(
+      /* @__PURE__ */ new Set([...modifiedFiles, ...mentionedFiles, ...configFiles])
+    );
+    for (const filePath of filePaths.slice(0, this.options.maxFiles)) {
+      try {
+        const fullPath = path.resolve(this.cwd, filePath);
+        const stat = await promises.stat(fullPath);
+        if (stat.size > this.options.maxFileSize) {
+          logger.debug(`Skipping large file: ${filePath} (${stat.size} bytes)`);
+          continue;
+        }
+        const content = await promises.readFile(fullPath, "utf-8");
+        const language = this.detectLanguage(filePath);
+        files.push({
+          path: filePath,
+          content,
+          language,
+          size: stat.size
+        });
+      } catch (error) {
+        logger.debug(`Failed to read file ${filePath}:`, error);
+      }
+    }
+    return files;
+  }
+  /**
+   * Get modified files from git
+   */
+  async getModifiedFiles() {
+    try {
+      const status = await this.git.status();
+      return [
+        ...status.modified,
+        ...status.created,
+        ...status.staged
+      ];
+    } catch (error) {
+      return [];
+    }
+  }
+  /**
+   * Extract file paths mentioned in prompt
+   */
+  extractFilePaths(prompt) {
+    const paths = [];
+    const patterns = [
+      /[\w-]+\/[\w-/.]+\.\w+/g,
+      // path/to/file.ext
+      /[\w-]+\.\w+/g
+      // file.ext
+    ];
+    for (const pattern of patterns) {
+      const matches = prompt.match(pattern);
+      if (matches) {
+        paths.push(...matches);
+      }
+    }
+    return paths;
+  }
+  /**
+   * Get important config files
+   */
+  async getConfigFiles() {
+    const configPatterns = [
+      "package.json",
+      "tsconfig.json",
+      "requirements.txt",
+      "Pipfile",
+      "Dockerfile",
+      "docker-compose.yml",
+      ".env.example",
+      "README.md"
+    ];
+    const files = [];
+    for (const pattern of configPatterns) {
+      try {
+        const fullPath = path.join(this.cwd, pattern);
+        await promises.access(fullPath);
+        files.push(pattern);
+      } catch {
+      }
+    }
+    return files;
+  }
+  /**
+   * Get current git branch
+   */
+  async getCurrentBranch() {
+    try {
+      const branch = await this.git.revparse(["--abbrev-ref", "HEAD"]);
+      return branch.trim();
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get git diff
+   */
+  async getGitDiff() {
+    try {
+      const diff = await this.git.diff();
+      return diff.substring(0, 1e4);
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Get recent commits
+   */
+  async getRecentCommits() {
+    try {
+      const log = await this.git.log({ maxCount: 5 });
+      return log.all.map((commit) => `${commit.hash.substring(0, 7)} - ${commit.message}`).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Detect shell type
+   */
+  detectShell() {
+    return path.basename(process.env.SHELL || "sh");
+  }
+  /**
+   * Get Node.js version
+   */
+  getNodeVersion() {
+    try {
+      return process.version;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get Python version
+   */
+  getPythonVersion() {
+    try {
+      const version = execSync("python --version 2>&1", { encoding: "utf-8" });
+      return version.trim();
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Detect framework from package.json or requirements.txt
+   */
+  async detectFramework() {
+    try {
+      const packageJsonPath = path.join(this.cwd, "package.json");
+      try {
+        const packageJson = JSON.parse(await promises.readFile(packageJsonPath, "utf-8"));
+        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        if (deps.next) return "Next.js";
+        if (deps.react) return "React";
+        if (deps.vue) return "Vue";
+        if (deps["@angular/core"]) return "Angular";
+        if (deps.express) return "Express";
+        if (deps.fastify) return "Fastify";
+      } catch {
+      }
+      const requirementsPath = path.join(this.cwd, "requirements.txt");
+      try {
+        const requirements = await promises.readFile(requirementsPath, "utf-8");
+        if (requirements.includes("django")) return "Django";
+        if (requirements.includes("flask")) return "Flask";
+        if (requirements.includes("fastapi")) return "FastAPI";
+      } catch {
+      }
+    } catch (error) {
+      logger.debug("Failed to detect framework:", error);
+    }
+    return void 0;
+  }
+  /**
+   * Detect programming language from file extension
+   */
+  detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const languageMap = {
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".py": "python",
+      ".rb": "ruby",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".cpp": "cpp",
+      ".c": "c",
+      ".h": "c",
+      ".hpp": "cpp",
+      ".cs": "csharp",
+      ".php": "php",
+      ".swift": "swift",
+      ".kt": "kotlin",
+      ".dart": "dart",
+      ".sh": "bash",
+      ".yml": "yaml",
+      ".yaml": "yaml",
+      ".json": "json",
+      ".xml": "xml",
+      ".html": "html",
+      ".css": "css",
+      ".scss": "scss",
+      ".md": "markdown",
+      ".sql": "sql"
+    };
+    return languageMap[ext] || "text";
+  }
+};
+var execAsync = util.promisify(exec);
+var ToolEngine = class {
+  allowedProjectPath;
+  commandTimeout = 3e4;
+  // 30 seconds
+  maxFileSize = 10 * 1024 * 1024;
+  // 10MB
+  constructor(allowedProjectPath = process.cwd()) {
+    this.allowedProjectPath = path.resolve(allowedProjectPath);
+  }
+  /**
+   * Validate and resolve file path to prevent directory traversal
+   */
+  validatePath(filePath) {
+    const resolvedPath = path.resolve(this.allowedProjectPath, filePath);
+    if (!resolvedPath.startsWith(this.allowedProjectPath)) {
+      throw new Error(`Security Error: Path '${filePath}' is outside allowed project directory`);
+    }
+    return resolvedPath;
+  }
+  // =================================================================
+  // FILE OPERATIONS
+  // =================================================================
+  async readFile(filePath) {
+    try {
+      const validatedPath = this.validatePath(filePath);
+      try {
+        const stat = await fs2.stat(validatedPath);
+        if (!stat.isFile()) {
+          return { success: false, output: "", error: `Path is not a file: ${filePath}` };
+        }
+        if (stat.size > this.maxFileSize) {
+          return { success: false, output: "", error: `File too large: ${stat.size} bytes (max ${this.maxFileSize})` };
+        }
+        const content = await fs2.readFile(validatedPath, "utf-8");
+        return {
+          success: true,
+          output: content,
+          metadata: { size: stat.size, lines: content.split("\n").length }
+        };
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          return { success: false, output: "", error: `File not found: ${filePath}` };
+        }
+        throw e;
+      }
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  async writeFile(filePath, content, userConfirmed = false) {
+    if (!userConfirmed) {
+      return { success: false, output: "", error: "User confirmation required for write_file operation" };
+    }
+    try {
+      const validatedPath = this.validatePath(filePath);
+      await fs2.mkdir(path.dirname(validatedPath), { recursive: true });
+      await fs2.writeFile(validatedPath, content, "utf-8");
+      return {
+        success: true,
+        output: `File written: ${filePath}`,
+        metadata: { path: validatedPath, size: Buffer.byteLength(content, "utf8") }
+      };
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  async listDirectory(dirPath = ".") {
+    try {
+      const validatedPath = this.validatePath(dirPath);
+      try {
+        const stat = await fs2.stat(validatedPath);
+        if (!stat.isDirectory()) {
+          return { success: false, output: "", error: `Path is not a directory: ${dirPath}` };
+        }
+        const items = await fs2.readdir(validatedPath, { withFileTypes: true });
+        const formattedItems = await Promise.all(items.map(async (item) => {
+          const itemType = item.isDirectory() ? "dir" : "file";
+          let size = 0;
+          if (item.isFile()) {
+            try {
+              const itemStat = await fs2.stat(path.join(validatedPath, item.name));
+              size = itemStat.size;
+            } catch (e) {
+            }
+          }
+          return { name: item.name, type: itemType, size };
+        }));
+        formattedItems.sort((a, b) => {
+          if (a.type === b.type) return a.name.localeCompare(b.name);
+          return a.type === "dir" ? -1 : 1;
+        });
+        const outputLines = formattedItems.map((item) => {
+          return item.type === "dir" ? `\u{1F4C1} ${item.name}/` : `\u{1F4C4} ${item.name} (${item.size} bytes)`;
+        });
+        return {
+          success: true,
+          output: outputLines.join("\n"),
+          metadata: { item_count: formattedItems.length }
+        };
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          return { success: false, output: "", error: `Directory not found: ${dirPath}` };
+        }
+        throw e;
+      }
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  // =================================================================
+  // SHELL EXECUTION
+  // =================================================================
+  async runCommand(command, cwd, userConfirmed = false) {
+    if (!userConfirmed) {
+      return { success: false, output: "", error: "User confirmation required for run_command operation" };
+    }
+    try {
+      let execCwd = this.allowedProjectPath;
+      if (cwd) {
+        execCwd = this.validatePath(cwd);
+        const stat = await fs2.stat(execCwd);
+        if (!stat.isDirectory()) {
+          return { success: false, output: "", error: `Working directory not found: ${cwd}` };
+        }
+      }
+      try {
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: execCwd,
+          timeout: this.commandTimeout,
+          env: { ...process.env, TERM: "dumb" }
+        });
+        return {
+          success: true,
+          output: stdout || stderr,
+          // Some commands write to stderr even on success
+          metadata: { command }
+        };
+      } catch (e) {
+        return {
+          success: false,
+          output: e.stdout || "",
+          error: e.stderr || e.message,
+          metadata: { command, exit_code: e.code }
+        };
+      }
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  // =================================================================
+  // GIT OPERATIONS
+  // =================================================================
+  async gitDiff(cwd) {
+    try {
+      let gitCwd = this.allowedProjectPath;
+      if (cwd) gitCwd = this.validatePath(cwd);
+      const git = simpleGit(gitCwd);
+      const diff = await git.diff();
+      return { success: true, output: diff };
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  async gitLog(limit = 5, cwd) {
+    try {
+      let gitCwd = this.allowedProjectPath;
+      if (cwd) gitCwd = this.validatePath(cwd);
+      const git = simpleGit(gitCwd);
+      const log = await git.log({ maxCount: limit });
+      const output = log.all.map((commit) => `${commit.hash.substring(0, 7)} - ${commit.message}`).join("\n");
+      return { success: true, output };
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  async gitCommit(message, cwd, userConfirmed = false) {
+    if (!userConfirmed) {
+      return { success: false, output: "", error: "User confirmation required for git_commit operation" };
+    }
+    try {
+      let gitCwd = this.allowedProjectPath;
+      if (cwd) gitCwd = this.validatePath(cwd);
+      const git = simpleGit(gitCwd);
+      const result = await git.commit(message);
+      return {
+        success: true,
+        output: `Committed: ${result.commit}
+Branch: ${result.branch}
+Summary: ${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+      };
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  // =================================================================
+  // EXTERNAL API OPERATIONS
+  // =================================================================
+  async searchDocs(query, source = "mdn") {
+    try {
+      if (source === "mdn") {
+        const url = `https://developer.mozilla.org/api/v1/search?q=${encodeURIComponent(query)}`;
+        const response = await axios2.get(url, { timeout: 1e4 });
+        return { success: true, output: JSON.stringify(response.data, null, 2), metadata: { source } };
+      } else if (source === "stackoverflow") {
+        const url = `https://api.stackexchange.com/2.3/search?order=desc&sort=activity&intitle=${encodeURIComponent(query)}&site=stackoverflow`;
+        const response = await axios2.get(url, { timeout: 1e4 });
+        return { success: true, output: JSON.stringify(response.data, null, 2), metadata: { source } };
+      } else {
+        return { success: false, output: "", error: `Unsupported documentation source: ${source}` };
+      }
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  async httpRequest(url, method = "GET", headers, body) {
+    try {
+      const response = await axios2({
+        url,
+        method,
+        headers,
+        data: body,
+        timeout: 1e4
+      });
+      return {
+        success: true,
+        output: typeof response.data === "string" ? response.data : JSON.stringify(response.data, null, 2),
+        metadata: { status_code: response.status }
+      };
+    } catch (e) {
+      return {
+        success: false,
+        output: "",
+        error: e.response ? `HTTP ${e.response.status}: ${e.message}` : e.message
+      };
+    }
+  }
+  async cveLookup(cveId) {
+    try {
+      const url = `https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=${encodeURIComponent(cveId)}`;
+      const response = await axios2.get(url, { timeout: 1e4 });
+      return { success: true, output: JSON.stringify(response.data, null, 2), metadata: { cve_id: cveId } };
+    } catch (e) {
+      return { success: false, output: "", error: e.message };
+    }
+  }
+  // =================================================================
+  // TOOL EXECUTION DISPATCHER
+  // =================================================================
+  async executeTool(toolName, args, userConfirmed = false) {
+    switch (toolName) {
+      case "read_file":
+        return this.readFile(args.file_path || "");
+      case "write_file":
+        return this.writeFile(args.file_path || "", args.content || "", userConfirmed);
+      case "list_directory":
+        return this.listDirectory(args.dir_path || ".");
+      case "run_command":
+        return this.runCommand(args.command || "", args.cwd, userConfirmed);
+      case "git_diff":
+        return this.gitDiff(args.cwd);
+      case "git_log":
+        return this.gitLog(args.limit || 5, args.cwd);
+      case "git_commit":
+        return this.gitCommit(args.message || "", args.cwd, userConfirmed);
+      case "search_docs":
+        return this.searchDocs(args.query || "", args.source || "mdn");
+      case "http_request":
+        return this.httpRequest(args.url || "", args.method || "GET", args.headers, args.body);
+      case "cve_lookup":
+        return this.cveLookup(args.cve_id || "");
+      default:
+        return { success: false, output: "", error: `Tool not implemented: ${toolName}` };
+    }
+  }
+};
+
+// src/streaming/renderer.ts
+marked.setOptions({
+  renderer: new TerminalRenderer({
+    code: chalk3.cyan,
+    blockquote: chalk3.gray.italic,
+    html: chalk3.gray,
+    heading: chalk3.bold.underline,
+    firstHeading: chalk3.bold.magenta,
+    hr: chalk3.reset,
+    listitem: chalk3.reset,
+    list: chalk3.reset,
+    table: chalk3.reset,
+    paragraph: chalk3.reset,
+    strong: chalk3.bold,
+    em: chalk3.italic,
+    codespan: chalk3.cyan,
+    del: chalk3.dim.strikethrough,
+    link: chalk3.blue.underline,
+    href: chalk3.blue.underline
+  })
+});
+var StreamingRenderer = class {
+  buffer = "";
+  inCodeBlock = false;
+  toolEngine;
+  pendingToolCalls = [];
+  sessionId = null;
+  constructor() {
+    this.toolEngine = new ToolEngine(process.cwd());
+  }
+  getPendingToolCalls() {
+    return this.pendingToolCalls;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  clearPendingTools() {
+    this.pendingToolCalls = [];
+    this.sessionId = null;
+  }
+  /**
+   * Process stream message
+   */
+  async processMessage(message) {
+    switch (message.type) {
+      case "token":
+        await this.handleToken(message.content || "");
+        break;
+      case "tool_call":
+        if (message.tool) {
+          this.pendingToolCalls.push({
+            tool: message.tool,
+            args: message.args || {}
+          });
+          await this.handleToolCall(message);
+        }
+        break;
+      case "tools_pending":
+        if (message.session_id) {
+          this.sessionId = message.session_id;
+        }
+        await this.flushBuffer();
+        break;
+      case "tool_result":
+        await this.handleToolResult(message);
+        break;
+      case "done":
+        await this.handleDone(message);
+        break;
+      case "error":
+        await this.handleError(message);
+        break;
+    }
+  }
+  /**
+   * Handle token (word/character from AI)
+   */
+  async handleToken(token) {
+    this.buffer += token;
+    if (token.includes("```")) {
+      this.inCodeBlock = !this.inCodeBlock;
+    }
+    if (token.includes("\n") || this.buffer.length > 1e3) {
+      await this.flushBuffer();
+    } else {
+      process.stdout.write(token);
+    }
+  }
+  /**
+   * Flush accumulated buffer
+   */
+  async flushBuffer() {
+    if (this.buffer.length === 0) return;
+    if (this.inCodeBlock) {
+      process.stdout.write(this.buffer);
+    } else {
+      try {
+        const rendered = await marked(this.buffer);
+        process.stdout.write(rendered);
+      } catch (error) {
+        process.stdout.write(this.buffer);
+      }
+    }
+    this.buffer = "";
+  }
+  /**
+   * Handle tool call request from AI - just display it, execution happens later
+   */
+  async handleToolCall(message) {
+    await this.flushBuffer();
+    logger.newline();
+    const { tool, args } = message;
+    if (!tool) return;
+    logger.info(chalk3.yellow(`AI requested tool: ${chalk3.bold(tool)}`));
+    if (args && Object.keys(args).length > 0) {
+      console.log(chalk3.gray("Arguments:"));
+      console.log(chalk3.gray(JSON.stringify(args, null, 2)));
+    }
+    logger.newline();
+  }
+  /**
+   * Execute all pending tool calls
+   * This is called from prompt.ts after stream ends
+   */
+  async executePendingTools() {
+    const results = [];
+    for (const { tool, args } of this.pendingToolCalls) {
+      logger.newline();
+      logger.info(chalk3.yellow(`Executing ${chalk3.bold(tool)}...`));
+      const requiresConfirmation = this.requiresConfirmation(tool);
+      let confirmed = true;
+      if (requiresConfirmation) {
+        const answers = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "confirmed",
+            message: `Allow ${tool} to execute?`,
+            default: false
+          }
+        ]);
+        confirmed = answers.confirmed;
+        if (!confirmed) {
+          logger.warn("Tool execution cancelled by user");
+          results.push({
+            tool,
+            args,
+            result: "User denied permission",
+            success: false
+          });
+          continue;
+        }
+      }
+      logger.startSpinner(`Executing ${tool}...`);
+      try {
+        const result = await this.toolEngine.executeTool(tool, args || {}, confirmed);
+        logger.stopSpinner();
+        if (result.success) {
+          logger.success(`${tool} completed successfully`);
+          const content = result.output || "";
+          const preview = content.substring(0, 500);
+          if (preview.length < content.length) {
+            console.log(chalk3.gray(preview + "... (truncated)"));
+          } else {
+            console.log(chalk3.gray(preview));
+          }
+          results.push({
+            tool,
+            args,
+            result: result.output || "",
+            success: true
+          });
+        } else {
+          logger.error(`${tool} failed: ${result.error}`);
+          results.push({
+            tool,
+            args,
+            result: result.error || "Unknown error",
+            success: false
+          });
+        }
+      } catch (error) {
+        logger.stopSpinner();
+        logger.error(`${tool} threw error: ${error.message}`);
+        results.push({
+          tool,
+          args,
+          result: error.message,
+          success: false
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Handle tool execution result (from backend)
+   */
+  async handleToolResult(message) {
+    logger.stopSpinner();
+    if (message.content) {
+      const preview = message.content.substring(0, 500);
+      if (preview.length < message.content.length) {
+        console.log(chalk3.gray(preview + "... (truncated)"));
+      } else {
+        console.log(chalk3.gray(preview));
+      }
+    }
+    logger.newline();
+  }
+  /**
+   * Handle completion done
+   */
+  async handleDone(message) {
+    await this.flushBuffer();
+    logger.newline();
+    if (message.usage) {
+      const { tokens_in, tokens_out, cost_usd } = message.usage;
+      console.log(
+        chalk3.gray(
+          `\u{1F4CA} Tokens: ${tokens_in.toLocaleString()} in, ${tokens_out.toLocaleString()} out | Cost: $${cost_usd.toFixed(4)}`
+        )
+      );
+    }
+    logger.newline();
+  }
+  /**
+   * Handle error
+   */
+  async handleError(message) {
+    await this.flushBuffer();
+    logger.newline();
+    logger.error(message.error || "An error occurred");
+  }
+  /**
+   * Check if tool requires user confirmation
+   */
+  requiresConfirmation(tool) {
+    const destructiveTools = [
+      "write_file",
+      "run_command",
+      "git_commit",
+      "delete_file",
+      "modify_file"
+    ];
+    return destructiveTools.includes(tool);
+  }
+  /**
+   * Reset renderer state
+   */
+  reset() {
+    this.buffer = "";
+    this.inCodeBlock = false;
+  }
+};
+var streamingRenderer = new StreamingRenderer();
+
+// src/commands/prompt.ts
+async function promptCommand(prompt, options) {
+  try {
+    const apiKey = await configManager.getApiKey();
+    if (!apiKey) {
+      logger.error('Not authenticated. Run "devwing login" first.');
+      process.exit(1);
+    }
+    logger.startSpinner("Analyzing codebase...");
+    const collector = new ContextCollector(process.cwd());
+    const context = await collector.collect(prompt);
+    logger.succeedSpinner("Context collected");
+    logger.newline();
+    logger.info("DevWing is thinking...");
+    logger.newline();
+    const request = {
+      prompt,
+      mode: options.mode,
+      model: options.model,
+      project_id: options.project || configManager.getProjectId(),
+      context,
+      stream: true,
+      max_tokens: 4096
+    };
+    let continueLoop = true;
+    while (continueLoop) {
+      streamingRenderer.reset();
+      streamingRenderer.clearPendingTools();
+      try {
+        const sessionId = streamingRenderer.getSessionId();
+        if (sessionId) {
+          const toolResults = await streamingRenderer.executePendingTools();
+          logger.newline();
+          logger.info("Sending tool results back to AI...");
+          logger.newline();
+          for await (const message of apiClient.continueCompletion(sessionId, toolResults)) {
+            await streamingRenderer.processMessage(message);
+          }
+        } else {
+          for await (const message of apiClient.streamCompletion(request)) {
+            await streamingRenderer.processMessage(message);
+          }
+        }
+        const pendingTools = streamingRenderer.getPendingToolCalls();
+        const newSessionId = streamingRenderer.getSessionId();
+        if (pendingTools.length > 0 && newSessionId) {
+          continueLoop = true;
+        } else {
+          continueLoop = false;
+        }
+      } catch (error) {
+        logger.newline();
+        logger.error("Request failed:", error);
+        if (error.message.includes("429")) {
+          logger.warn("Rate limit exceeded. Please wait a moment and try again.");
+        } else if (error.message.includes("quota")) {
+          logger.warn("Token quota exceeded. Consider upgrading your plan.");
+        } else if (error.message.includes("unauthorized")) {
+          logger.warn('Authentication failed. Try running "devwing login" again.');
+        }
+        process.exit(1);
+      }
+    }
+    logger.success("Done!");
+  } catch (error) {
+    logger.error("Command failed", error);
+    process.exit(1);
+  }
+}
+async function scanCommand(options) {
+  logger.info("Running security vulnerability scan...");
+  logger.newline();
+  const prompt = `Perform a comprehensive security scan of this codebase. Check for:
+- Common vulnerabilities (OWASP Top 10)
+- Dependency vulnerabilities
+- Hardcoded secrets or credentials
+- SQL injection risks
+- XSS vulnerabilities
+- Insecure authentication/authorization
+- API security issues
+
+Provide a detailed report with severity levels and remediation steps.`;
+  await promptCommand(prompt, { ...options, mode: "security" });
+}
+async function reviewCommand(options) {
+  logger.info("Performing code review...");
+  logger.newline();
+  const prompt = `Conduct a thorough code review of the recent changes. Focus on:
+- Code quality and best practices
+- Potential bugs or edge cases
+- Performance issues
+- Readability and maintainability
+- Documentation completeness
+- Test coverage
+- Security concerns
+
+Provide specific suggestions for improvement.`;
+  await promptCommand(prompt, { ...options, mode: options.mode || "general" });
+}
+async function explainCommand(target, options) {
+  logger.info(`Explaining: ${target}`);
+  logger.newline();
+  const prompt = `Please explain ${target} in detail. Include:
+- What it does and how it works
+- Key components and their relationships
+- Any important patterns or techniques used
+- Potential gotchas or edge cases
+- How it fits into the larger system
+
+Make the explanation clear and accessible.`;
+  await promptCommand(prompt, { ...options });
+}
+async function memoryCommand(action, content, options = {}) {
+  const projectId = options.project || configManager.getProjectId();
+  if (!projectId) {
+    logger.error('No project configured. Use "devwing config set project <project-id>"');
+    return;
+  }
+  try {
+    switch (action) {
+      case "save":
+        await memorySave(projectId, content);
+        break;
+      case "show":
+        await memoryShow(projectId);
+        break;
+      case "clear":
+        await memoryClear(projectId);
+        break;
+    }
+  } catch (error) {
+    logger.error("Memory command failed", error);
+    process.exit(1);
+  }
+}
+async function memorySave(projectId, content) {
+  if (!content) {
+    logger.error("Please provide content to save");
+    return;
+  }
+  const { type } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "type",
+      message: "What type of memory is this?",
+      choices: [
+        { name: "Context (general information)", value: "context" },
+        { name: "Rule (coding standard or guideline)", value: "rule" },
+        { name: "Decision (architectural decision)", value: "decision" },
+        { name: "Summary (project summary)", value: "summary" }
+      ]
+    }
+  ]);
+  logger.startSpinner("Saving to project memory...");
+  try {
+    await apiClient.addProjectMemory(projectId, content, type);
+    logger.succeedSpinner("Memory saved successfully");
+  } catch (error) {
+    logger.failSpinner("Failed to save memory");
+    throw error;
+  }
+}
+async function memoryShow(projectId) {
+  logger.startSpinner("Loading project memory...");
+  try {
+    const memories = await apiClient.getProjectMemory(projectId);
+    logger.stopSpinner();
+    if (memories.length === 0) {
+      logger.info("No memories stored for this project yet");
+      return;
+    }
+    logger.success(`Found ${memories.length} memory items`);
+    logger.newline();
+    const table = new Table({
+      head: ["Type", "Content", "Created"],
+      colWidths: [15, 60, 20],
+      wordWrap: true
+    });
+    for (const memory of memories) {
+      const preview = memory.content.length > 100 ? memory.content.substring(0, 100) + "..." : memory.content;
+      table.push([
+        chalk3.cyan(memory.type),
+        preview,
+        new Date(memory.created_at).toLocaleDateString()
+      ]);
+    }
+    console.log(table.toString());
+  } catch (error) {
+    logger.failSpinner("Failed to load memory");
+    throw error;
+  }
+}
+async function memoryClear(projectId) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Are you sure you want to clear all project memory?",
+      default: false
+    }
+  ]);
+  if (!confirm) {
+    logger.info("Operation cancelled");
+    return;
+  }
+  logger.startSpinner("Clearing project memory...");
+  try {
+    const memories = await apiClient.getProjectMemory(projectId);
+    for (const memory of memories) {
+      await apiClient.deleteProjectMemory(projectId, memory.id);
+    }
+    logger.succeedSpinner("Project memory cleared");
+  } catch (error) {
+    logger.failSpinner("Failed to clear memory");
+    throw error;
+  }
+}
+async function configCommand(action, key, value) {
+  try {
+    if (!action || action === "list") {
+      const config = configManager.getAll();
+      const apiKey = await configManager.getApiKey();
+      console.log(chalk3.bold("Current Configuration:"));
+      console.log(`  API URL: ${config.apiUrl}`);
+      console.log(`  API Key: ${apiKey ? apiKey.substring(0, 12) + "..." : "Not set"}`);
+      console.log(`  Workspace: ${config.workspaceId || "Not set"}`);
+      console.log(`  Project: ${config.projectId || "Not set"}`);
+      console.log(`  Model: ${config.model || "Auto"}`);
+      console.log(`  Mode: ${config.mode || "Auto"}`);
+      console.log();
+      console.log(chalk3.gray(`Config file: ${configManager.getPath()}`));
+      return;
+    }
+    if (action === "get") {
+      if (!key) {
+        logger.error("Please specify a key to get");
+        return;
+      }
+      const config = configManager.getAll();
+      const val = config[key];
+      console.log(val || "Not set");
+      return;
+    }
+    if (action === "set") {
+      if (!key || !value) {
+        logger.error("Please specify both key and value");
+        return;
+      }
+      switch (key) {
+        case "project":
+          configManager.setProjectId(value);
+          logger.success(`project set to: ${value}`);
+          break;
+        case "workspace":
+          configManager.setWorkspaceId(value);
+          logger.success(`workspace set to: ${value}`);
+          break;
+        case "model":
+          configManager.setModel(value);
+          logger.success(`model set to: ${value}`);
+          break;
+        case "mode":
+          const validModes = ["general", "frontend", "backend", "security", "devops"];
+          if (validModes.includes(value)) {
+            configManager.setMode(value);
+            logger.success(`mode set to: ${value}`);
+          } else {
+            logger.error(`Invalid mode. Must be one of: ${validModes.join(", ")}`);
+          }
+          break;
+        case "apiUrl":
+          configManager.setApiUrl(value);
+          logger.success(`apiUrl set to: ${value}`);
+          break;
+        default:
+          logger.error(`Unknown config key: ${key}`);
+      }
+    }
+  } catch (error) {
+    logger.error("Config command failed", error);
+    process.exit(1);
+  }
+}
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function getCurrentVersion() {
+  try {
+    const packageJsonPath = join(__dirname2, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch (error) {
+    logger.error("Failed to read package version", error);
+    return "0.1.0";
+  }
+}
+function getPackageName() {
+  try {
+    const packageJsonPath = join(__dirname2, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.name;
+  } catch (error) {
+    logger.error("Failed to read package name", error);
+    return "@devwing/cli";
+  }
+}
+async function getLatestVersion(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+    if (!response.ok) {
+      throw new Error(`Registry responded with ${response.status}`);
+    }
+    const data = await response.json();
+    return data["dist-tags"].latest;
+  } catch (error) {
+    logger.error("Failed to fetch latest version from npm registry", error);
+    return null;
+  }
+}
+function detectPackageManager() {
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+  }
+  try {
+    execSync("yarn --version", { stdio: "ignore" });
+    return "yarn";
+  } catch {
+  }
+  try {
+    execSync("npm --version", { stdio: "ignore" });
+    return "npm";
+  } catch {
+  }
+  return null;
+}
+function installUpdate(packageName, packageManager, version) {
+  try {
+    logger.startSpinner(`Installing ${packageName}@${version}...`);
+    const command = packageManager === "yarn" ? `yarn global add ${packageName}@${version}` : `${packageManager} install -g ${packageName}@${version}`;
+    execSync(command, { stdio: "inherit" });
+    logger.stopSpinner();
+    return true;
+  } catch (error) {
+    logger.stopSpinner();
+    logger.error("Failed to install update", error);
+    return false;
+  }
+}
+function displayUpdateInfo(currentVersion, latestVersion) {
+  console.log();
+  console.log(chalk3.cyan("\u2501".repeat(60)));
+  console.log(chalk3.bold.cyan("  DevWing CLI Update Available"));
+  console.log(chalk3.cyan("\u2501".repeat(60)));
+  console.log();
+  console.log(`  ${chalk3.gray("Current version:")} ${chalk3.yellow(currentVersion)}`);
+  console.log(`  ${chalk3.gray("Latest version:")}  ${chalk3.green(latestVersion)}`);
+  console.log();
+  console.log(chalk3.gray("  Changelog: https://github.com/devwing/devwing/releases"));
+  console.log();
+}
+async function updateCommand(options) {
+  try {
+    const currentVersion = getCurrentVersion();
+    const packageName = getPackageName();
+    console.log();
+    console.log(chalk3.cyan(`\u{1F4E6} DevWing CLI v${currentVersion}`));
+    console.log();
+    logger.startSpinner("Checking for updates...");
+    const latestVersion = await getLatestVersion(packageName);
+    logger.stopSpinner();
+    if (!latestVersion) {
+      logger.warn("Unable to check for updates. Please check your internet connection.");
+      return;
+    }
+    const isNewer = semver.gt(latestVersion, currentVersion);
+    if (!isNewer) {
+      logger.success(`You're running the latest version (v${currentVersion})`);
+      return;
+    }
+    displayUpdateInfo(currentVersion, latestVersion);
+    if (options?.check) {
+      logger.info('Run "devwing update" to install the latest version');
+      return;
+    }
+    const packageManager = detectPackageManager();
+    if (!packageManager) {
+      logger.error("No package manager found. Please install npm, pnpm, or yarn.");
+      return;
+    }
+    logger.info(`Detected package manager: ${chalk3.cyan(packageManager)}`);
+    if (!options?.force) {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Update to v${latestVersion}?`,
+          default: true
+        }
+      ]);
+      if (!confirm) {
+        logger.info("Update cancelled");
+        return;
+      }
+    }
+    console.log();
+    const success = installUpdate(packageName, packageManager, latestVersion);
+    if (success) {
+      console.log();
+      logger.success(`Successfully updated to v${latestVersion}`);
+      console.log();
+      console.log(chalk3.gray('  Run "devwing --version" to verify'));
+      console.log();
+    } else {
+      console.log();
+      logger.error("Update failed. Please try manually:");
+      console.log();
+      console.log(chalk3.gray(`  ${packageManager} install -g ${packageName}@${latestVersion}`));
+      console.log();
+      process.exit(1);
+    }
+  } catch (error) {
+    logger.error("Update check failed", error);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+var VERSION = "0.1.0";
+program.name("devwing").description("DevWing.ai - Your AI Wingman in the Terminal").version(VERSION, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information");
+program.option("--mode <mode>", "AI mode: general|frontend|backend|security|devops").option("--model <model>", "Specific model to use").option("--project <id>", "Project ID").option("--workspace <id>", "Workspace ID").option("--verbose", "Verbose output for debugging").option("-y, --yes", "Auto-confirm destructive actions");
+program.command("login").description("Authenticate with DevWing").action(async () => {
+  await loginCommand();
+});
+program.command("logout").description("Clear stored credentials").action(async () => {
+  await logoutCommand();
+});
+program.command("status").description("Show authentication status and profile").action(async () => {
+  await statusCommand();
+});
+program.command("scan").description("Run security vulnerability scan").action(async () => {
+  const opts = program.opts();
+  await scanCommand(opts);
+});
+program.command("review").description("Perform code review on recent changes").action(async () => {
+  const opts = program.opts();
+  await reviewCommand(opts);
+});
+program.command("explain <target>").description("Explain code, file, or concept").action(async (target) => {
+  const opts = program.opts();
+  await explainCommand(target, opts);
+});
+var memoryCmd = program.command("memory").description("Manage project memory");
+memoryCmd.command("save <content>").description("Save information to project memory").action(async (content) => {
+  const opts = program.opts();
+  await memoryCommand("save", content, opts);
+});
+memoryCmd.command("show").description("Show all project memories").action(async () => {
+  const opts = program.opts();
+  await memoryCommand("show", void 0, opts);
+});
+memoryCmd.command("clear").description("Clear all project memories").action(async () => {
+  const opts = program.opts();
+  await memoryCommand("clear", void 0, opts);
+});
+var configCmd = program.command("config").description("Manage CLI configuration");
+configCmd.command("list").description("Show all configuration").action(async () => {
+  await configCommand("list");
+});
+configCmd.command("get <key>").description("Get configuration value").action(async (key) => {
+  await configCommand("get", key);
+});
+configCmd.command("set <key> <value>").description("Set configuration value").action(async (key, value) => {
+  await configCommand("set", key, value);
+});
+program.command("update").description("Check for and install CLI updates").option("--check", "Only check for updates, do not install").option("--force", "Skip confirmation prompt").action(async (options) => {
+  await updateCommand(options);
+});
+program.argument("[prompt...]", "Natural language prompt for AI").action(async (promptParts) => {
+  if (promptParts.length === 0) {
+    program.help();
+    return;
+  }
+  const prompt = promptParts.join(" ");
+  const opts = program.opts();
+  await promptCommand(prompt, opts);
+});
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  if (error.code === "commander.help" || error.code === "commander.version") {
+    process.exit(0);
+  }
+  logger.error("An error occurred", error);
+  if (process.env.DEBUG) {
+    console.error(error);
+  }
+  process.exit(1);
+}
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map