tuticli 0.1.0

package/bin/cli.js

@@ -0,0 +1,2001 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/ui/chat.ts
+import { createInterface } from "readline";
+import { stdin as input, stdout as output } from "process";
+import chalk3 from "chalk";
+
+// src/providers/claudev3.ts
+import axios from "axios";
+
+// src/providers/base.ts
+var BaseProvider = class {
+  validateConfig(config2) {
+    if (!config2.apiKey) {
+      throw new Error("API key n\xE3o configurada. Use: tuticli config set api-key SUA_API_KEY");
+    }
+    if (!config2.endpoint) {
+      throw new Error("Endpoint n\xE3o configurado");
+    }
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var d = chalk.dim;
+var b = chalk.bold;
+function timestamp() {
+  return d((/* @__PURE__ */ new Date()).toLocaleTimeString());
+}
+var logger = {
+  info(msg, ...args) {
+    console.log(`${timestamp()} ${b("\u2139")} ${msg}`, ...args);
+  },
+  success(msg, ...args) {
+    console.log(`${timestamp()} ${b("\u2714")} ${msg}`, ...args);
+  },
+  warn(msg, ...args) {
+    console.log(`${timestamp()} ${b("\u26A0")} ${msg}`, ...args);
+  },
+  error(msg, ...args) {
+    console.error(`${timestamp()} ${b("\u2716")} ${msg}`, ...args);
+  },
+  debug(msg, ...args) {
+    if (process.env.DEBUG) {
+      console.log(`${timestamp()} ${b("\u25CF")} ${d(msg)}`, ...args);
+    }
+  },
+  raw(msg) {
+    console.log(msg);
+  }
+};
+
+// src/providers/claudev3.ts
+var ClaudeV3Provider = class extends BaseProvider {
+  name = "claude-v3";
+  buildMessages(messages) {
+    const result = [];
+    for (const m of messages) {
+      if (m.role !== "user" && m.role !== "assistant") continue;
+      const content = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+      result.push({
+        role: m.role,
+        content
+      });
+    }
+    return result;
+  }
+  buildTools(tools) {
+    if (!tools || tools.length === 0) return void 0;
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+  }
+  async chat(messages, config2, tools) {
+    this.validateConfig(config2);
+    const request = {
+      model: config2.model,
+      max_tokens: config2.maxTokens,
+      messages: this.buildMessages(messages),
+      stream: false
+    };
+    const apiTools = this.buildTools(tools);
+    if (apiTools) request.tools = apiTools;
+    try {
+      const response = await axios.post(config2.endpoint, request, {
+        headers: {
+          "x-api-key": config2.apiKey,
+          "Content-Type": "application/json"
+        },
+        timeout: 3e5
+      });
+      const data = response.data;
+      let text = "";
+      const toolCalls = [];
+      for (const block of data.content || []) {
+        if (block.type === "text") {
+          text += block.text || "";
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id || "",
+            name: block.name || "",
+            input: JSON.stringify(block.input || {})
+          });
+        }
+      }
+      return { text, toolCalls };
+    } catch (err) {
+      const axiosErr = err;
+      if (axiosErr.response) {
+        const status = axiosErr.response.status;
+        const msg = axiosErr.response.data?.error?.message || axiosErr.message;
+        throw new Error(`API error ${status}: ${msg}`);
+      }
+      throw new Error(`Falha na requisi\xE7\xE3o: ${axiosErr.message}`);
+    }
+  }
+  async *chatStream(messages, config2, tools) {
+    this.validateConfig(config2);
+    const request = {
+      model: config2.model,
+      max_tokens: config2.maxTokens,
+      messages: this.buildMessages(messages),
+      stream: true
+    };
+    const apiTools = this.buildTools(tools);
+    if (apiTools) request.tools = apiTools;
+    try {
+      const response = await axios.post(config2.endpoint, request, {
+        headers: {
+          "x-api-key": config2.apiKey,
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        responseType: "stream",
+        timeout: 3e5
+      });
+      const stream = response.data;
+      yield* this.parseSSE(stream);
+    } catch (err) {
+      const axiosErr = err;
+      if (axiosErr.response) {
+        const status = axiosErr.response.status;
+        let errorMsg = `API error ${status}`;
+        try {
+          const data = axiosErr.response.data;
+          const body = typeof data === "string" ? data : JSON.stringify(data);
+          const parsed = JSON.parse(body);
+          if (parsed.error?.message) {
+            errorMsg += `: ${parsed.error.message}`;
+          }
+        } catch {
+          errorMsg += `: ${axiosErr.message}`;
+        }
+        yield { type: "error", error: errorMsg };
+      } else {
+        yield { type: "error", error: `Falha na requisi\xE7\xE3o: ${axiosErr.message}` };
+      }
+    }
+  }
+  async *parseSSE(stream) {
+    let buffer = "";
+    const toolInputBuffers = {};
+    const toolCalls = {};
+    let textAccumulator = "";
+    for await (const chunk of stream) {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const dataStr = trimmed.slice(6).trim();
+        if (!dataStr || dataStr === "[DONE]") {
+          continue;
+        }
+        try {
+          const data = JSON.parse(dataStr);
+          if (data.type === "content_block_start") {
+            const idx = data.index;
+            const block = data.content_block;
+            if (block.type === "tool_use") {
+              toolCalls[idx] = { id: block.id, name: block.name };
+              toolInputBuffers[idx] = "";
+            } else if (block.type === "text") {
+              textAccumulator = "";
+            }
+          } else if (data.type === "content_block_delta") {
+            const idx = data.index;
+            const delta = data.delta;
+            if (!delta) continue;
+            if (delta.type === "text_delta") {
+              textAccumulator += delta.text || "";
+            } else if (delta.type === "input_json_delta") {
+              toolInputBuffers[idx] = (toolInputBuffers[idx] || "") + (delta.partial_json || "");
+            }
+          } else if (data.type === "content_block_stop") {
+            const idx = data.index;
+            if (toolCalls[idx] && toolInputBuffers[idx] !== void 0) {
+              const tc = toolCalls[idx];
+              const fullInput = toolInputBuffers[idx];
+              yield {
+                type: "tool_use",
+                tool_call: {
+                  id: tc.id,
+                  name: tc.name,
+                  input: fullInput || "{}"
+                }
+              };
+            }
+            if (!toolCalls[idx] && textAccumulator) {
+              if (textAccumulator.trim()) {
+                yield { type: "content", content: textAccumulator };
+              }
+              textAccumulator = "";
+            }
+          } else if (data.type === "message_stop" || data.type === "done") {
+            if (textAccumulator.trim()) {
+              yield { type: "content", content: textAccumulator };
+            }
+            yield { type: "done" };
+            return;
+          } else if (data.type === "message_delta") {
+            if (data.delta?.stop_reason === "end_turn" || data.delta?.stop_reason === "stop") {
+              if (textAccumulator.trim()) {
+                yield { type: "content", content: textAccumulator };
+              }
+              textAccumulator = "";
+              yield { type: "done" };
+              return;
+            }
+          } else if (data.type === "error") {
+            yield { type: "error", error: data.error?.message || "Erro desconhecido" };
+          }
+        } catch {
+          if (dataStr !== "[DONE]") {
+            logger.debug(`SSE parse error for: ${dataStr}`);
+          }
+        }
+      }
+    }
+    yield { type: "done" };
+  }
+  async listModels(config2) {
+    this.validateConfig(config2);
+    try {
+      const response = await axios.get(config2.endpoint.replace("/messages", "/models"), {
+        headers: {
+          "x-api-key": config2.apiKey,
+          "Content-Type": "application/json"
+        },
+        timeout: 3e4
+      });
+      const data = response.data;
+      if (Array.isArray(data.models)) {
+        return data.models.map((m) => m.id || m.name || String(m));
+      }
+      if (Array.isArray(data.data)) {
+        return data.data.map((m) => m.id || String(m));
+      }
+      return [config2.model, "claude-opus-4-7", "claude-sonnet-4-7", "claude-haiku-4-7"];
+    } catch {
+      return [
+        config2.model,
+        "claude-opus-4-7",
+        "claude-sonnet-4-7",
+        "claude-haiku-4-7",
+        "claude-3-opus-latest",
+        "claude-3-sonnet-latest",
+        "claude-3-haiku-latest"
+      ];
+    }
+  }
+};
+
+// src/providers/index.ts
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(name, provider) {
+  providers.set(name, provider);
+}
+function getProvider(name) {
+  const provider = providers.get(name || "claude-v3");
+  if (!provider) {
+    throw new Error(`Provider "${name}" n\xE3o encontrado. Dispon\xEDveis: ${listProviders().join(", ")}`);
+  }
+  return provider;
+}
+function listProviders() {
+  return Array.from(providers.keys());
+}
+registerProvider("claude-v3", new ClaudeV3Provider());
+
+// src/config/manager.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/utils/validation.ts
+function isValidApiKey(key) {
+  return typeof key === "string" && key.length > 0 && !key.includes(" ");
+}
+function isValidEndpoint(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isValidMaxTokens(n) {
+  return Number.isInteger(n) && n > 0 && n <= 2e5;
+}
+
+// src/config/manager.ts
+var CONFIG_DIR = join(homedir(), ".tuticli");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  apiKey: "",
+  model: "claude-opus-4-7",
+  endpoint: "https://claudev3.hopto.org/v1/messages",
+  maxTokens: 4096
+};
+var VALID_KEYS = {
+  "api-key": {
+    validate: (v) => isValidApiKey(v),
+    normalize: (v) => v.trim()
+  },
+  "apiKey": {
+    validate: (v) => isValidApiKey(v),
+    normalize: (v) => v.trim()
+  },
+  model: {
+    validate: (v) => v.length > 0,
+    normalize: (v) => v.trim()
+  },
+  endpoint: {
+    validate: (v) => isValidEndpoint(v),
+    normalize: (v) => v.trim()
+  },
+  "max-tokens": {
+    validate: (v) => isValidMaxTokens(Number(v)),
+    normalize: (v) => Number(v)
+  },
+  "maxTokens": {
+    validate: (v) => isValidMaxTokens(Number(v)),
+    normalize: (v) => Number(v)
+  }
+};
+var ConfigManager = class {
+  config;
+  constructor() {
+    this.ensureDir();
+    this.config = this.load();
+  }
+  ensureDir() {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  }
+  load() {
+    try {
+      if (existsSync(CONFIG_PATH)) {
+        const raw = readFileSync(CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { ...DEFAULT_CONFIG, ...parsed };
+      }
+    } catch (err) {
+      logger.warn(`Falha ao ler config, usando padr\xE3o: ${err.message}`);
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  save() {
+    try {
+      writeFileSync(CONFIG_PATH, JSON.stringify(this.config, null, 2), "utf-8");
+    } catch (err) {
+      logger.error(`Falha ao salvar config: ${err.message}`);
+    }
+  }
+  get(key) {
+    return this.config[key];
+  }
+  getAll() {
+    return { ...this.config };
+  }
+  set(key, value) {
+    const entry = VALID_KEYS[key];
+    if (!entry) {
+      logger.error(`Chave inv\xE1lida: ${key}. Use: api-key, model, endpoint, max-tokens`);
+      return false;
+    }
+    if (!entry.validate(value)) {
+      logger.error(`Valor inv\xE1lido para "${key}": ${value}`);
+      return false;
+    }
+    const normalized = entry.normalize(value);
+    const configKey = this.mapToConfigKey(key);
+    this.config[configKey] = normalized;
+    this.save();
+    logger.success(`Config atualizada: ${key} = ${normalized}`);
+    return true;
+  }
+  mapToConfigKey(key) {
+    const map = {
+      "api-key": "apiKey",
+      "apiKey": "apiKey",
+      model: "model",
+      endpoint: "endpoint",
+      "max-tokens": "maxTokens",
+      "maxTokens": "maxTokens"
+    };
+    return map[key] || key;
+  }
+  show() {
+    const { apiKey, ...rest } = this.config;
+    const masked = apiKey ? apiKey.slice(0, 4) + "\u2026" + apiKey.slice(-4) : "(n\xE3o definida)";
+    console.log("\nConfigura\xE7\xE3o atual:");
+    console.log(`  API Key:       ${masked}`);
+    console.log(`  Model:         ${rest.model}`);
+    console.log(`  Endpoint:      ${rest.endpoint}`);
+    console.log(`  Max Tokens:    ${rest.maxTokens}`);
+    console.log(`  Config file:   ${CONFIG_PATH}
+`);
+  }
+  reset() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.save();
+    logger.success("Configura\xE7\xE3o resetada para valores padr\xE3o");
+  }
+};
+
+// src/storage/sqlite.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import Database from "better-sqlite3";
+var DB_DIR = join2(homedir2(), ".tuticli");
+var DB_PATH = join2(DB_DIR, "conversations.db");
+var Storage = class {
+  db;
+  constructor() {
+    if (!existsSync2(DB_DIR)) {
+      mkdirSync2(DB_DIR, { recursive: true });
+    }
+    this.db = new Database(DB_PATH);
+    this.db.pragma("journal_mode = WAL");
+    this.init();
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL DEFAULT 'Nova conversa',
+        model TEXT NOT NULL DEFAULT 'claude-opus-4-7',
+        created_at TEXT NOT NULL DEFAULT (datetime('now', 'localtime')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now', 'localtime'))
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now', 'localtime')),
+        FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+    `);
+  }
+  createSession(name, model) {
+    const id = crypto.randomUUID();
+    const stmt = this.db.prepare(
+      "INSERT INTO sessions (id, name, model) VALUES (?, ?, ?)"
+    );
+    stmt.run(id, name || "Nova conversa", model || "claude-opus-4-7");
+    return this.getSession(id);
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      name: row.name,
+      model: row.model,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  listSessions() {
+    const rows = this.db.prepare("SELECT * FROM sessions ORDER BY updated_at DESC").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      model: row.model,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  updateSessionName(id, name) {
+    this.db.prepare("UPDATE sessions SET name = ?, updated_at = datetime('now', 'localtime') WHERE id = ?").run(name, id);
+  }
+  deleteSession(id) {
+    this.db.prepare("DELETE FROM messages WHERE session_id = ?").run(id);
+    this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+  }
+  clearAll() {
+    this.db.exec("DELETE FROM messages");
+    this.db.exec("DELETE FROM sessions");
+  }
+  addMessage(sessionId, role, content) {
+    const stmt = this.db.prepare(
+      "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)"
+    );
+    const result = stmt.run(sessionId, role, content);
+    this.db.prepare("UPDATE sessions SET updated_at = datetime('now', 'localtime') WHERE id = ?").run(sessionId);
+    return {
+      id: result.lastInsertRowid,
+      sessionId,
+      role,
+      content
+    };
+  }
+  getMessages(sessionId) {
+    const rows = this.db.prepare("SELECT * FROM messages WHERE session_id = ? ORDER BY id ASC").all(sessionId);
+    return rows.map((row) => ({
+      id: row.id,
+      sessionId: row.session_id,
+      role: row.role,
+      content: row.content,
+      createdAt: row.created_at
+    }));
+  }
+  getMessageCount(sessionId) {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM messages WHERE session_id = ?").get(sessionId);
+    return row.count;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/tools/base.ts
+var Tool = class {
+  needsConfirmation(args) {
+    return { needed: false };
+  }
+};
+
+// src/tools/read-file.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { resolve } from "path";
+var ReadFileTool = class extends Tool {
+  definition = {
+    name: "read_file",
+    description: "Read the contents of a file. Use this to inspect source code, configs, or any text file in the project.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of lines to read (optional)"
+        },
+        offset: {
+          type: "number",
+          description: "Starting line number (1-indexed, optional)"
+        }
+      },
+      required: ["path"]
+    }
+  };
+  async execute(args) {
+    const filePath = resolve(String(args.path));
+    const limit = args.limit ? Number(args.limit) : void 0;
+    const offset = args.offset ? Number(args.offset) : void 0;
+    if (!existsSync3(filePath)) {
+      return { success: false, data: "", error: `Arquivo n\xE3o encontrado: ${filePath}` };
+    }
+    try {
+      const content = readFileSync2(filePath, "utf-8");
+      const lines = content.split("\n");
+      if (offset || limit) {
+        const start = offset ? Math.max(0, offset - 1) : 0;
+        const end = limit ? start + limit : void 0;
+        const sliced = lines.slice(start, end);
+        const total = lines.length;
+        const result = sliced.join("\n");
+        const meta = `
+[Linhas ${start + 1}-${Math.min(end || total, total)} de ${total}]`;
+        return { success: true, data: result + meta };
+      }
+      return {
+        success: true,
+        data: content
+      };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro ao ler arquivo: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/write-file.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+var WriteFileTool = class extends Tool {
+  definition = {
+    name: "write_file",
+    description: "Write content to a file. Creates the file if it does not exist, or overwrites if it does. Use for creating new files or complete rewrites.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file"
+        },
+        content: {
+          type: "string",
+          description: "Full content to write to the file"
+        }
+      },
+      required: ["path", "content"]
+    }
+  };
+  needsConfirmation() {
+    return { needed: false };
+  }
+  async execute(args) {
+    const filePath = resolve2(String(args.path));
+    const content = String(args.content ?? "");
+    try {
+      const dir = dirname(filePath);
+      if (!existsSync4(dir)) {
+        mkdirSync3(dir, { recursive: true });
+      }
+      const isNew = !existsSync4(filePath);
+      writeFileSync2(filePath, content, "utf-8");
+      return {
+        success: true,
+        data: isNew ? `Arquivo criado: ${filePath} (${content.length} bytes)` : `Arquivo atualizado: ${filePath} (${content.length} bytes)`
+      };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro ao escrever arquivo: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/edit-file.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
+import { resolve as resolve3 } from "path";
+var EditFileTool = class extends Tool {
+  definition = {
+    name: "edit_file",
+    description: "Make targeted edits to a file by finding and replacing specific text. Use for surgical changes instead of rewriting the entire file. The old_string must match exactly including whitespace.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative or absolute path to the file to edit"
+        },
+        old_string: {
+          type: "string",
+          description: "The exact text to find and replace (must match precisely)"
+        },
+        new_string: {
+          type: "string",
+          description: "The new text to replace with"
+        }
+      },
+      required: ["path", "old_string", "new_string"]
+    }
+  };
+  needsConfirmation() {
+    return { needed: false };
+  }
+  async execute(args) {
+    const filePath = resolve3(String(args.path));
+    const oldString = String(args.old_string ?? "");
+    const newString = String(args.new_string ?? "");
+    if (!existsSync5(filePath)) {
+      return { success: false, data: "", error: `Arquivo n\xE3o encontrado: ${filePath}` };
+    }
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      if (!content.includes(oldString)) {
+        return {
+          success: false,
+          data: "",
+          error: `Texto n\xE3o encontrado no arquivo. Verifique se h\xE1 diferen\xE7as de espa\xE7amento ou quebra de linha.`
+        };
+      }
+      const count = content.split(oldString).length - 1;
+      const newContent = content.replaceAll(oldString, newString);
+      writeFileSync3(filePath, newContent, "utf-8");
+      return {
+        success: true,
+        data: `Arquivo editado: ${filePath} (${count} ocorr\xEAncia${count > 1 ? "s" : ""} alterada${count > 1 ? "s" : ""})`
+      };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro ao editar arquivo: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/list-files.ts
+import { readdirSync, statSync, existsSync as existsSync6 } from "fs";
+import { resolve as resolve4, join as join3, relative } from "path";
+var IGNORED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  "__pycache__",
+  ".DS_Store",
+  "*.pyc",
+  ".gitignore"
+]);
+function shouldIgnore(name) {
+  if (IGNORED.has(name)) return true;
+  if (name.startsWith(".") && name !== ".env" && name !== ".env.example") return true;
+  return false;
+}
+function scanDir(dirPath, maxDepth, depth = 0, relativePath = "") {
+  if (depth > maxDepth) return [];
+  const entries = [];
+  try {
+    const files = readdirSync(dirPath);
+    for (const file of files) {
+      if (shouldIgnore(file)) continue;
+      const fullPath = join3(dirPath, file);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          entries.push({ name: file + "/", type: "dir" });
+          if (depth < maxDepth) {
+            const sub = scanDir(fullPath, maxDepth, depth + 1, join3(relativePath, file));
+            entries.push(...sub);
+          }
+        } else if (stat.isFile()) {
+          entries.push({ name: file, type: "file", size: stat.size });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function formatTree(entries, indent = "") {
+  let result = "";
+  for (const entry of entries) {
+    if (entry.type === "dir") {
+      result += `${indent}\u{1F4C1} ${entry.name}
+`;
+    } else {
+      result += `${indent}\u{1F4C4} ${entry.name}${entry.size !== void 0 ? ` (${formatSize(entry.size)})` : ""}
+`;
+    }
+  }
+  return result;
+}
+var ListFilesTool = class extends Tool {
+  definition = {
+    name: "list_files",
+    description: "List files and directories in the project. Shows a tree view with file sizes. Use to understand project structure.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: 'Directory path relative to project root (default: ".")'
+        },
+        depth: {
+          type: "number",
+          description: "Maximum directory depth to traverse (default: 3, max: 10)"
+        }
+      },
+      required: []
+    }
+  };
+  async execute(args) {
+    const dirPath = resolve4(String(args.path || "."));
+    const depth = Math.min(Number(args.depth || 3), 10);
+    if (!existsSync6(dirPath)) {
+      return { success: false, data: "", error: `Diret\xF3rio n\xE3o encontrado: ${dirPath}` };
+    }
+    try {
+      const entries = scanDir(dirPath, depth);
+      const cwd = process.cwd();
+      const relPath = relative(cwd, dirPath) || ".";
+      let output2 = `\u{1F4C1} ${relPath}/
+`;
+      output2 += formatTree(entries, "");
+      const fileCount = entries.filter((e) => e.type === "file").length;
+      const dirCount = entries.filter((e) => e.type === "dir").length;
+      output2 += `
+${dirCount} pastas, ${fileCount} arquivos`;
+      return { success: true, data: output2 };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro ao listar diret\xF3rio: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/glob-files.ts
+import { resolve as resolve5 } from "path";
+var IGNORE_PATTERNS = [
+  "node_modules/**",
+  ".git/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  ".cache/**",
+  "__pycache__/**",
+  "*.pyc"
+];
+var GlobFilesTool = class extends Tool {
+  definition = {
+    name: "glob",
+    description: "Find files matching a glob pattern. Use to search for files by name or extension pattern.",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Glob pattern to match (e.g., "src/**/*.ts", "*.json", "**/*.test.ts")'
+        },
+        path: {
+          type: "string",
+          description: 'Directory to search in (default: ".")'
+        }
+      },
+      required: ["pattern"]
+    }
+  };
+  async execute(args) {
+    const pattern = String(args.pattern);
+    const searchPath = String(args.path || ".");
+    try {
+      const { globSync } = await import("glob");
+      const results = globSync(pattern, {
+        cwd: resolve5(searchPath),
+        ignore: IGNORE_PATTERNS,
+        dot: false,
+        nodir: true
+      });
+      if (results.length === 0) {
+        return { success: true, data: "Nenhum arquivo encontrado para o padr\xE3o: " + pattern };
+      }
+      const sorted = results.sort();
+      const list = sorted.map((f) => `  ${f}`).join("\n");
+      return {
+        success: true,
+        data: `Arquivos encontrados (${results.length}):
+${list}`
+      };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro na busca glob: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/grep-files.ts
+import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+var MAX_FILE_SIZE = 1024 * 1024;
+function isText(buf) {
+  for (let i = 0; i < Math.min(buf.length, 4096); i++) {
+    const c = buf[i];
+    if (c === 0) return false;
+  }
+  return true;
+}
+var GrepFilesTool = class extends Tool {
+  definition = {
+    name: "grep",
+    description: "Search for a regex pattern across files in the project. Use to find where functions are defined, variables are used, or any text pattern.",
+    input_schema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Regex pattern to search for"
+        },
+        path: {
+          type: "string",
+          description: 'Directory to search in (default: ".")'
+        },
+        include: {
+          type: "string",
+          description: 'Only search files matching this glob pattern (e.g., "*.ts", "*.{ts,js}")'
+        },
+        maxResults: {
+          type: "number",
+          description: "Maximum number of results to return (default: 50)"
+        }
+      },
+      required: ["pattern"]
+    }
+  };
+  async execute(args) {
+    const rawPattern = String(args.pattern);
+    const searchPath = resolve6(String(args.path || "."));
+    const maxResults = Math.min(Number(args.maxResults || 50), 200);
+    const includePattern = args.include ? String(args.include) : void 0;
+    let regex;
+    try {
+      regex = new RegExp(rawPattern, "gi");
+    } catch {
+      return { success: false, data: "", error: `Padr\xE3o regex inv\xE1lido: ${rawPattern}` };
+    }
+    try {
+      const { globSync } = await import("glob");
+      const searchGlob = includePattern || "**/*";
+      const files = globSync(searchGlob, {
+        cwd: searchPath,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+        nodir: true,
+        dot: false
+      });
+      const results = [];
+      for (const file of files.slice(0, 500)) {
+        if (results.length >= maxResults) break;
+        const fullPath = resolve6(searchPath, file);
+        try {
+          const stat = statSync2(fullPath);
+          if (stat.size > MAX_FILE_SIZE) continue;
+          const buf = readFileSync5(fullPath);
+          if (!isText(buf)) continue;
+          const content = buf.toString("utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (results.length >= maxResults) break;
+            if (regex.test(lines[i])) {
+              const lineNum = i + 1;
+              const trimmed = lines[i].trim();
+              results.push(`${file}:${lineNum}:  ${trimmed}`);
+            }
+          }
+        } catch {
+        }
+      }
+      if (results.length === 0) {
+        return { success: true, data: `Nenhum resultado para: ${rawPattern}` };
+      }
+      return {
+        success: true,
+        data: `Resultados para "${rawPattern}" (${results.length}):
+${results.join("\n")}`
+      };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro na busca: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/project-info.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync3, existsSync as existsSync7 } from "fs";
+import { join as join4 } from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  "__pycache__",
+  ".svn",
+  ".hg",
+  "coverage"
+]);
+function scanFiles(dir, depth = 0, maxDepth = 4) {
+  if (depth > maxDepth) return [];
+  const files = [];
+  try {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      if (IGNORE_DIRS.has(entry)) continue;
+      if (entry.startsWith(".") && entry !== ".env" && entry !== ".env.example") continue;
+      const fullPath = join4(dir, entry);
+      try {
+        const stat = statSync3(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...scanFiles(fullPath, depth + 1, maxDepth));
+        } else if (stat.isFile()) {
+          const ext = entry.includes(".") ? entry.split(".").pop() : "";
+          files.push({ path: fullPath, size: stat.size, ext });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function readConfigIfExists(filePath) {
+  try {
+    if (existsSync7(filePath)) {
+      return JSON.parse(readFileSync6(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+var ProjectInfoTool = class extends Tool {
+  definition = {
+    name: "project_info",
+    description: "Get an overview of the project structure, including file counts by type, project config files, and dependency information. Use this first to understand what kind of project this is.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  };
+  async execute(_args) {
+    const cwd = process.cwd();
+    try {
+      const files = scanFiles(cwd);
+      const totalSize = files.reduce((acc, f) => acc + f.size, 0);
+      const byExt = {};
+      for (const f of files) {
+        byExt[f.ext] = (byExt[f.ext] || 0) + 1;
+      }
+      const extSummary = Object.entries(byExt).sort((a, b2) => b2[1] - a[1]).map(([ext, count]) => `  .${ext}: ${count} arquivos`).join("\n");
+      const topFiles = files.sort((a, b2) => b2.size - a.size).slice(0, 15).map((f) => {
+        const rel = f.path.replace(cwd + "/", "");
+        const sizeLabel = f.size > 1024 * 1024 ? `${(f.size / (1024 * 1024)).toFixed(1)}MB` : f.size > 1024 ? `${(f.size / 1024).toFixed(1)}KB` : `${f.size}B`;
+        return `  ${rel} (${sizeLabel})`;
+      }).join("\n");
+      let configInfo = "";
+      const pkg = readConfigIfExists(join4(cwd, "package.json"));
+      if (pkg) {
+        const name = pkg.name || "(sem nome)";
+        const deps = Object.keys(pkg.dependencies || {}).length;
+        const devDeps = Object.keys(pkg.devDependencies || {}).length;
+        const scripts = Object.keys(pkg.scripts || {}).length;
+        configInfo += `  Node.js: ${name}
+  Depend\xEAncias: ${deps} | Dev: ${devDeps} | Scripts: ${scripts}
+`;
+      }
+      const tsconfig = readConfigIfExists(join4(cwd, "tsconfig.json"));
+      if (tsconfig) {
+        configInfo += `  TypeScript: ${tsconfig.compilerOptions?.target || "presente"}
+`;
+      }
+      try {
+        const gitHead = readFileSync6(join4(cwd, ".git", "HEAD"), "utf-8").trim();
+        configInfo += `  Git: ${gitHead.replace("ref: refs/heads/", "branch ")}
+`;
+      } catch {
+      }
+      const output2 = [
+        `\u{1F4C1} Projeto: ${cwd}`,
+        ``,
+        `\u{1F4CA} Vis\xE3o geral:`,
+        `  Total: ${files.length} arquivos (${(totalSize / 1024 / 1024).toFixed(2)}MB)`,
+        ``,
+        `\u{1F4E6} Configura\xE7\xE3o:`,
+        configInfo || "  (sem configura\xE7\xE3o detectada)",
+        ``,
+        `\u{1F4C4} Tipos de arquivo:`,
+        extSummary || "  (sem arquivos)",
+        ``,
+        `\u{1F4CF} Maiores arquivos:`,
+        topFiles || "  (sem arquivos)"
+      ].join("\n");
+      return { success: true, data: output2 };
+    } catch (err) {
+      return { success: false, data: "", error: `Erro ao analisar projeto: ${err.message}` };
+    }
+  }
+};
+
+// src/tools/run-command.ts
+import { execSync } from "child_process";
+import { resolve as resolve8 } from "path";
+var BLOCKED_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "rm -rf .",
+  "mkfs",
+  "dd if=",
+  "> /dev/sd",
+  ":(){ :|:& };:",
+  "chmod 777",
+  "sudo ",
+  "su ",
+  "passwd"
+];
+function isBlocked(command) {
+  const lower = command.toLowerCase();
+  return BLOCKED_COMMANDS.some((b2) => lower.includes(b2));
+}
+var MAX_OUTPUT = 1e4;
+var RunCommandTool = class extends Tool {
+  definition = {
+    name: "run_command",
+    description: "Execute a shell command in the project directory. Use for running build commands, tests, linters, or any terminal operation. THE USER WILL BE ASKED TO CONFIRM BEFORE EXECUTION.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute"
+        },
+        workdir: {
+          type: "string",
+          description: "Working directory (default: current project root)"
+        },
+        description: {
+          type: "string",
+          description: "Explain what this command does and why it is needed"
+        }
+      },
+      required: ["command", "description"]
+    }
+  };
+  needsConfirmation(args) {
+    const cmd = String(args.command || "");
+    const desc = String(args.description || "");
+    return {
+      needed: true,
+      message: `Executar comando?
+  Descri\xE7\xE3o: ${desc}
+  Comando: ${cmd}`
+    };
+  }
+  async execute(args) {
+    const command = String(args.command || "");
+    const workdir = args.workdir ? resolve8(String(args.workdir)) : process.cwd();
+    const description = String(args.description || "");
+    if (!command) {
+      return { success: false, data: "", error: "Nenhum comando fornecido" };
+    }
+    if (isBlocked(command)) {
+      return { success: false, data: "", error: "Comando bloqueado por raz\xF5es de seguran\xE7a" };
+    }
+    try {
+      const output2 = execSync(command, {
+        cwd: workdir,
+        encoding: "utf-8",
+        timeout: 12e4,
+        maxBuffer: MAX_OUTPUT,
+        env: { ...process.env }
+      });
+      const truncated = output2.length > MAX_OUTPUT ? output2.slice(0, MAX_OUTPUT) + `
+... (sa\xEDda truncada, ${output2.length - MAX_OUTPUT} bytes omitidos)` : output2;
+      return {
+        success: true,
+        data: truncated || "(comando executado sem sa\xEDda)"
+      };
+    } catch (err) {
+      const stderr = err.stderr || "";
+      const stdout = err.stdout || "";
+      const message = err.message;
+      return {
+        success: false,
+        data: "",
+        error: `Comando falhou: ${message}
+${stderr || stdout || ""}`.trim()
+      };
+    }
+  }
+};
+
+// src/tools/index.ts
+var toolRegistry = /* @__PURE__ */ new Map();
+function register(tool) {
+  toolRegistry.set(tool.definition.name, tool);
+}
+function getAllTools() {
+  return Array.from(toolRegistry.values());
+}
+function getTool(name) {
+  return toolRegistry.get(name);
+}
+register(new ReadFileTool());
+register(new WriteFileTool());
+register(new EditFileTool());
+register(new ListFilesTool());
+register(new GlobFilesTool());
+register(new GrepFilesTool());
+register(new ProjectInfoTool());
+register(new RunCommandTool());
+
+// src/ui/components.ts
+import chalk2 from "chalk";
+import boxen from "boxen";
+var w = chalk2.bold;
+var d2 = chalk2.dim;
+var gold = chalk2.hex("#E8BF6A");
+function renderWelcome() {
+  const art = chalk2.bold(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                                  \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2551
+  \u2551   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2551
+  \u2551   \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551  \u2588\u2588\u2551 \u2551
+  \u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u2551
+  \u2551                                                  \u2551
+  \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2551
+  \u2551   \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2551
+  \u2551      \u2588\u2588\u2551    \u2588\u2588\u2551   \u2588\u2588\u2551    \u2588\u2588\u2551    \u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2551
+  \u2551      \u2588\u2588\u2551    \u2588\u2588\u2551   \u2588\u2588\u2551    \u2588\u2588\u2551    \u2588\u2588\u2551 \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2551
+  \u2551      \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D    \u2588\u2588\u2551    \u2588\u2588\u2551 \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2551
+  \u2551      \u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D     \u255A\u2550\u255D    \u255A\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D\u2551
+  \u2551                                                  \u2551
+  \u2551           CLI interativo para Claude AI          \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+  `);
+  logger.raw(art);
+  logger.raw(d2("  Comandos: /help, /clear, /sessions, /exit, /new\n"));
+}
+function renderDirConfirm(dir) {
+  console.log(
+    boxen(
+      `  ${d2("\u{1F4C1} Diret\xF3rio atual")}
+  ${w(dir)}
+
+  ${d2("O tuticli pode acessar arquivos desta pasta.")}
+  ${d2("Deseja continuar?")}`,
+      {
+        padding: 1,
+        margin: { top: 1, bottom: 0 },
+        borderStyle: "round",
+        borderColor: "white",
+        dimBorder: true
+      }
+    )
+  );
+}
+function renderHelp() {
+  console.log(boxen(
+    `
+  ${w("Comandos dispon\xEDveis")}
+
+  ${w("/help")}       Mostra esta mensagem
+  ${w("/clear")}     Limpa o hist\xF3rico da sess\xE3o atual
+  ${w("/sessions")}  Lista todas as sess\xF5es
+  ${w("/new")}       Inicia uma nova sess\xE3o
+  ${w("/exit")}      Sai do chat
+
+  ${d2("Dica:")} Pressione ${w("Ctrl+C")} para sair a qualquer momento.
+    `,
+    {
+      padding: 1,
+      margin: 0,
+      borderStyle: "round",
+      borderColor: "white",
+      dimBorder: true
+    }
+  ));
+}
+function renderFormattedContent(content) {
+  const blocks = content.split(/(```[\w-]*\n[\s\S]*?```)/);
+  return blocks.map((block) => {
+    if (!block.startsWith("```")) {
+      return block;
+    }
+    const firstLineEnd = block.indexOf("\n");
+    const langLine = block.slice(3, firstLineEnd).trim();
+    const code = block.slice(firstLineEnd + 1, -3);
+    const lines = code.split("\n");
+    const lineNumWidth = String(lines.length).length;
+    const langTag = langLine ? chalk2.bold(` ${langLine} `) : d2(" code ");
+    const codeLines = lines.map((line, i) => {
+      const num = d2(String(i + 1).padStart(lineNumWidth, " ") + " \u2502");
+      return `${num} ${gold(line)}`;
+    }).join("\n");
+    return "\n" + boxen(codeLines, {
+      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+      margin: { top: 0, bottom: 0 },
+      borderStyle: "round",
+      borderColor: "white",
+      dimBorder: true,
+      title: langTag,
+      titleAlignment: "left"
+    }) + "\n";
+  }).join("");
+}
+function renderMessage(msg) {
+  const prefix = msg.role === "user" ? w("Voc\xEA") : w("Claude");
+  if (msg.role === "assistant" && msg.content.includes("```")) {
+    const formatted = renderFormattedContent(msg.content);
+    console.log(
+      boxen(formatted, {
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        margin: { top: 1, bottom: 0 },
+        borderStyle: "round",
+        borderColor: "white",
+        dimBorder: true,
+        title: prefix,
+        titleAlignment: "left"
+      })
+    );
+  } else {
+    console.log(
+      boxen(msg.content, {
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        margin: { top: 1, bottom: 0 },
+        borderStyle: "round",
+        borderColor: "white",
+        title: prefix,
+        titleAlignment: "left"
+      })
+    );
+  }
+}
+function renderStreamStart() {
+  process.stdout.write(w("\n Claude ") + d2("(streaming...) \n"));
+}
+var TYPING_SPEED = 20;
+function delay(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+async function renderStreamChunk(text) {
+  for (const char of text) {
+    process.stdout.write(char);
+    if (char !== " " && char !== "\n") {
+      await delay(TYPING_SPEED);
+    } else if (char === "\n") {
+      await delay(TYPING_SPEED);
+    }
+  }
+}
+function renderStreamEnd() {
+  process.stdout.write("\n\n");
+}
+function renderError(msg) {
+  console.log(
+    boxen(msg, {
+      padding: 1,
+      borderStyle: "round",
+      borderColor: "white",
+      title: w(" Erro "),
+      titleAlignment: "left"
+    })
+  );
+}
+function renderSessionsTable(sessions) {
+  if (sessions.length === 0) {
+    logger.info("Nenhuma sess\xE3o encontrada.");
+    return;
+  }
+  console.log(w("\n  Sess\xF5es:\n"));
+  sessions.forEach((s, i) => {
+    const shortId = s.id.slice(0, 8);
+    const name = s.name.length > 30 ? s.name.slice(0, 30) + "\u2026" : s.name;
+    console.log(
+      `  ${d2(String(i + 1).padStart(2, " ") + ".")} ${w(name)} ${d2(shortId)} ${d2(s.model)} ${d2(s.updatedAt)}`
+    );
+  });
+  console.log();
+}
+
+// src/ui/chat.ts
+var config = new ConfigManager();
+var storage = new Storage();
+var STATUS = [
+  "Estou processando sua solicita\xE7\xE3o\u2026",
+  "Analisando sua pergunta\u2026",
+  "Consultando o modelo de IA\u2026",
+  "Preparando resposta\u2026",
+  "Processando\u2026",
+  "Aguarde um momento\u2026",
+  "Estou pensando\u2026",
+  "Buscando informa\xE7\xF5es\u2026",
+  "Analisando o contexto\u2026",
+  "Compilando conhecimento\u2026",
+  "Estruturando resposta\u2026",
+  "Consultando base de conhecimento\u2026",
+  "Processando dados\u2026",
+  "Gerando resposta\u2026",
+  "Aplicando racioc\xEDnio\u2026",
+  "Verificando informa\xE7\xF5es\u2026",
+  "Organizando pensamento\u2026",
+  "Analisando c\xF3digo\u2026",
+  "Buscando padr\xF5es\u2026",
+  "Interpretando requisi\xE7\xE3o\u2026",
+  "Conectando ao modelo\u2026",
+  "Carregando contexto\u2026",
+  "Sintetizando informa\xE7\xF5es\u2026",
+  "Avaliando melhor abordagem\u2026",
+  "Calculando resposta\u2026",
+  "Construindo solu\xE7\xE3o\u2026",
+  "Revisando\u2026",
+  "Aplicando l\xF3gica\u2026",
+  "Examinando detalhes\u2026",
+  "Preparando an\xE1lise\u2026",
+  "Coletando informa\xE7\xF5es\u2026",
+  "Analisando arquivos\u2026",
+  "Quase l\xE1\u2026",
+  "Finalizando\u2026",
+  "Validando resposta\u2026",
+  "Processando com carinho\u2026",
+  "Consultando intelig\xEAncia\u2026",
+  "Montando resultado\u2026",
+  "Reunindo dados\u2026",
+  "Elaborando resposta\u2026",
+  "Pensando profundamente\u2026",
+  "Analisando requisitos\u2026",
+  "Buscando solu\xE7\xE3o ideal\u2026"
+];
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner() {
+  let interval = null;
+  let current = "";
+  let idx = 0;
+  function clearLine() {
+    if (current) {
+      process.stderr.write(`\r${" ".repeat(current.length + 2)}\r`);
+    }
+  }
+  return {
+    start(msg) {
+      current = msg;
+      idx = 0;
+      clearLine();
+      if (!interval) {
+        interval = setInterval(() => {
+          process.stderr.write(`\r${FRAMES[idx]} ${current}`);
+          idx = (idx + 1) % FRAMES.length;
+        }, 80);
+      }
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      clearLine();
+      current = "";
+    },
+    message(msg) {
+      current = msg;
+    }
+  };
+}
+function askConfirm(msg) {
+  return new Promise((resolve9) => {
+    const rl = createInterface({ input, output });
+    rl.question(chalk3.bold(`
+ ${msg} (s/N) \u203A `), (answer) => {
+      rl.close();
+      try {
+        input.setRawMode(true);
+      } catch {
+      }
+      resolve9(answer.trim().toLowerCase() === "s");
+    });
+  });
+}
+function spinnerWithRotation(s, ms = 1800) {
+  let i = 0;
+  s.start(STATUS[i]);
+  const id = setInterval(() => {
+    i = (i + 1) % STATUS.length;
+    s.message(STATUS[i]);
+  }, ms);
+  return () => {
+    clearInterval(id);
+    s.stop();
+  };
+}
+function toolMessage(name, input2) {
+  const path = String(input2.path || input2.pattern || input2.command || "");
+  const shortPath = path.length > 50 ? path.slice(0, 50) + "\u2026" : path;
+  const icons = {
+    read_file: "\u{1F4D6} Lendo",
+    write_file: "\u270F\uFE0F Escrevendo",
+    edit_file: "\u{1F527} Editando",
+    list_files: "\u{1F4C2} Listando",
+    glob: "\u{1F4CE} Procurando",
+    grep: "\u{1F50D} Buscando",
+    project_info: "\u{1F4C1} Analisando",
+    run_command: "\u26A1 Executando"
+  };
+  const icon = icons[name] || "\u{1F6E0}\uFE0F Executando";
+  const suffix = path ? `: ${shortPath}` : "\u2026";
+  return `${icon}${suffix}`;
+}
+async function processCommand(cmd, session) {
+  const normalized = cmd.trim().toLowerCase();
+  switch (normalized) {
+    case "/help":
+      renderHelp();
+      return "continue";
+    case "/clear": {
+      const shouldClear = await askConfirm("Limpar todas as mensagens desta sess\xE3o?");
+      if (shouldClear) {
+        storage.deleteSession(session.id);
+        logger.success("Sess\xE3o limpa.");
+        return "new";
+      }
+      return "continue";
+    }
+    case "/sessions": {
+      const sessions = storage.listSessions();
+      renderSessionsTable(sessions);
+      return "continue";
+    }
+    case "/new": {
+      const shouldNew = await askConfirm("Iniciar nova sess\xE3o? (a atual ser\xE1 preservada)");
+      if (shouldNew) return "new";
+      return "continue";
+    }
+    case "/exit":
+    case "/quit":
+      return "exit";
+    default:
+      logger.warn(`Comando desconhecido: ${cmd}. Use /help para ver os comandos dispon\xEDveis.`);
+      return "continue";
+  }
+}
+async function startChat(sessionId) {
+  let session = null;
+  if (!config.get("apiKey")) {
+    renderError("API key n\xE3o configurada. Use: tuticli config set api-key SUA_API_KEY");
+    return;
+  }
+  if (sessionId) {
+    const found = storage.getSession(sessionId);
+    if (found) {
+      session = found;
+    } else {
+      logger.warn(`Sess\xE3o "${sessionId}" n\xE3o encontrada. Criando nova.`);
+    }
+  }
+  renderWelcome();
+  if (!sessionId) {
+    const cwd = process.cwd();
+    renderDirConfirm(cwd);
+    const useDir = await askConfirm("Usar este diret\xF3rio?");
+    if (!useDir) {
+      logger.warn("Diret\xF3rio n\xE3o confirmado. Apenas chat b\xE1sico dispon\xEDvel.");
+    }
+  }
+  if (!session) {
+    session = storage.createSession(void 0, config.get("model"));
+    logger.success(`Nova sess\xE3o criada: ${session.id.slice(0, 8)}`);
+  }
+  let running = true;
+  while (running) {
+    const result = await runChatLoop(session);
+    if (result === "exit") {
+      running = false;
+    } else if (result === "new") {
+      session = storage.createSession(void 0, config.get("model"));
+      logger.success(`Nova sess\xE3o criada: ${session.id.slice(0, 8)}`);
+    }
+  }
+  storage.close();
+}
+async function runChatLoop(session) {
+  const rl = createInterface({ input, output });
+  let resolvePromise;
+  const promise = new Promise((r) => {
+    resolvePromise = r;
+  });
+  let busy = false;
+  rl.setPrompt(chalk3.bold("\n Voc\xEA \u203A "));
+  rl.on("line", async (line) => {
+    if (busy) return;
+    busy = true;
+    try {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        busy = false;
+        rl.prompt();
+        return;
+      }
+      if (trimmed.startsWith("/")) {
+        const result = await processCommand(trimmed, session);
+        if (result === "exit" || result === "new") {
+          rl.close();
+          resolvePromise(result);
+          return;
+        }
+        busy = false;
+        rl.prompt();
+        return;
+      }
+      storage.addMessage(session.id, "user", trimmed);
+      renderMessage({ sessionId: session.id, role: "user", content: trimmed });
+      if (session.name === "Nova conversa") {
+        const newName = trimmed.length > 50 ? trimmed.slice(0, 50) + "\u2026" : trimmed;
+        storage.updateSessionName(session.id, newName);
+        session.name = newName;
+      }
+      const finalText = await handleToolLoop(session.id);
+      if (finalText) {
+        renderMessage({ sessionId: session.id, role: "assistant", content: finalText });
+        storage.addMessage(session.id, "assistant", finalText);
+      }
+      busy = false;
+      rl.prompt();
+    } catch (err) {
+      logger.error(`Erro: ${err}`);
+      busy = false;
+      rl.prompt();
+    }
+  });
+  rl.on("SIGINT", () => {
+    rl.close();
+    resolvePromise("exit");
+  });
+  rl.on("close", () => {
+    resolvePromise("exit");
+  });
+  rl.prompt();
+  return promise;
+}
+async function handleToolLoop(sessionId) {
+  const toolMessages = [];
+  const provider = getProvider();
+  const allTools = getAllTools().map((t) => t.definition);
+  const s = createSpinner();
+  for (let round = 0; round < 15; round++) {
+    const dbHistory = storage.getMessages(sessionId);
+    const dbMessages = dbHistory.map((m) => ({
+      role: m.role,
+      content: [{ type: "text", text: m.content }]
+    }));
+    const apiMessages = [...dbMessages, ...toolMessages];
+    if (round === 0) {
+      const stopRotate = spinnerWithRotation(s);
+      const stream = provider.chatStream(apiMessages, config.getAll(), allTools);
+      let textBuffer = "";
+      const streamToolCalls = [];
+      let gotData = false;
+      for await (const chunk of stream) {
+        if (!gotData) {
+          gotData = true;
+          stopRotate();
+        }
+        if (chunk.type === "content" && chunk.content) {
+          textBuffer += chunk.content;
+        } else if (chunk.type === "tool_use" && chunk.tool_call) {
+          streamToolCalls.push({
+            id: chunk.tool_call.id,
+            name: chunk.tool_call.name,
+            input: chunk.tool_call.input
+          });
+        } else if (chunk.type === "error") {
+          if (!gotData) stopRotate();
+          else s.stop();
+          renderError(chunk.error || "Erro desconhecido");
+          return textBuffer || chunk.error || "";
+        }
+      }
+      if (!gotData) stopRotate();
+      else s.stop();
+      if (streamToolCalls.length === 0) {
+        renderStreamStart();
+        await renderStreamChunk(textBuffer);
+        renderStreamEnd();
+        return textBuffer;
+      }
+      if (textBuffer) {
+        toolMessages.push({
+          role: "assistant",
+          content: [{ type: "text", text: textBuffer }]
+        });
+      }
+      for (const tc of streamToolCalls) {
+        let inputObj;
+        try {
+          inputObj = JSON.parse(tc.input);
+        } catch {
+          inputObj = {};
+        }
+        toolMessages.push({
+          role: "assistant",
+          content: [{
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: inputObj
+          }]
+        });
+        s.start(toolMessage(tc.name, inputObj));
+        const result = await runTool(tc.name, inputObj, s);
+        s.stop();
+        if (result.success) {
+          const display = result.data.length > 300 ? result.data.slice(0, 300) + `
+... (${result.data.length} caracteres)` : result.data;
+          logger.success(`${tc.name}: ${display}`);
+        } else if (result.error) {
+          logger.error(`${tc.name}: ${result.error}`);
+        }
+        toolMessages.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: tc.id,
+            content: result.success ? result.data : result.error || "Sem sa\xEDda"
+          }]
+        });
+      }
+    } else {
+      const stopRotate = spinnerWithRotation(s);
+      const response = await provider.chat(apiMessages, config.getAll(), allTools);
+      stopRotate();
+      if (response.toolCalls.length === 0) {
+        return response.text;
+      }
+      if (response.text) {
+        toolMessages.push({
+          role: "assistant",
+          content: [{ type: "text", text: response.text }]
+        });
+      }
+      for (const tc of response.toolCalls) {
+        let inputObj;
+        try {
+          inputObj = JSON.parse(tc.input);
+        } catch {
+          inputObj = {};
+        }
+        toolMessages.push({
+          role: "assistant",
+          content: [{
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: inputObj
+          }]
+        });
+        s.start(toolMessage(tc.name, inputObj));
+        const result = await runTool(tc.name, inputObj, s);
+        s.stop();
+        if (result.success) {
+          const display = result.data.length > 300 ? result.data.slice(0, 300) + "..." : result.data;
+          logger.success(`${tc.name}: ${display}`);
+        } else if (result.error) {
+          logger.error(`${tc.name}: ${result.error}`);
+        }
+        toolMessages.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: tc.id,
+            content: result.success ? result.data : result.error || "Sem sa\xEDda"
+          }]
+        });
+      }
+    }
+  }
+  return "";
+}
+async function runTool(name, input2, s) {
+  const tool = getTool(name);
+  if (!tool) {
+    return { success: false, data: "", error: `Ferramenta desconhecida: ${name}` };
+  }
+  const confirmCheck = tool.needsConfirmation(input2);
+  if (confirmCheck.needed) {
+    s.stop();
+    const ok = await askConfirm(confirmCheck.message || `Permitir ${name}?`);
+    s.start("Continuando\u2026");
+    if (!ok) {
+      return { success: false, data: "", error: "Opera\xE7\xE3o cancelada pelo usu\xE1rio" };
+    }
+  }
+  const result = await tool.execute(input2);
+  return result;
+}
+
+// src/commands/chat.ts
+async function chatCommand(options) {
+  const config2 = new ConfigManager();
+  if (!config2.get("apiKey")) {
+    logger.warn("API key n\xE3o configurada.");
+    logger.info("Configure com: tuticli config set api-key SUA_API_KEY");
+    return;
+  }
+  try {
+    await startChat(options.session);
+  } catch (err) {
+    logger.error(`Erro no chat: ${err.message}`);
+  }
+}
+
+// src/commands/models.ts
+import chalk4 from "chalk";
+async function modelsCommand() {
+  const config2 = new ConfigManager();
+  if (!config2.get("apiKey")) {
+    logger.warn("API key n\xE3o configurada.");
+    logger.info("Configure com: tuticli config set api-key SUA_API_KEY");
+    return;
+  }
+  process.stderr.write("Buscando modelos\u2026\r");
+  try {
+    const provider = getProvider();
+    const models = await provider.listModels(config2.getAll());
+    process.stderr.write(" ".repeat(20) + "\r");
+    console.log(chalk4.bold("\n  Modelos dispon\xEDveis:\n"));
+    models.forEach((model, i) => {
+      const isActive = model === config2.get("model");
+      const prefix = isActive ? chalk4.bold("\u2605") : chalk4.dim(`${String(i + 1).padStart(2, " ")}.`);
+      const name = isActive ? chalk4.bold(model) : model;
+      const tag = isActive ? chalk4.dim(" (em uso)") : "";
+      console.log(`  ${prefix} ${name}${tag}`);
+    });
+    console.log();
+  } catch (err) {
+    process.stderr.write(" ".repeat(20) + "\r");
+    logger.error(`Erro ao listar modelos: ${err.message}`);
+  }
+}
+
+// src/commands/config.ts
+function configCommand(subcommand, key, value) {
+  const manager = new ConfigManager();
+  switch (subcommand) {
+    case "set":
+      if (!key || !value) {
+        logger.error("Uso: tuticli config set <chave> <valor>");
+        logger.info("Chaves: api-key, model, endpoint, max-tokens");
+        return;
+      }
+      manager.set(key, value);
+      break;
+    case "get":
+      if (!key) {
+        logger.error("Uso: tuticli config get <chave>");
+        return;
+      }
+      {
+        const config2 = manager.getAll();
+        const configKey = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        const val = config2[configKey];
+        if (val !== void 0) {
+          const display = configKey === "apiKey" ? val.slice(0, 4) + "\u2026" + val.slice(-4) : String(val);
+          console.log(`${key}: ${display}`);
+        } else {
+          logger.warn(`Chave "${key}" n\xE3o encontrada`);
+        }
+      }
+      break;
+    case "show":
+      manager.show();
+      break;
+    case "reset":
+      manager.reset();
+      break;
+    default:
+      logger.error("Subcomando inv\xE1lido. Use: set, get, show, reset");
+  }
+}
+
+// src/commands/clear.ts
+import { confirm } from "@clack/prompts";
+async function clearCommand(options) {
+  const storage2 = new Storage();
+  if (options.session) {
+    const session = storage2.getSession(options.session);
+    if (!session) {
+      logger.warn(`Sess\xE3o "${options.session}" n\xE3o encontrada.`);
+      storage2.close();
+      return;
+    }
+    const msgCount = storage2.getMessageCount(session.id);
+    const proceed = options.force || await confirm({
+      message: `Limpar sess\xE3o "${session.name}" (${msgCount} mensagens)?`
+    });
+    if (proceed) {
+      storage2.deleteSession(session.id);
+      logger.success(`Sess\xE3o "${session.name}" removida.`);
+    }
+  } else if (options.all) {
+    const sessions = storage2.listSessions();
+    if (sessions.length === 0) {
+      logger.info("Nenhuma sess\xE3o para limpar.");
+      storage2.close();
+      return;
+    }
+    renderSessionsTable(sessions);
+    const proceed = options.force || await confirm({
+      message: `Remover TODAS as ${sessions.length} sess\xF5es e mensagens?`
+    });
+    if (proceed) {
+      storage2.clearAll();
+      logger.success(`Todo o hist\xF3rico foi limpo (${sessions.length} sess\xF5es removidas).`);
+    }
+  } else {
+    const sessions = storage2.listSessions();
+    if (sessions.length === 0) {
+      logger.info("Nenhuma sess\xE3o para limpar.");
+      storage2.close();
+      return;
+    }
+    renderSessionsTable(sessions);
+    logger.info("Use --all para limpar tudo, ou --session <id> para limpar uma espec\xEDfica.");
+  }
+  storage2.close();
+}
+
+// src/commands/version.ts
+import chalk5 from "chalk";
+var VERSION = "0.1.0";
+function versionCommand() {
+  const nodeVer = process.versions.node;
+  const platform = process.platform;
+  const arch = process.arch;
+  console.log(chalk5.bold(`
+  tuticli v${VERSION}`));
+  console.log(chalk5.dim(`  node ${nodeVer} | ${platform} (${arch})`));
+  console.log(chalk5.dim(`  CLI interativo para Claude AI
+`));
+}
+
+// src/commands/update.ts
+import { execSync as execSync2 } from "child_process";
+import chalk6 from "chalk";
+var VERSION2 = "0.1.0";
+async function updateCommand() {
+  console.log(chalk6.bold("\n  Verificando atualiza\xE7\xF5es\u2026\n"));
+  try {
+    const result = execSync2("npm view tuticli version --no-optional --silent 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 1e4
+    }).trim();
+    const latest = result;
+    if (latest === VERSION2) {
+      console.log(chalk6.bold(`  \u2714 Voc\xEA j\xE1 est\xE1 na vers\xE3o mais recente (v${VERSION2})
+`));
+      return;
+    }
+    console.log(chalk6.bold(`  \u26A0 Vers\xE3o dispon\xEDvel: v${latest}`));
+    console.log(chalk6.dim(`     Vers\xE3o atual:     v${VERSION2}
+`));
+    const { confirm: confirm2 } = await import("@clack/prompts");
+    const shouldUpdate = await confirm2({
+      message: `Atualizar para v${latest}?`
+    });
+    if (shouldUpdate) {
+      console.log(chalk6.dim("\n  Executando: npm install -g tuticli@latest\n"));
+      execSync2("npm install -g tuticli@latest", { stdio: "inherit" });
+      console.log(chalk6.bold(`
+  \u2714 Atualizado para v${latest}
+`));
+    }
+  } catch (err) {
+    console.log(chalk6.dim(`  Vers\xE3o atual: v${VERSION2}
+`));
+    console.log(chalk6.dim("  N\xE3o foi poss\xEDvel verificar atualiza\xE7\xF5es."));
+    console.log(chalk6.dim("  Verifique manualmente com: npm view tuticli\n"));
+  }
+}
+
+// src/cli.ts
+var VERSION3 = "0.1.0";
+var program = new Command();
+program.name("tuticli").description("CLI interativo para Claude AI").version(VERSION3).helpOption("-h, --help", "Mostra ajuda");
+program.command("chat").description("Inicia uma sess\xE3o de chat interativa").option("--new", "For\xE7a cria\xE7\xE3o de nova sess\xE3o").option("-s, --session <id>", "ID da sess\xE3o para continuar").action(async (options) => {
+  await chatCommand(options);
+});
+program.command("models").description("Lista modelos dispon\xEDveis do provider").action(async () => {
+  await modelsCommand();
+});
+program.command("config").description("Gerencia configura\xE7\xF5es do CLI").argument("[subcommand]", "Subcomando: set, get, show, reset").argument("[key]", "Chave da configura\xE7\xE3o").argument("[value]", "Valor da configura\xE7\xE3o").action((subcommand, key, value) => {
+  if (!subcommand || subcommand === "show") {
+    configCommand("show");
+    return;
+  }
+  configCommand(subcommand, key, value);
+});
+program.command("clear").description("Limpa hist\xF3rico de conversas").option("--all", "Limpa todas as sess\xF5es").option("-s, --session <id>", "Limpa uma sess\xE3o espec\xEDfica").option("-f, --force", "Pula confirma\xE7\xE3o").action(async (options) => {
+  await clearCommand(options);
+});
+program.command("version").description("Mostra a vers\xE3o instalada").action(() => {
+  versionCommand();
+});
+program.command("update").description("Verifica e instala atualiza\xE7\xF5es").action(async () => {
+  await updateCommand();
+});
+if (process.argv.length <= 2) {
+  process.argv.push("chat");
+}
+program.parse(process.argv);