stella-coder 3.9.2 → 5.0.0

package/stella-cli/index.mjs

@@ -18,8 +18,29 @@ import {
   verifyCodeIntegrity, getApiKey, saveApiKey, deleteApiKey,
   getHardwareInfo, saveIntegrityHash,
 } from "./security.mjs"
+import { runSubagent, listSubagents, parseAgentCommand, SUBAGENTS } from "./subagents.mjs"
+import { mcp, MCP_COMMANDS } from "./mcp.mjs"
+import { generatePresentation, createPresentationFromTopic, AVAILABLE_THEMES, exportToPDF } from "./presentations.mjs"
+import {
+  buildRepoMap, buildProjectContext, compressContext,
+  loadSpec, generateSpecTemplate,
+  detectTestFramework, detectLinter, detectFormatter, detectTypeChecker,
+  generateTestPrompt,
+  gitStatus, gitDiff, gitLog, gitBranches, gitCreateBranch, gitCheckout,
+  gitMerge, gitStash, gitStashPop, gitCommit, gitPush, gitPull,
+  gitCreatePR, gitListPRs, gitResolveConflicts,
+  runLinter, runFormatter, runTypeChecker, runTests,
+  applyEdits, diagnoseProject,
+  CODING_BRAIN_COMMANDS,
+} from "./coding-brain.mjs"
+import {
+  startBot, stopBot, notifyUser, notifyAll,
+  getBotStatus, TELEGRAM_BRAIN_COMMANDS,
+  verifyAuthCode, getPendingCodes,
+  generateAdminCode, listAuthorizedUsers,
+} from "./telegram-bot.mjs"
 
-const VERSION = "3.9.1"
+const VERSION = "5.0.0"
 const CONFIG_DIR = path.join(os.homedir(), ".stella")
 const CONFIG_PATH = path.join(CONFIG_DIR, "config.json")
 const HISTORY_PATH = path.join(CONFIG_DIR, "history.json")
@@ -125,17 +146,41 @@ if (args.includes("--model")) state.model = args[args.indexOf("--model") + 1] ||
 function systemPrompt() {
   let projectContext = ""
   try {
-    if (fs.existsSync("STELLA.md")) projectContext = "\n\n# Контекст проекта (STELLA.md)\n" + fs.readFileSync("STELLA.md", "utf8")
+    // Auto-load SPEC.md, CLAUDE.md, AGENTS.md, STELLA.md
+    for (const specFile of ["SPEC.md", "CLAUDE.md", "AGENTS.md", "STELLA.md"]) {
+      const p = path.join(process.cwd(), specFile)
+      if (fs.existsSync(p)) {
+        projectContext += `\n\n# ${specFile}\n` + fs.readFileSync(p, "utf8").slice(0, 10000)
+      }
+    }
+  } catch {}
+
+  // Build repo map for context
+  let repoContext = ""
+  try {
+    const map = buildRepoMap(process.cwd())
+    repoContext = `\n\n# Карта проекта (${map.summary})\n\`\`\`\n${map.tree.slice(0, 200).join("\n")}\n\`\`\``
   } catch {}
-  return `Ты — Stella, ИИ-агент терминального агента Stella Coder 3.9 (аналог Claude Code).
-Ты — эксперт-программист, работающий в директории: ${process.cwd()} (ОС: ${os.platform()}).
+
+  return `Ты — Stella, ИИ-агент терминального агента Stella Coder 4.0 (аналог Claude Code / Cursor).
+Ты — эксперт-программист с огромным контекстом, работающий в: ${process.cwd()} (ОС: ${os.platform()}).
+
+Твои возможности:
+- Огромный контекст: ты "держишь в голове" структуру всего репозитория
+- Spec-Driven Development: работай по SPEC.md / CLAUDE.md
+- TDD: пиши тесты, прав код, запускай линтеры — всё автономно
+- Multi-file editing: правь 15+ файлов за раз
+- Git экосистема: ветки, PR, мержи, разрешение конфликтов
+- Автосжатие контекста при необходимости
 
 Правила:
-- Используй инструменты (read_file, edit_file, write_file, bash, grep, glob, list_dir), чтобы РЕАЛЬНО выполнять задачи, а не просто описывать их.
+- Используй инструменты (read_file, edit_file, write_file, bash, grep, glob, list_dir), чтобы РЕАЛЬНО выполнять задачи.
 - Перед изменением файла всегда читай его.
-- Для многошаговых задач используй todo_write, чтобы показать план.
+- Для многошаговых задач используй todo_write.
+- Автоматически определяй и запускай линтеры/тесты после изменений.
+- При большом контексте — сжимай автоматически.
 - Отвечай кратко и по делу, в формате markdown. Код — в блоках с указанием языка.
-- Отвечай на языке пользователя.${projectContext}`
+- Отвечай на языке пользователя.${projectContext}${repoContext}`
 }
 
 // ---------- spinner ----------
@@ -566,6 +611,37 @@ const COMMANDS = [
   // Ollama
   ["/ollama", "подключить локальную LLM (Ollama)"],
 
+  // Презентации
+  ["/presentation", "создать презентацию из темы"],
+  ["/presentation-theme", "показать доступные темы оформления"],
+  ["/presentation-list", "показать созданные презентации"],
+  ["/presentation-custom", "создать кастомную презентацию"],
+  ["/presentation-export", "экспортировать презентацию в PDF"],
+
+  // Coding Brain
+  ["/brain", "показать контекст и инструменты проекта"],
+  ["/brain-map", "построить карту репозитория"],
+  ["/brain-compress", "сжать контекст сессии"],
+  ["/spec", "показать/создать SPEC.md"],
+  ["/tdd", "автономный TDD-цикл"],
+  ["/lint-auto", "автоматический линтер + исправление"],
+  ["/format-auto", "автоформатирование кода"],
+  ["/typecheck-auto", "автопроверка типов"],
+  ["/test-auto", "автозапуск тестов"],
+  ["/git-eco", "полная информация о Git"],
+  ["/git-pr", "создать Pull Request"],
+  ["/git-merge-auto", "автоматический merge с разрешением конфликтов"],
+  ["/fix-all", "полный цикл: линтер → форматер → типы → тесты"],
+
+  // Telegram Bot
+  ["/tg", "запустить Telegram бота"],
+  ["/tg-stop", "остановить Telegram бота"],
+  ["/tg-notify", "отправить уведомление в Telegram"],
+  ["/tg-sessions", "показать Telegram сессии"],
+  ["/tg-verify", "привязать Telegram аккаунт по коду"],
+  ["/tg-code", "сгенерировать код для продажи доступа"],
+  ["/tg-users", "показать кто подключён"],
+
   // Управление компьютером
   ["/open", "открыть приложение/файл/URL"],
   ["/app", "запустить приложение"],
@@ -647,6 +723,29 @@ const COMMANDS = [
 async function handleCommand(line) {
   const [cmd, ...rest] = line.trim().split(/\s+/)
   const arg = rest.join(" ")
+  
+  // Handle @agent commands
+  if (cmd.startsWith("@")) {
+    const agentName = cmd.slice(1)
+    const agents = listSubagents()
+    const agent = agents.find(a => a.id === agentName)
+    if (agent) {
+      if (!arg) {
+        console.log(dim(`\n  Использование: @${agentName} <задача>\n`))
+        return
+      }
+      const result = await runSubagent(agentName, arg, {
+        apiKey,
+        model: state.model,
+        tools: createTools({ ask: askPermission }),
+      })
+      if (result.result) {
+        console.log("\n" + renderMarkdown(result.result) + "\n")
+      }
+      return
+    }
+  }
+  
   switch (cmd) {
     case "/help": {
       console.log()
@@ -663,6 +762,10 @@ async function handleCommand(line) {
         ["📦 Пакеты", ["/install", "/uninstall", "/outdated", "/deps"]],
         ["💻 Система", ["/env", "/path", "/which", "/whoami", "/hostname", "/uname", "/uptime", "/disk", "/mem", "/cpu", "/net", "/ps", "/kill"]],
         ["📚 Документация", ["/docs", "/readme", "/changelog", "/examples", "/tutorial", "/wizard"]],
+        ["📊 Презентации", ["/presentation", "/presentation-theme", "/presentation-list", "/presentation-custom", "/presentation-export"]],
+        ["🧠 Coding Brain", ["/brain", "/brain-map", "/brain-compress", "/spec", "/tdd", "/lint-auto", "/format-auto", "/typecheck-auto", "/test-auto", "/fix-all"]],
+        ["📱 Telegram", ["/tg", "/tg-stop", "/tg-notify", "/tg-sessions", "/tg-verify", "/tg-code", "/tg-users"]],
+        ["🔀 Git Экосистема", ["/git-eco", "/git-pr", "/git-merge-auto"]],
         ["⚙️ Настройки", ["/help", "/model", "/clear", "/compact", "/cost", "/context", "/config", "/version", "/login", "/newkey", "/doctor", "/sessions", "/color", "/lang", "/shortcut"]],
       ]
       for (const [cat, cmds] of categories) {
@@ -1293,17 +1396,83 @@ async function handleCommand(line) {
       return
     }
     case "/mcp": {
-      console.log(box([
-        violet("/mcp list") + dim(" — список MCP серверов"),
-        violet("/mcp add <url>") + dim(" — добавить сервер"),
-        violet("/mcp remove <url>") + dim(" — удалить сервер"),
-        violet("/mcp status") + dim(" — статус подключений"),
-        "",
-        dim("MCP (Model Context Protocol) расширяет инструменты AI."),
-      ], { title: "MCP Серверы", padding: 2 }))
+      // Delegate to MCP command handler
+      const mcpHandler = MCP_COMMANDS["/mcp"]?.handler
+      if (mcpHandler) {
+        await mcpHandler(arg || "help")
+      } else {
+        console.log(box([
+          violet("/mcp list") + dim(" — список серверов"),
+          violet("/mcp start <имя>") + dim(" — запустить сервер"),
+          violet("/mcp stop <имя>") + dim(" — остановить сервер"),
+          violet("/mcp add <имя> <команда> [args]") + dim(" — добавить сервер"),
+          violet("/mcp remove <имя>") + dim(" — удалить сервер"),
+          violet("/mcp tools") + dim(" — список инструментов"),
+          "",
+          dim("MCP (Model Context Protocol) расширяет инструменты AI."),
+        ], { title: "MCP Серверы", padding: 2 }))
+      }
       console.log()
       return
     }
+    case "/agent": {
+      const agents = listSubagents()
+      if (!arg || arg === "list" || arg === "список") {
+        console.log(box([
+          ...agents.map(a => `${a.icon} ${violet(a.name)}` + dim(` — ${a.description}`)),
+          "",
+          dim("Запуск: ") + violet("@имя_агента задача"),
+        ], { title: "Субагенты Stella", padding: 2 }))
+        console.log()
+        return
+      }
+      // Parse @agent task format
+      const agentMatch = parseAgentCommand(`@${arg}`)
+      if (agentMatch) {
+        const result = await runSubagent(agentMatch.agent, agentMatch.task, {
+          apiKey,
+          model: state.model,
+          tools: createTools({ ask: askPermission }),
+        })
+        if (result.result) {
+          console.log("\n" + renderMarkdown(result.result) + "\n")
+        }
+      } else {
+        // Run as general subagent task
+        const result = await runSubagent("codebase-investigator", arg, {
+          apiKey,
+          model: state.model,
+          tools: createTools({ ask: askPermission }),
+        })
+        if (result.result) {
+          console.log("\n" + renderMarkdown(result.result) + "\n")
+        }
+      }
+      return
+    }
+    case "@codebase-investigator":
+    case "@security-auditor":
+    case "@test-writer":
+    case "@docs-writer":
+    case "@refactor":
+    case "@debugger":
+    case "@performance":
+    case "@git-expert": {
+      const agentName = command.slice(1) // Remove @
+      if (!arg) {
+        console.log(dim(`\n  Использование: @${agentName} <задача>\n`))
+        return
+      }
+      const result = await runSubagent(agentName, arg, {
+        apiKey,
+        model: state.model,
+        tools: createTools({ ask: askPermission }),
+      })
+      if (result.result) {
+        console.log("\n" + renderMarkdown(result.result) + "\n")
+      }
+      return
+    }
 
     // ═══════════════════════════════════════════════════
     //  ВЕБ И КОНТЕНТ
@@ -2471,6 +2640,753 @@ async function handleCommand(line) {
       goodbye()
       return
     }
+
+    // ═══════════════════════════════════════════════════
+    //  ПРЕЗЕНТАЦИИ
+    // ═══════════════════════════════════════════════════
+    case "/presentation": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /presentation <тема> [тема_оформления]\n"))
+        console.log(dim("  Пример: /presentation \"Машинное обучение\" modern\n"))
+        return
+      }
+      const parts = arg.split(/\s+/)
+      const topic = parts[0]
+      const theme = parts[1] || "modern"
+      
+      console.log()
+      startSpinner("Создаю презентацию")
+      
+      try {
+        const result = createPresentationFromTopic(topic, {
+          theme,
+          slidesCount: 8,
+          author: "Stella Coder",
+        })
+        
+        stopSpinner()
+        console.log(box([
+          green("✓ Презентация создана!"),
+          "",
+          dim("Тема: ") + white(topic),
+          dim("Тема оформления: ") + white(result.theme),
+          dim("Слайдов: ") + white(String(result.slidesCount)),
+          "",
+          dim("Путь: ") + cyan(result.outputDir),
+          "",
+          white("Откройте index.html в браузере для просмотра"),
+        ], { title: "Презентация", color: green, padding: 2 }))
+        console.log()
+        
+        // Open in browser
+        const openBrowser = await question("  " + green("Открыть в браузере? (y/n) › "))
+        if (openBrowser.trim().toLowerCase() === "y" || openBrowser.trim().toLowerCase() === "д") {
+          try {
+            const indexPath = result.outputDir + "/index.html"
+            execSync(`start "" "${indexPath}"`, { shell: "cmd.exe", stdio: "pipe" })
+            console.log(green("  ✓ Презентация открыта в браузере\n"))
+          } catch (e) {
+            console.log(yellow("  ⚠ Не удалось открыть автоматически: ") + String(e?.message || e).slice(0, 100) + "\n")
+          }
+        }
+      } catch (e) {
+        stopSpinner()
+        console.log(red("  ✗ Ошибка: ") + String(e?.message || e).slice(0, 200) + "\n")
+      }
+      return
+    }
+
+    case "/presentation-theme": {
+      console.log(box([
+        ...AVAILABLE_THEMES.map(t =>
+          violet(t.id) + dim(" — ") + white(t.name) + dim(` (${t.colors.primary})`)
+        ),
+      ], { title: "Доступные темы презентаций", padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/presentation-custom": {
+      console.log(dim("\n  Создание кастомной презентации"))
+      console.log(dim("  Введите данные для каждого слайда:\n"))
+      
+      const title = await question("  " + green("Заголовок презентации › "))
+      if (!title.trim()) {
+        console.log(red("  Заголовок не может быть пустым\n"))
+        return
+      }
+      
+      const author = await question("  " + green("Автор › "))
+      const themeChoice = await question("  " + green("Тема (modern/elegant/creative/minimal/tech) › "))
+      const theme = themeChoice.trim() || "modern"
+      
+      const slides = []
+      let slideNum = 1
+      
+      while (true) {
+        console.log(dim(`\n  Слайд ${slideNum}:`))
+        const slideTitle = await question("  " + green("Заголовок слайда (пусто для завершения) › "))
+        if (!slideTitle.trim()) break
+        
+        const slideType = await question("  " + green("Тип (content/twoColumn/quote) › "))
+        const slideContent = await question("  " + green("Содержимое (через запятую) › "))
+        
+        slides.push({
+          type: slideType.trim() || "content",
+          title: slideTitle.trim(),
+          items: slideContent.split(",").map(i => i.trim()).filter(i => i),
+        })
+        
+        slideNum++
+      }
+      
+      if (slides.length === 0) {
+        console.log(red("  Не добавлено ни одного слайда\n"))
+        return
+      }
+      
+      console.log()
+      startSpinner("Создаю кастомную презентацию")
+      
+      try {
+        const result = generatePresentation({
+          title: title.trim(),
+          author: author.trim(),
+          slides,
+          theme,
+          outputDir: `presentation-${title.trim().toLowerCase().replace(/\s+/g, '-')}`,
+        })
+        
+        stopSpinner()
+        console.log(box([
+          green("✓ Кастомная презентация создана!"),
+          "",
+          dim("Тема: ") + white(title.trim()),
+          dim("Автор: ") + white(author.trim() || "Не указан"),
+          dim("Тема оформления: ") + white(result.theme),
+          dim("Слайдов: ") + white(String(result.slidesCount)),
+          "",
+          dim("Путь: ") + cyan(result.outputDir),
+        ], { title: "Кастомная презентация", color: green, padding: 2 }))
+        console.log()
+      } catch (e) {
+        stopSpinner()
+        console.log(red("  ✗ Ошибка: ") + String(e?.message || e).slice(0, 200) + "\n")
+      }
+      return
+    }
+
+    case "/presentation-list": {
+      const outputDirs = fs.readdirSync(process.cwd()).filter(f => 
+        f.startsWith("presentation-") && fs.statSync(f).isDirectory()
+      )
+      
+      if (outputDirs.length === 0) {
+        console.log(dim("\n  Нет созданных презентаций\n"))
+      } else {
+        console.log(box([
+          ...outputDirs.map((d, i) =>
+            violet(String(i + 1)) + dim(" — ") + white(d)
+          ),
+        ], { title: "Ваши презентации", padding: 2 }))
+        console.log()
+      }
+      return
+    }
+
+    case "/presentation-export": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /presentation-export <путь_к_презентации>\n"))
+        console.log(dim("  Пример: /presentation-export presentation-моя-презентация\n"))
+        return
+      }
+      
+      const presentationDir = arg.trim()
+      if (!fs.existsSync(presentationDir)) {
+        console.log(red(`  ✗ Директория не найдена: ${presentationDir}\n`))
+        return
+      }
+      
+      console.log()
+      startSpinner("Создаю версию для печати")
+      
+      try {
+        const result = exportToPDF(presentationDir)
+        stopSpinner()
+        
+        console.log(box([
+          green("✓ Версия для печати создана!"),
+          "",
+          dim("Файл: ") + cyan(result.printPath),
+          "",
+          white("Откройте print.html в браузере"),
+          white("Используйте Ctrl+P для экспорта в PDF"),
+        ], { title: "Экспорт в PDF", color: green, padding: 2 }))
+        console.log()
+        
+        // Open print version
+        const openPrint = await question("  " + green("Открыть версию для печати? (y/n) › "))
+        if (openPrint.trim().toLowerCase() === "y" || openPrint.trim().toLowerCase() === "д") {
+          try {
+            execSync(`start "" "${result.printPath}"`, { shell: "cmd.exe", stdio: "pipe" })
+            console.log(green("  ✓ Версия для печати открыта\n"))
+          } catch (e) {
+            console.log(yellow("  ⚠ Не удалось открыть автоматически: ") + String(e?.message || e).slice(0, 100) + "\n")
+          }
+        }
+      } catch (e) {
+        stopSpinner()
+        console.log(red("  ✗ Ошибка: ") + String(e?.message || e).slice(0, 200) + "\n")
+      }
+      return
+    }
+
+    // ═══════════════════════════════════════════════════
+    //  CODING BRAIN
+    // ═══════════════════════════════════════════════════
+    case "/brain": {
+      console.log()
+      startSpinner("Анализирую проект")
+      const diag = diagnoseProject(process.cwd())
+      stopSpinner()
+
+      console.log(box([
+        dim("Репозиторий:  ") + white(diag.repo),
+        dim("SPEC:         ") + (diag.spec !== "not found" ? green(diag.spec) : yellow("не найден")),
+        dim("Тесты:        ") + (diag.test !== "not detected" ? green(diag.test) : yellow("не обнаружены")),
+        dim("Линтер:       ") + (diag.linter !== "not detected" ? green(diag.linter) : yellow("не обнаружен")),
+        dim("Форматер:     ") + (diag.formatter !== "not detected" ? green(diag.formatter) : yellow("не обнаружен")),
+        dim("Типы:         ") + (diag.typeChecker !== "not detected" ? green(diag.typeChecker) : yellow("не обнаружен")),
+        "",
+        dim("Git ветка:    ") + violet(diag.git.branch),
+        dim("Git статус:   ") + (diag.git.clean ? green("чисто") : yellow(`${diag.git.files} файлов`)),
+        diag.git.ahead ? dim("Впереди:      ") + cyan(String(diag.git.ahead)) : "",
+        diag.git.behind ? dim("Позади:       ") + cyan(String(diag.git.behind)) : "",
+      ], { title: "🧠 Coding Brain", color: violet, padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/brain-map": {
+      console.log()
+      startSpinner("Строю карту репозитория")
+      const map = buildRepoMap(process.cwd())
+      stopSpinner()
+
+      console.log(box([
+        dim("Файлов: ") + white(String(map.fileCount)),
+        dim("Размер: ") + white(map.totalSize),
+        "",
+        dim("Типы файлов:"),
+        ...Object.entries(map.fileTypes)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 15)
+          .map(([ext, count]) => `  ${violet(ext)} ${dim("—")} ${white(String(count))}`),
+      ], { title: "Карта репозитория", color: cyan, padding: 2 }))
+      console.log()
+
+      const showTree = await question("  " + green("Показать дерево файлов? (y/n) › "))
+      if (showTree.trim().toLowerCase() === "y") {
+        console.log()
+        map.tree.slice(0, 100).forEach(l => console.log(dim("  ") + l))
+        if (map.tree.length > 100) console.log(dim(`  ... и ещё ${map.tree.length - 100} файлов`))
+        console.log()
+      }
+      return
+    }
+
+    case "/brain-compress": {
+      console.log()
+      const msgCount = state.messages.length
+      const chars = JSON.stringify(state.messages).length
+      console.log(dim(`  Контекст: ${msgCount} сообщений, ${Math.round(chars / 1000)}K символов`))
+
+      if (chars < COMPRESS_THRESHOLD) {
+        console.log(green("  Контекст ещё не нуждается в сжатии\n"))
+        return
+      }
+
+      const confirm = await question("  " + yellow(`Сжать контекст? (${Math.round(chars / 1000)}K → ~50K) (y/n) › `))
+      if (confirm.trim().toLowerCase() !== "y") {
+        console.log(dim("  Отмена\n"))
+        return
+      }
+
+      startSpinner("Сжимаю контекст")
+      state.messages = await compressContext(state.messages, getModel(state.model))
+      stopSpinner()
+
+      const newChars = JSON.stringify(state.messages).length
+      console.log(green(`  ✓ Контекст сжат: ${Math.round(chars / 1000)}K → ${Math.round(newChars / 1000)}K\n`))
+      return
+    }
+
+    case "/spec": {
+      const spec = loadSpec(process.cwd())
+      if (spec.exists) {
+        console.log(box([
+          dim("Файл: ") + white(spec.file),
+          "",
+          spec.content.slice(0, 2000),
+          spec.content.length > 2000 ? dim(`\n... [показано ${2000} из ${spec.content.length} символов]`) : "",
+        ], { title: "SPEC", color: cyan, padding: 2 }))
+      } else {
+        console.log(yellow("\n  SPEC.md не найден в проекте"))
+        const createSpec = await question("  " + green("Создать SPEC.md? (y/n) › "))
+        if (createSpec.trim().toLowerCase() === "y") {
+          const name = await question("  " + green("Название проекта › "))
+          const desc = await question("  " + green("Описание › "))
+          const content = generateSpecTemplate(name, desc)
+          fs.writeFileSync(path.join(process.cwd(), "SPEC.md"), content)
+          console.log(green("  ✓ SPEC.md создан\n"))
+        }
+      }
+      return
+    }
+
+    case "/tdd": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /tdd <путь к файлу>\n"))
+        return
+      }
+
+      const filePath = arg.trim()
+      if (!fs.existsSync(filePath)) {
+        console.log(red(`  ✗ Файл не найден: ${filePath}\n`))
+        return
+      }
+
+      console.log()
+      const fileContent = fs.readFileSync(filePath, "utf8")
+      const spec = loadSpec(process.cwd())
+      const testPrompt = generateTestPrompt(filePath, fileContent, spec.content)
+
+      startSpinner("Генерирую тесты")
+      try {
+        const { text } = await generateText({
+          model: getModel(state.model),
+          messages: [{ role: "user", content: testPrompt.prompt }],
+        })
+        stopSpinner()
+
+        const testFilePath = path.join(process.cwd(), testPrompt.testFile)
+        fs.writeFileSync(testFilePath, text.replace(/```[\s\S]*?\n/g, "").replace(/```/g, "").trim())
+
+        console.log(green(`  ✓ Тесты созданы: ${testPrompt.testFile}`))
+
+        // Run tests
+        const framework = detectTestFramework(process.cwd())
+        if (framework.detected) {
+          startSpinner("Запускаю тесты")
+          const result = runTests(process.cwd(), framework)
+          stopSpinner()
+          if (result.success) {
+            console.log(green("  ✓ Тесты пройдены!"))
+          } else {
+            console.log(red("  ✗ Тесты упали:"))
+            console.log(dim(result.output?.slice(0, 500) || ""))
+          }
+        }
+      } catch (e) {
+        stopSpinner()
+        console.log(red("  ✗ Ошибка: ") + String(e?.message || e).slice(0, 200) + "\n")
+      }
+      console.log()
+      return
+    }
+
+    case "/lint-auto": {
+      console.log()
+      const linter = detectLinter(process.cwd())
+      if (!linter.detected) {
+        console.log(yellow("  Линтер не обнаружен в проекте\n"))
+        return
+      }
+
+      startSpinner(`Запускаю ${linter.name}`)
+      const result = runLinter(process.cwd(), linter)
+      stopSpinner()
+
+      if (result.success && !result.hasErrors) {
+        console.log(green(`  ✓ ${linter.name}: ошибок нет`))
+      } else {
+        console.log(yellow(`  ⚠ ${linter.name}: найдены проблемы`))
+        console.log(dim(result.output?.slice(0, 1000) || ""))
+
+        const fix = await question("  " + green("Автоматически исправить? (y/n) › "))
+        if (fix.trim().toLowerCase() === "y") {
+          startSpinner("Исправляю")
+          try {
+            execSync(`${linter.cmd} --fix .`, { cwd: process.cwd(), encoding: "utf8", timeout: 60000 })
+            stopSpinner()
+            console.log(green("  ✓ Исправлено\n"))
+          } catch (e) {
+            stopSpinner()
+            console.log(red("  ✗ Ошибка исправления: ") + String(e?.message || e).slice(0, 200) + "\n")
+          }
+        }
+      }
+      return
+    }
+
+    case "/format-auto": {
+      console.log()
+      const formatter = detectFormatter(process.cwd())
+      if (!formatter.detected) {
+        console.log(yellow("  Форматер не обнаружен в проекте\n"))
+        return
+      }
+
+      startSpinner(`Форматирую (${formatter.name})`)
+      const result = runFormatter(process.cwd(), formatter)
+      stopSpinner()
+
+      if (result.success) {
+        console.log(green(`  ✓ ${formatter.name}: код отформатирован`))
+      } else {
+        console.log(red(`  ✗ ${formatter.name}: `) + String(result.error || "").slice(0, 200))
+      }
+      console.log()
+      return
+    }
+
+    case "/typecheck-auto": {
+      console.log()
+      const checker = detectTypeChecker(process.cwd())
+      if (!checker.detected) {
+        console.log(yellow("  Проверщик типов не обнаружен\n"))
+        return
+      }
+
+      startSpinner(`Проверяю типы (${checker.name})`)
+      const result = runTypeChecker(process.cwd(), checker)
+      stopSpinner()
+
+      if (result.success && !result.hasErrors) {
+        console.log(green(`  ✓ ${checker.name}: ошибок нет`))
+      } else {
+        console.log(yellow(`  ⚠ ${checker.name}: найдены ошибки`))
+        console.log(dim(result.output?.slice(0, 1000) || ""))
+      }
+      console.log()
+      return
+    }
+
+    case "/test-auto": {
+      console.log()
+      const framework = detectTestFramework(process.cwd())
+      if (!framework.detected) {
+        console.log(yellow("  Фреймворк тестов не обнаружен\n"))
+        return
+      }
+
+      startSpinner(`Запускаю тесты (${framework.framework})`)
+      const result = runTests(process.cwd(), framework)
+      stopSpinner()
+
+      if (result.success) {
+        console.log(green("  ✓ Тесты пройдены!"))
+        console.log(dim(result.output?.slice(-500) || ""))
+      } else {
+        console.log(red("  ✗ Тесты упали:"))
+        console.log(dim(result.output?.slice(0, 1000) || ""))
+      }
+      console.log()
+      return
+    }
+
+    case "/fix-all": {
+      console.log()
+      console.log(dim("  Полный цикл исправления: линтер → форматер → типы → тесты\n"))
+
+      // 1. Linter
+      const linter = detectLinter(process.cwd())
+      if (linter.detected) {
+        startSpinner(`Линтер (${linter.name})`)
+        try { execSync(`${linter.cmd} --fix .`, { cwd: process.cwd(), encoding: "utf8", timeout: 60000 }) } catch {}
+        stopSpinner()
+        console.log(green(`  ✓ ${linter.name} выполнен`))
+      }
+
+      // 2. Formatter
+      const formatter = detectFormatter(process.cwd())
+      if (formatter.detected) {
+        startSpinner(`Форматер (${formatter.name})`)
+        runFormatter(process.cwd(), formatter)
+        stopSpinner()
+        console.log(green(`  ✓ ${formatter.name} выполнен`))
+      }
+
+      // 3. Type checker
+      const checker = detectTypeChecker(process.cwd())
+      if (checker.detected) {
+        startSpinner(`Типы (${checker.name})`)
+        const typeResult = runTypeChecker(process.cwd(), checker)
+        stopSpinner()
+        if (typeResult.success) {
+          console.log(green(`  ✓ ${checker.name}: ошибок нет`))
+        } else {
+          console.log(yellow(`  ⚠ ${checker.name}: есть ошибки`))
+        }
+      }
+
+      // 4. Tests
+      const framework = detectTestFramework(process.cwd())
+      if (framework.detected) {
+        startSpinner(`Тесты (${framework.framework})`)
+        const testResult = runTests(process.cwd(), framework)
+        stopSpinner()
+        if (testResult.success) {
+          console.log(green("  ✓ Тесты пройдены"))
+        } else {
+          console.log(red("  ✗ Тесты упали"))
+        }
+      }
+
+      console.log(green("\n  ✓ Полный цикл завершён\n"))
+      return
+    }
+
+    case "/git-eco": {
+      console.log()
+      startSpinner("Собираю Git-информацию")
+      const git = gitStatus(process.cwd())
+      const branches = gitBranches(process.cwd())
+      const log = gitLog(process.cwd(), 10)
+      stopSpinner()
+
+      console.log(box([
+        dim("Ветка:     ") + violet(git.branch),
+        dim("Статус:    ") + (git.clean ? green("чисто") : yellow(`${git.files.length} изменений`)),
+        git.ahead ? dim("Впереди:   ") + cyan(String(git.ahead)) : "",
+        git.behind ? dim("Позади:    ") + cyan(String(git.behind)) : "",
+        git.stashCount ? dim("Stash:     ") + cyan(String(git.stashCount)) : "",
+        "",
+        dim("Ветки:"),
+        ...branches.slice(0, 10).map(b => `  ${b.includes("*") ? green(b) : dim(b)}`),
+      ], { title: "Git Экосистема", color: cyan, padding: 2 }))
+
+      if (log) {
+        console.log(dim("\nПоследние коммиты:"))
+        log.split("\n").slice(0, 5).forEach(l => console.log(dim("  ") + l))
+      }
+      console.log()
+      return
+    }
+
+    case "/git-pr": {
+      console.log()
+      const title = await question("  " + green("Название PR › "))
+      if (!title.trim()) { console.log(red("  Название не может быть пустым\n")); return }
+      const body = await question("  " + green("Описание (необязательно) › "))
+      const base = await question("  " + green("Базовая ветка (main) › "))
+
+      startSpinner("Создаю Pull Request")
+      const result = gitCreatePR(process.cwd(), title.trim(), body || title.trim(), base.trim() || "main")
+      stopSpinner()
+
+      if (result.success) {
+        console.log(green(`  ✓ PR создан: ${result.url}`))
+      } else {
+        console.log(red("  ✗ Ошибка: ") + String(result.error || "").slice(0, 200))
+      }
+      console.log()
+      return
+    }
+
+    case "/git-merge-auto": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /git-merge-auto <ветка>\n"))
+        return
+      }
+
+      const branch = arg.trim()
+      console.log()
+      startSpinner(`Мержу ${branch}`)
+      const result = gitMerge(process.cwd(), branch)
+      stopSpinner()
+
+      if (result.success) {
+        console.log(green(`  ✓ ${branch} успешно смержена`))
+      } else if (result.conflict) {
+        console.log(yellow(`  ⚠ Конфликт в ${result.files.length} файлах:`))
+        result.files.forEach(f => console.log(dim(`    - ${f}`)))
+
+        const resolve = await question("  " + green("Разрешить конфликты (theirs)? (y/n) › "))
+        if (resolve.trim().toLowerCase() === "y") {
+          startSpinner("Разрешаю конфликты")
+          const resolved = gitResolveConflicts(process.cwd(), "theirs")
+          stopSpinner()
+          if (resolved.success) {
+            console.log(green(`  ✓ Конфликты разрешены в ${resolved.resolved?.length || 0} файлах`))
+          } else {
+            console.log(red("  ✗ Ошибка: ") + String(resolved.error || "").slice(0, 200))
+          }
+        }
+      } else {
+        console.log(red("  ✗ Ошибка: ") + String(result.error || "").slice(0, 200))
+      }
+      console.log()
+      return
+    }
+
+    // ═══════════════════════════════════════════════════
+    //  TELEGRAM BOT
+    // ═══════════════════════════════════════════════════
+    case "/tg": {
+      console.log()
+      startSpinner("Запускаю Telegram бота")
+      const botResult = await startBot()
+      stopSpinner()
+
+      if (botResult) {
+        const status = getBotStatus()
+        console.log(box([
+          green("✓ Telegram бот запущен!"),
+          "",
+          dim("Бот: ") + cyan("@" + "stella_coder_bot"),
+          dim("Статус: ") + green("онлайн"),
+          "",
+          white("Откройте Telegram и найдите @stella_coder_bot"),
+          white("Нажмите /start для авторизации"),
+        ], { title: "Telegram Bot", color: blue, padding: 2 }))
+      } else {
+        console.log(red("  ✗ Не удалось запустить бота\n"))
+      }
+      console.log()
+      return
+    }
+
+    case "/tg-stop": {
+      console.log()
+      await stopBot()
+      console.log(green("  ✓ Telegram бот остановлен\n"))
+      return
+    }
+
+    case "/tg-notify": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /tg-notify <сообщение>\n"))
+        return
+      }
+      console.log()
+      startSpinner("Отправляю уведомление")
+      await notifyAll(arg.trim())
+      stopSpinner()
+      console.log(green("  ✓ Уведомление отправлено всем пользователям\n"))
+      return
+    }
+
+    case "/tg-sessions": {
+      console.log()
+      const status = getBotStatus()
+      const sessions = status.sessions.sessions
+
+      if (sessions.length === 0) {
+        console.log(dim("  Нет Telegram сессий\n"))
+      } else {
+        console.log(box([
+          ...sessions.map((s, i) => {
+            const isActive = s.id === status.sessions.activeSession
+            const msgs = s.stats.userMessages + s.stats.assistantMessages
+            return `${isActive ? green("●") : dim("○")} ${white(s.name)} ${dim(`(${s.model}, ${msgs} msgs)`)}`
+          }),
+        ], { title: "Telegram Sessions", color: blue, padding: 2 }))
+      }
+      console.log()
+
+      // Show auth info
+      const authUsers = Object.keys(status.auth.users).length
+      console.log(dim(`  Авторизовано пользователей: ${authUsers}`))
+      console.log()
+      return
+    }
+
+    case "/tg-verify": {
+      if (!arg) {
+        // Show pending codes
+        const pending = getPendingCodes()
+        const pendingList = Object.entries(pending)
+
+        if (pendingList.length === 0) {
+          console.log(dim("\n  Нет ожидающих кодов. Пользователь должен нажать /start в Telegram.\n"))
+        } else {
+          console.log(box([
+            ...pendingList.map(([userId, p]) =>
+              violet(p.code) + dim(" — ") + white(p.username) + dim(` (ID: ${userId})`)
+            ),
+          ], { title: "Ожидающие коды", color: blue, padding: 2 }))
+          console.log()
+          console.log(dim("  Введите: /tg-verify <код>"))
+        }
+        console.log()
+        return
+      }
+
+      const code = arg.trim()
+      console.log()
+      startSpinner("Проверяю код")
+      const result = verifyAuthCode(code)
+      stopSpinner()
+
+      if (result.success) {
+        console.log(box([
+          green("✓ Telegram аккаунт привязан!"),
+          "",
+          dim("Пользователь: ") + white(result.username),
+          dim("Telegram ID: ") + white(String(result.userId)),
+          "",
+          white("Теперь вы можете управлять компьютером через Telegram!"),
+        ], { title: "Привязка", color: green, padding: 2 }))
+
+        // Send confirmation to Telegram
+        await notifyUser(result.chatId, "✅ <b>Аккаунт привязан!</b>\n\nТеперь вы можете управлять компьютером через Telegram.")
+      } else {
+        console.log(red(`  ✗ ${result.error}\n`))
+      }
+      console.log()
+      return
+    }
+
+    case "/tg-code": {
+      console.log()
+      startSpinner("Генерирую код")
+      const code = generateAdminCode()
+      stopSpinner()
+
+      console.log(box([
+        green("✓ Код сгенерирован!"),
+        "",
+        dim("Ваш код: ") + bold(violet(code)),
+        "",
+        white("Дайте этот код покупателю."),
+        white("Покупатель вводит его в Telegram боте."),
+        "",
+        dim("Код действителен до использования."),
+        dim("Для нового кода: /tg-code"),
+      ], { title: "Код для продажи", color: green, padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/tg-users": {
+      console.log()
+      const users = listAuthorizedUsers()
+
+      if (users.length === 0) {
+        console.log(dim("\n  Нет подключённых пользователей\n"))
+      } else {
+        console.log(box([
+          ...users.map(u =>
+            violet(u.firstName || u.username) + dim(` (ID: ${u.id})`) +
+            dim("\n    Подключён: ") + white(u.authenticatedAt)
+          ),
+        ], { title: "Подключённые пользователи", color: blue, padding: 2 }))
+      }
+      console.log()
+      return
+    }
+
     default:
       console.log(dim(`\n  Неизвестная команда: ${cmd}. Смотри /help\n`))
   }