stella-coder 5.0.1 → 5.1.1

package/.github/workflows/deploy.yml

@@ -0,0 +1,58 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: ["main"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v5
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build with Next.js
+        run: pnpm run build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./out
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

package/next.config.mjs

@@ -1,5 +1,6 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
+  output: "export",
   typescript: {
     ignoreBuildErrors: true,
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stella-coder",
-  "version": "5.0.1",
+  "version": "5.1.1",
   "private": false,
   "description": "Stella Coder 5.0 — AI coding agent with Telegram bot, huge context, TDD, Git ecosystem, presentations, computer control, smart home, Office automation, and antivirus",
   "main": "stella-cli/index.mjs",

package/stella-cli/autonomous-agent.mjs

@@ -0,0 +1,550 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, appendFileSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { execSync } from "child_process"
+
+const STELLA_DIR = join(homedir(), ".stella")
+const AUTO_DIR = join(STELLA_DIR, "autonomous")
+const MEMORY_FILE = join(AUTO_DIR, "memory.json")
+const TASKS_FILE = join(AUTO_DIR, "tasks.json")
+const LOG_FILE = join(AUTO_DIR, "activity.log")
+const DASHBOARD_FILE = join(AUTO_DIR, "dashboard.html")
+const STATE_FILE = join(AUTO_DIR, "state.json")
+
+function ensureDir() {
+  if (!existsSync(AUTO_DIR)) mkdirSync(AUTO_DIR, { recursive: true })
+}
+
+function loadJSON(file, fallback) {
+  try { return JSON.parse(readFileSync(file, "utf-8")) } catch { return fallback }
+}
+
+function saveJSON(file, data) {
+  ensureDir()
+  writeFileSync(file, JSON.stringify(data, null, 2))
+}
+
+function logEntry(action, details) {
+  ensureDir()
+  const entry = `[${new Date().toISOString()}] ${action}: ${details}\n`
+  appendFileSync(LOG_FILE, entry)
+}
+
+function shellRun(cmd) {
+  try {
+    execSync(cmd, { timeout: 60000, stdio: "pipe", shell: true })
+    return true
+  } catch { return false }
+}
+
+export class AutonomousAgent {
+  constructor() {
+    ensureDir()
+    this.memory = loadJSON(MEMORY_FILE, { projects: [], accounts: [], videos: [], earnings: 0, lessons: [] })
+    this.tasks = loadJSON(TASKS_FILE, { queue: [], completed: [], failed: [] })
+    this.state = loadJSON(STATE_FILE, { running: false, startedAt: null, goal: "", pid: null, iterations: 0 })
+  }
+
+  save() {
+    saveJSON(MEMORY_FILE, this.memory)
+    saveJSON(TASKS_FILE, this.tasks)
+    saveJSON(STATE_FILE, this.state)
+  }
+
+  planGoal(goal) {
+    const plan = {
+      id: Date.now().toString(36),
+      goal,
+      createdAt: new Date().toISOString(),
+      steps: [],
+      status: "planning"
+    }
+
+    const g = goal.toLowerCase()
+
+    if (g.includes("видео") || g.includes("video")) {
+      plan.steps = [
+        { id: "concept", name: "Create video concept and script", status: "pending", subtasks: [
+          "Write a compelling script/storyboard for the video",
+          "Create HTML presentation with animations showing the product",
+          "Add text overlays, transitions, and effects"
+        ], results: [] },
+        { id: "build_video", name: "Build HTML video/animation", status: "pending", subtasks: [
+          "Create self-contained HTML file with CSS animations",
+          "Add GSAP or CSS keyframe animations",
+          "Create cinematic transitions between scenes",
+          "Add background music placeholder"
+        ], results: [] },
+        { id: "export", name: "Export and place on desktop", status: "pending", subtasks: [
+          "Copy the HTML video file to Desktop",
+          "Create a .bat launcher to open it in browser",
+          "Create a poster/thumbnail image"
+        ], results: [] },
+        { id: "promote", name: "Promote the content", status: "pending", subtasks: [
+          "Create social media post templates",
+          "Write promotional text for sharing"
+        ], results: [] }
+      ]
+    } else if (g.includes("приложен") || g.includes("app") || g.includes("заработ") || g.includes("$") || g.includes("монетиз") || g.includes("donate") || g.includes("заработ")) {
+      plan.steps = [
+        { id: "research", name: "Research market & competitors", status: "pending", subtasks: [
+          "Search for trending app ideas and niches",
+          "Analyze top competitors in the space",
+          "Define monetization strategy (ads, subscriptions, donations)"
+        ], results: [] },
+        { id: "architect", name: "Architecture & design", status: "pending", subtasks: [
+          "Choose tech stack (Next.js + Tailwind + Supabase)",
+          "Design database schema",
+          "Create API structure"
+        ], results: [] },
+        { id: "build", name: "Build the application", status: "pending", subtasks: [
+          "Create project with package.json, config files",
+          "Build frontend with UI components",
+          "Build backend API routes",
+          "Add Stripe/Paddle payment integration",
+          "Add donation button (Buy Me a Coffee / Ko-fi)",
+          "Add user authentication"
+        ], results: [] },
+        { id: "deploy", name: "Deploy to production", status: "pending", subtasks: [
+          "Initialize git repo, commit all files",
+          "Push to GitHub",
+          "Deploy frontend to Vercel",
+          "Deploy backend to Railway/Render",
+          "Configure custom domain if needed"
+        ], results: [] },
+        { id: "accounts", name: "Create promo accounts", status: "pending", subtasks: [
+          "Create YouTube channel for the project",
+          "Create TikTok account",
+          "Create Twitter/X account",
+          "Create Telegram channel",
+          "Create Product Hunt listing"
+        ], results: [] },
+        { id: "content", name: "Create promotional content", status: "pending", subtasks: [
+          "Write launch blog post",
+          "Create demo video script",
+          "Write Reddit posts for r/SideProject, r/webdev",
+          "Create Hacker News Show HN post",
+          "Write Product Hunt description"
+        ], results: [] },
+        { id: "dashboard", name: "Build management dashboard", status: "pending", subtasks: [
+          "Create HTML dashboard page",
+          "Add analytics tracking",
+          "Add financial metrics view",
+          "Add user management"
+        ], results: [] },
+        { id: "optimize", name: "Growth & optimization", status: "pending", subtasks: [
+          "SEO optimization",
+          "Performance audit",
+          "Add analytics (Google Analytics / Plausible)",
+          "Set up email list"
+        ], results: [] }
+      ]
+    } else if (g.includes("сайт") || g.includes("website") || g.includes("лендинг")) {
+      plan.steps = [
+        { id: "design", name: "Design the website", status: "pending", subtasks: [
+          "Create wireframe and layout",
+          "Design UI with modern dark theme",
+          "Write compelling copy"
+        ], results: [] },
+        { id: "build", name: "Build the website", status: "pending", subtasks: [
+          "Create HTML/CSS/JS files",
+          "Add responsive design",
+          "Add animations and interactions"
+        ], results: [] },
+        { id: "seo", name: "SEO & performance", status: "pending", subtasks: [
+          "Add meta tags and Open Graph",
+          "Optimize images and loading",
+          "Add structured data"
+        ], results: [] },
+        { id: "deploy", name: "Deploy the website", status: "pending", subtasks: [
+          "Push to GitHub",
+          "Enable GitHub Pages or deploy to Vercel",
+          "Configure domain"
+        ], results: [] },
+        { id: "promo", name: "Promote the website", status: "pending", subtasks: [
+          "Share on social media",
+          "Submit to directories",
+          "Run ad campaigns"
+        ], results: [] }
+      ]
+    } else {
+      plan.steps = [
+        { id: "analyze", name: "Analyze the task", status: "pending", subtasks: [
+          "Break down requirements",
+          "Identify needed resources",
+          "Create execution plan"
+        ], results: [] },
+        { id: "execute", name: "Execute the plan", status: "pending", subtasks: [
+          "Implement step by step",
+          "Test at each stage",
+          "Handle errors and retry"
+        ], results: [] },
+        { id: "deliver", name: "Deliver results", status: "pending", subtasks: [
+          "Document everything",
+          "Create summary report",
+          "Generate dashboard"
+        ], results: [] }
+      ]
+    }
+
+    this.tasks.queue.push(plan)
+    this.state.goal = goal
+    this.save()
+    logEntry("PLAN_CREATED", goal)
+    return plan
+  }
+
+  async executeSubtask(subtask, goal, apiCall) {
+    const prompt = `You are an autonomous coding agent. Complete this task: "${subtask}"
+Context: Goal is "${goal}"
+
+You MUST return a JSON object with actual executable commands and file contents.
+DO NOT just describe — ACTUALLY PLAN THE EXECUTION.
+
+Return this exact JSON structure:
+{
+  "action": "what will be done",
+  "filesToCreate": [
+    {"path": "relative/path/file.ext", "content": "FULL file content with all code"}
+  ],
+  "commandsToRun": [
+    "shell command 1",
+    "shell command 2"
+  ],
+  "result": "description of what will happen",
+  "nextSteps": ["what to do next"]
+}
+
+IMPORTANT:
+- filesToCreate must contain REAL, COMPLETE, WORKING code (not placeholders)
+- commandsToRun must be real shell commands (npm init, mkdir, etc.)
+- Return ONLY the JSON, no markdown, no explanations`
+
+    const response = await apiCall(prompt)
+    let parsed
+    try {
+      // Strip markdown code fences if present
+      let clean = response.trim()
+      if (clean.startsWith("```")) {
+        clean = clean.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "")
+      }
+      parsed = JSON.parse(clean)
+    } catch {
+      parsed = { action: "completed", result: response, filesToCreate: [], commandsToRun: [] }
+    }
+
+    const created = []
+    const executed = []
+
+    // Create actual files
+    if (parsed.filesToCreate && Array.isArray(parsed.filesToCreate)) {
+      for (const file of parsed.filesToCreate) {
+        if (file.path && file.content) {
+          try {
+            const fullPath = join(process.cwd(), file.path)
+            const dir = dirname(fullPath)
+            if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+            writeFileSync(fullPath, file.content, "utf-8")
+            created.push(file.path)
+            this.memory.projects.push({ file: file.path, created: new Date().toISOString(), goal, subtask })
+            logEntry("FILE_CREATED", file.path)
+          } catch (err) {
+            logEntry("FILE_ERROR", `${file.path}: ${err.message}`)
+          }
+        }
+      }
+    }
+
+    // Execute actual commands
+    if (parsed.commandsToRun && Array.isArray(parsed.commandsToRun)) {
+      for (const cmd of parsed.commandsToRun) {
+        try {
+          execSync(cmd, { timeout: 30000, stdio: "pipe", shell: true, cwd: process.cwd() })
+          executed.push(cmd)
+          logEntry("CMD_RUN", cmd)
+        } catch (err) {
+          logEntry("CMD_FAIL", `${cmd}: ${err.message?.slice(0, 100)}`)
+        }
+      }
+    }
+
+    logEntry("SUBTASK_DONE", `${subtask}: ${created.length} files, ${executed.length} cmds`)
+    this.save()
+    return { ...parsed, filesCreated: created, commandsRun: executed }
+  }
+
+  async runIteration(apiCall, onProgress) {
+    const plan = this.tasks.queue.find(p => p.status !== "completed" && p.status !== "failed")
+    if (!plan) return null
+
+    plan.status = "running"
+    const step = plan.steps.find(s => s.status === "pending")
+    if (!step) {
+      const hasFailed = plan.steps.some(s => s.status === "failed")
+      plan.status = hasFailed ? "failed" : "completed"
+      this.save()
+      logEntry("PLAN_DONE", `${plan.goal}: ${plan.status}`)
+      return { type: "plan_done", plan }
+    }
+
+    step.status = "running"
+    this.save()
+    if (onProgress) onProgress(`⚡ Executing: ${step.name}`)
+    logEntry("STEP_START", step.name)
+
+    const stepResults = []
+    let failed = false
+
+    for (const subtask of step.subtasks) {
+      try {
+        if (onProgress) onProgress(`  → ${subtask}`)
+        const result = await this.executeSubtask(subtask, plan.goal, apiCall)
+        stepResults.push(result)
+        
+        // Report created files
+        if (result.filesCreated && result.filesCreated.length > 0) {
+          for (const f of result.filesCreated) {
+            if (onProgress) onProgress(`  📄 Created: ${f}`)
+          }
+        }
+        if (result.commandsRun && result.commandsRun.length > 0) {
+          for (const c of result.commandsRun) {
+            if (onProgress) onProgress(`  ⚙️ Ran: ${c}`)
+          }
+        }
+      } catch (err) {
+        logEntry("SUBTASK_FAIL", `${subtask}: ${err.message}`)
+        stepResults.push({ error: err.message })
+        failed = true
+      }
+    }
+
+    step.status = failed ? "failed" : "completed"
+    step.results = stepResults
+    this.save()
+    logEntry("STEP_DONE", `${step.name}: ${step.status}`)
+    return { type: "step_done", step, plan }
+  }
+
+  async start(goal, apiCall, onProgress) {
+    this.state.running = true
+    this.state.startedAt = new Date().toISOString()
+    this.state.goal = goal
+    this.state.iterations = 0
+    this.save()
+
+    const plan = this.planGoal(goal)
+    logEntry("AGENT_START", goal)
+
+    while (this.state.running) {
+      this.state.iterations++
+      const result = await this.runIteration(apiCall, onProgress)
+
+      if (!result) {
+        this.state.running = false
+        this.save()
+        logEntry("AGENT_DONE", "All plans completed!")
+        if (onProgress) onProgress("ALL_DONE")
+        break
+      }
+
+      if (result.type === "plan_done") {
+        if (onProgress) onProgress(`Plan completed: ${result.plan.goal}`)
+      } else if (result.type === "step_done") {
+        if (onProgress) onProgress(`Step done: ${result.step.name}`)
+      }
+
+      await new Promise(r => setTimeout(r, 500))
+    }
+
+    this.state.running = false
+    this.save()
+  }
+
+  stop() {
+    this.state.running = false
+    this.save()
+    logEntry("AGENT_STOPPED", "Manually stopped")
+  }
+
+  getStatus() {
+    const plan = this.tasks.queue.find(p => p.status === "running" || p.status === "planning")
+    return {
+      running: this.state.running,
+      goal: this.state.goal,
+      iterations: this.state.iterations,
+      startedAt: this.state.startedAt,
+      currentPlan: plan ? {
+        goal: plan.goal,
+        status: plan.status,
+        steps: plan.steps.map(s => ({
+          name: s.name,
+          status: s.status,
+          total: s.subtasks.length,
+          done: (s.results || []).filter(r => !r.error).length
+        }))
+      } : null,
+      completedPlans: this.tasks.queue.filter(p => p.status === "completed").length,
+      failedPlans: this.tasks.queue.filter(p => p.status === "failed").length,
+      totalFiles: this.memory.projects.length,
+      totalEarnings: this.memory.earnings,
+      accounts: this.memory.accounts.length
+    }
+  }
+
+  generateDashboard() {
+    const completedPlans = this.tasks.queue.filter(p => p.status === "completed")
+    const failedPlans = this.tasks.queue.filter(p => p.status === "failed")
+    const activePlans = this.tasks.queue.filter(p => p.status === "running" || p.status === "planning")
+    const allFiles = [...new Set(this.memory.projects.map(p => p.file))]
+    const logs = existsSync(LOG_FILE) ? readFileSync(LOG_FILE, "utf-8").split("\n").filter(Boolean).slice(-100) : []
+
+    const html = `<!DOCTYPE html>
+<html lang="ru">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Stella Autonomous Dashboard</title>
+  <style>
+    *{margin:0;padding:0;box-sizing:border-box}
+    body{background:#0a0a0f;color:#f8fafc;font-family:'Courier New',monospace;min-height:100vh}
+    .hdr{background:linear-gradient(135deg,#0f0f1a,#1a0a2e);padding:2rem 3rem;border-bottom:2px solid #22c55e;display:flex;justify-content:space-between;align-items:center}
+    .hdr h1{font-size:2rem;color:#22c55e}
+    .hdr .status{display:flex;align-items:center;gap:8px}
+    .hdr .dot{width:12px;height:12px;border-radius:50%;background:${this.state.running ? "#22c55e" : "#ef4444"};animation:pulse 1.5s infinite}
+    @keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
+    .grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:1rem;padding:2rem 3rem}
+    .card{background:#111118;border:1px solid #22c55e33;border-radius:12px;padding:1.5rem;text-align:center;transition:border-color .3s}
+    .card:hover{border-color:#22c55e}
+    .card .num{font-size:2.5rem;color:#22c55e;font-weight:bold}
+    .card .lbl{color:#94a3b8;margin-top:.3rem;font-size:.85rem}
+    .sec{padding:1.5rem 3rem}
+    .sec h2{color:#22c55e;font-size:1.3rem;margin-bottom:1rem;display:flex;align-items:center;gap:8px}
+    .plan-card{background:#111118;border:1px solid #333;border-radius:12px;padding:1.5rem;margin-bottom:1rem}
+    .plan-card h3{color:#e2e8f0;font-size:1.1rem}
+    .plan-card .meta{color:#64748b;font-size:.8rem;margin:.5rem 0}
+    .step-row{display:flex;align-items:center;gap:10px;padding:.6rem 0;border-bottom:1px solid #1a1a2e}
+    .step-row:last-child{border:none}
+    .badge{padding:3px 10px;border-radius:6px;font-size:.7rem;font-weight:bold;text-transform:uppercase}
+    .badge.completed{background:#22c55e22;color:#22c55e}
+    .badge.failed{background:#ef444422;color:#ef4444}
+    .badge.running{background:#eab30822;color:#eab308}
+    .badge.pending{background:#64748b22;color:#64748b}
+    .badge.planning{background:#3b82f622;color:#3b82f6}
+    .files-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:.5rem}
+    .file-item{background:#16161f;padding:.5rem 1rem;border-radius:6px;font-size:.85rem;color:#22c55e;display:flex;align-items:center;gap:6px}
+    .log-box{background:#111118;border-radius:12px;padding:1rem;max-height:400px;overflow-y:auto;font-size:.78rem;color:#94a3b8;line-height:1.6}
+    .log-box div{padding:2px 0;border-bottom:1px solid #111}
+    .log-box .ts{color:#64748b}
+    .footer{text-align:center;padding:2rem;color:#475569;border-top:1px solid #1a1a2e;margin-top:2rem}
+    .empty{text-align:center;padding:3rem;color:#475569;font-size:1.1rem}
+  </style>
+</head>
+<body>
+  <div class="hdr">
+    <div>
+      <h1>🤖 Stella Autonomous Agent</h1>
+      <p style="color:#94a3b8;margin-top:.3rem">Self-driving coding machine — powered by codex alex</p>
+    </div>
+    <div class="status">
+      <div class="dot"></div>
+      <span style="color:${this.state.running ? "#22c55e" : "#ef4444"};font-weight:bold">${this.state.running ? "RUNNING" : "IDLE"}</span>
+    </div>
+  </div>
+
+  <div class="grid">
+    <div class="card"><div class="num">${completedPlans.length}</div><div class="lbl">Plans Done</div></div>
+    <div class="card"><div class="num">${activePlans.length}</div><div class="lbl">Active Plans</div></div>
+    <div class="card"><div class="num">${failedPlans.length}</div><div class="lbl">Failed</div></div>
+    <div class="card"><div class="num">${allFiles.length}</div><div class="lbl">Files Created</div></div>
+    <div class="card"><div class="num">$${this.memory.earnings.toFixed(2)}</div><div class="lbl">Earnings</div></div>
+    <div class="card"><div class="num">${this.memory.accounts.length}</div><div class="lbl">Accounts</div></div>
+    <div class="card"><div class="num">${this.state.iterations}</div><div class="lbl">Iterations</div></div>
+    <div class="card"><div class="num">${this.memory.videos.length}</div><div class="lbl">Videos</div></div>
+  </div>
+
+  ${activePlans.length > 0 ? `
+  <div class="sec">
+    <h2>⚡ Active Plans</h2>
+    ${activePlans.map(p => `
+      <div class="plan-card">
+        <h3>${p.goal}</h3>
+        <div class="meta">Started: ${new Date(p.createdAt).toLocaleString()}</div>
+        ${p.steps.map(s => `
+          <div class="step-row">
+            <span class="badge ${s.status}">${s.status}</span>
+            <span>${s.name}</span>
+            <span style="margin-left:auto;color:#64748b">${(s.results||[]).filter(r=>!r.error).length}/${s.subtasks.length}</span>
+          </div>
+        `).join("")}
+      </div>
+    `).join("")}
+  </div>` : ""}
+
+  ${completedPlans.length > 0 ? `
+  <div class="sec">
+    <h2>✅ Completed Plans</h2>
+    ${completedPlans.map(p => `
+      <div class="plan-card">
+        <h3>${p.goal}</h3>
+        <div class="meta">Completed: ${new Date(p.createdAt).toLocaleString()}</div>
+        ${p.steps.map(s => `
+          <div class="step-row">
+            <span class="badge completed">done</span>
+            <span>${s.name}</span>
+          </div>
+        `).join("")}
+      </div>
+    `).join("")}
+  </div>` : ""}
+
+  ${failedPlans.length > 0 ? `
+  <div class="sec">
+    <h2>❌ Failed Plans</h2>
+    ${failedPlans.map(p => `
+      <div class="plan-card">
+        <h3>${p.goal}</h3>
+        ${p.steps.filter(s=>s.status==="failed").map(s => `
+          <div class="step-row">
+            <span class="badge failed">failed</span>
+            <span>${s.name}</span>
+          </div>
+        `).join("")}
+      </div>
+    `).join("")}
+  </div>` : ""}
+
+  <div class="sec">
+    <h2>📁 All Created Files</h2>
+    ${allFiles.length > 0 ? `
+      <div class="files-grid">
+        ${allFiles.map(f => `<div class="file-item">📄 ${f}</div>`).join("")}
+      </div>
+    ` : '<div class="empty">No files created yet</div>'}
+  </div>
+
+  <div class="sec">
+    <h2>📝 Activity Log (last 100 entries)</h2>
+    <div class="log-box">
+      ${logs.length > 0 ? logs.map(l => {
+        const parts = l.match(/\[(.*?)\] (\w+): (.*)/)
+        if (parts) return `<div><span class="ts">${parts[1]}</span> <span style="color:#22c55e">${parts[2]}</span> ${parts[3]}</div>`
+        return `<div>${l}</div>`
+      }).join("") : '<div>No activity yet</div>'}
+    </div>
+  </div>
+
+  <div class="footer">
+    <p>Stella Coder 5.1 — Autonomous Agent Dashboard</p>
+    <p>Generated: ${new Date().toLocaleString()} · Goal: ${this.state.goal || "None"}</p>
+  </div>
+</body>
+</html>`
+
+    ensureDir()
+    writeFileSync(DASHBOARD_FILE, html)
+    return DASHBOARD_FILE
+  }
+}
+
+export default AutonomousAgent

package/stella-cli/banner.mjs

@@ -30,7 +30,7 @@ export function printBanner({ model, cwd, version }) {
   console.log(
     box(
       [
-        violet("✻") + " Добро пожаловать в " + bold(violet("Stella Coder 5.0")) + "!",
+        violet("✻") + " Добро пожаловать в " + bold(violet("Stella Coder 5.1")) + "!",
         "",
         dim("  модель:  ") + blue(model),
         dim("  папка:   ") + gray(cwd),

package/stella-cli/index.mjs

@@ -21,6 +21,7 @@ import {
 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 { AutonomousAgent } from "./autonomous-agent.mjs"
 import {
   buildRepoMap, buildProjectContext, compressContext,
   loadSpec, generateSpecTemplate,
@@ -40,7 +41,7 @@ import {
   generateAdminCode, listAuthorizedUsers,
 } from "./telegram-bot.mjs"
 
-const VERSION = "5.0.1"
+const VERSION = "5.1.1"
 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")
@@ -642,6 +643,13 @@ const COMMANDS = [
   ["/tg-code", "сгенерировать код для продажи доступа"],
   ["/tg-users", "показать кто подключён"],
 
+  // Autonomous Agent
+  ["/auto", "запустить автономный режим (цель)"],
+  ["/auto-stop", "остановить автономный агента"],
+  ["/auto-status", "статус автономного агента"],
+  ["/auto-dashboard", "создать dashboard с результатами"],
+  ["/auto-history", "история выполненных задач"],
+
   // Управление компьютером
   ["/open", "открыть приложение/файл/URL"],
   ["/app", "запустить приложение"],
@@ -766,6 +774,7 @@ async function handleCommand(line) {
         ["🧠 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"]],
+        ["🤖 Autonomous Agent", ["/auto", "/auto-stop", "/auto-status", "/auto-dashboard", "/auto-history"]],
         ["⚙️ Настройки", ["/help", "/model", "/clear", "/compact", "/cost", "/context", "/config", "/version", "/login", "/newkey", "/doctor", "/sessions", "/color", "/lang", "/shortcut"]],
       ]
       for (const [cat, cmds] of categories) {
@@ -3387,6 +3396,204 @@ async function handleCommand(line) {
       return
     }
 
+    // ═══════════════════════════════════════════════════
+    //  AUTONOMOUS AGENT
+    // ═══════════════════════════════════════════════════
+    case "/auto": {
+      if (!arg) {
+        console.log(dim("\n  Использование: /auto <цель>\n"))
+        console.log(dim("  Пример: /auto создай приложение и заработай $10\n"))
+        console.log(dim("  Агент будет работать автономно пока не выполнит цель.\n"))
+        return
+      }
+
+      const goal = arg.trim()
+      const agent = new AutonomousAgent()
+
+      console.log()
+      console.log(box([
+        violet("🤖 AUTONOMOUS AGENT"),
+        "",
+        white("Цель: ") + cyan(goal),
+        "",
+        dim("Агент создаст план и начнёт автономное выполнение."),
+        dim("Каждый шаг будет выполняться автоматически."),
+        dim("Используй /auto-stop для остановки."),
+        dim("Используй /auto-status для проверки прогресса."),
+      ], { color: violet, padding: 2 }))
+      console.log()
+
+      const confirm = await question("  " + green("Начать автономное выполнение? (y/n) › "))
+      if (confirm.trim().toLowerCase() !== "y" && confirm.trim().toLowerCase() !== "д") {
+        console.log(dim("  Отменено\n"))
+        return
+      }
+
+      console.log()
+      startSpinner("Составляю план выполнения")
+      const plan = agent.planGoal(goal)
+      stopSpinner()
+
+      console.log(box([
+        green("✓ План создан!"),
+        "",
+        ...plan.steps.map((s, i) => dim(`  ${i + 1}. `) + white(s.name)),
+        "",
+        dim(`Всего шагов: ${plan.steps.length}`),
+      ], { title: "План", color: green, padding: 2 }))
+      console.log()
+
+      const apiCall = async (prompt) => {
+        const response = await queryAI(prompt, apiKey, state.model)
+        return response
+      }
+
+      console.log(dim("  Запускаю автономный режим...\n"))
+
+      agent.state.running = true
+      agent.state.startedAt = new Date().toISOString()
+      agent.state.goal = goal
+      agent.save()
+
+      let stepCount = 0
+      const runAuto = async () => {
+        while (agent.state.running) {
+          const result = await agent.runIteration(apiCall, (msg) => {
+            if (msg === "ALL_DONE") {
+              console.log(green("\n  ✅ ВСЕ ЗАДАЧИ ВЫПОЛНЕНЫ!\n"))
+              agent.generateDashboard()
+              console.log(dim("  Dashboard: ~/.stella/autonomous/dashboard.html\n"))
+              return
+            }
+            console.log(dim("  ") + violet("→") + " " + white(msg))
+          })
+
+          if (!result) {
+            agent.state.running = false
+            agent.save()
+            console.log(green("\n  ✅ Все планы выполнены!\n"))
+            agent.generateDashboard()
+            console.log(dim("  Dashboard: ~/.stella/autonomous/dashboard.html\n"))
+            break
+          }
+
+          stepCount++
+          if (stepCount % 5 === 0) {
+            console.log(dim(`  [${stepCount} шагов выполнено]`))
+          }
+
+          await new Promise(r => setTimeout(r, 1000))
+        }
+      }
+
+      runAuto().catch(err => {
+        console.log(red(`\n  ✗ Ошибка: ${err.message}\n`))
+        agent.state.running = false
+        agent.save()
+      })
+
+      return
+    }
+
+    case "/auto-stop": {
+      console.log()
+      const agent = new AutonomousAgent()
+      if (!agent.state.running) {
+        console.log(dim("  Агент не запущен\n"))
+        return
+      }
+      agent.stop()
+      console.log(green("  ✓ Автономный агент остановлен\n"))
+      console.log(dim(`  Выполнено шагов: ${agent.state.iterations}`))
+      console.log(dim(`  Создано файлов: ${agent.memory.projects.length}`))
+      console.log()
+      return
+    }
+
+    case "/auto-status": {
+      console.log()
+      const agent = new AutonomousAgent()
+      const status = agent.getStatus()
+
+      if (!status.running && !status.currentPlan) {
+        console.log(dim("  Агент не запущен. Используй /auto <цель> для запуска.\n"))
+        return
+      }
+
+      const items = [
+        dim("Статус:     ") + (status.running ? green("● RUNNINg") : red("○ STOPPED")),
+        dim("Цель:       ") + white(status.goal || "Нет"),
+        dim("Итераций:   ") + cyan(String(status.iterations)),
+        dim("Начато:     ") + white(status.startedAt ? new Date(status.startedAt).toLocaleString() : "—"),
+        "",
+        dim("Планов выполнено: ") + green(String(status.completedPlans)),
+        dim("Планов.failed:    ") + red(String(status.failedPlans)),
+        dim("Файлов создано:   ") + cyan(String(status.totalFiles)),
+        dim("Заработано:       ") + green("$" + status.totalEarnings.toFixed(2)),
+        dim("Аккаунтов:        ") + cyan(String(status.accounts)),
+      ]
+
+      if (status.currentPlan) {
+        items.push("", violet("Текущий план: ") + white(status.currentPlan.goal))
+        items.push(dim("Прогресс:"))
+        for (const step of status.currentPlan.steps) {
+          const icon = step.status === "completed" ? green("✓") : step.status === "running" ? yellow("●") : step.status === "failed" ? red("✗") : dim("○")
+          items.push(`  ${icon} ${step.name} ${dim(`(${step.done}/${step.total})`)}`)
+        }
+      }
+
+      console.log(box(items, { title: "🤖 Autonomous Agent Status", color: violet, padding: 2 }))
+      console.log()
+      return
+    }
+
+    case "/auto-dashboard": {
+      console.log()
+      const agent = new AutonomousAgent()
+      startSpinner("Создаю dashboard")
+      const path = agent.generateDashboard()
+      stopSpinner()
+      console.log(green(`  ✓ Dashboard создан: ${path}`))
+      console.log(dim("  Откройте в браузере для просмотра результатов\n"))
+
+      const openIt = await question("  " + green("Открыть dashboard? (y/n) › "))
+      if (openIt.trim().toLowerCase() === "y" || openIt.trim().toLowerCase() === "д") {
+        try {
+          execSync(`start "" "${path}"`, { shell: "cmd.exe", stdio: "pipe" })
+        } catch (e) {
+          console.log(yellow("  ⚠ Не удалось открыть автоматически\n"))
+        }
+      }
+      console.log()
+      return
+    }
+
+    case "/auto-history": {
+      console.log()
+      const agent = new AutonomousAgent()
+      const allPlans = agent.tasks.queue
+
+      if (allPlans.length === 0) {
+        console.log(dim("  Нет истории. Используй /auto <цель> для запуска.\n"))
+        return
+      }
+
+      console.log(box([
+        ...allPlans.map(p => {
+          const icon = p.status === "completed" ? green("✓") : p.status === "failed" ? red("✗") : yellow("●")
+          return `${icon} ${white(p.goal)} ${dim(`(${p.status})`)}`
+        }),
+      ], { title: "История автономных задач", color: violet, padding: 2 }))
+      console.log()
+
+      // Show memory stats
+      console.log(dim(`  Всего проектов: ${agent.memory.projects.length}`))
+      console.log(dim(`  Аккаунтов: ${agent.memory.accounts.length}`))
+      console.log(dim(`  Уроков: ${agent.memory.lessons.length}`))
+      console.log()
+      return
+    }
+
     default:
       console.log(dim(`\n  Неизвестная команда: ${cmd}. Смотри /help\n`))
   }

package/stella-cli/tools.mjs

@@ -2,6 +2,7 @@ import { tool } from "ai"
 import { z } from "zod"
 import fs from "node:fs"
 import path from "node:path"
+import os from "node:os"
 import { execSync } from "node:child_process"
 
 const MAX_OUTPUT = 30000
@@ -949,12 +950,12 @@ export function createTools(permissions) {
             platform: process.platform,
             arch: process.arch,
             nodeVersion: process.version,
-            hostname: require("os").hostname(),
-            username: require("os").userInfo().username,
-            cpus: require("os").cpus().length,
-            totalMemory: `${(require("os").totalmem() / 1e9).toFixed(1)} GB`,
-            freeMemory: `${(require("os").freemem() / 1e9).toFixed(1)} GB`,
-            uptime: `${Math.floor(require("os").uptime() / 3600)}h ${Math.floor((require("os").uptime() % 3600) / 60)}m`,
+            hostname: os.hostname(),
+            username: os.userInfo().username,
+            cpus: os.cpus().length,
+            totalMemory: `${(os.totalmem() / 1e9).toFixed(1)} GB`,
+            freeMemory: `${(os.freemem() / 1e9).toFixed(1)} GB`,
+            uptime: `${Math.floor(os.uptime() / 3600)}h ${Math.floor((os.uptime() % 3600) / 60)}m`,
           }
           return info
         } catch (e) {