indirecttek-vibe-engine 1.6.29

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 IndirectTek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# IndirectTek Vibe Engine 🤖⚡ (v1.6.29)
+
+> **🚀 PRODUCTION STABLE RELEASE**
+> **"Autonomous Local AI Agent. Maximum Badassery."**
+
+**IndirectTek Vibe Engine** is a local-first autonomous VS Code extension designed for developers who want code, not conversation. Powered by your local **Ollama** instance, it turns your IDE into a self-healing, self-scaffolding autonomous agent.
+
+No API keys. No data leaks. Pure local compute.
+
+---
+
+## 🚨 CRITICAL CONFIGURATION
+
+**Quick Start (Best Way)**
+You don't need to clone this repo to run the Agent Controller. Just use `npx`:
+
+```bash
+# 1. Start the Agent Controller (Requires Node.js 18+)
+npx indirecttek-vibe-engine
+
+# 2. It will print a Token. Copy it.
+
+# 3. Configure VS Code Extension:
+#    - Setting: IndirectTek AI -> Controller Token
+#    - Paste the token.
+```
+
+## 🛠️ Development Setup
+
+If you want to contribute to the engine:
+
+1.  Clone this repo.
+2.  Run `npm install`.
+3.  Run `npm run compile`.
+4.  Run `./start-agent.sh` (Auto-configures your local VS Code).
+
+---
+
+## 🚨 CONFIGURATION Details
+
+**User Settings vs. Workspace Settings**
+
+VS Code has two places to store settings:
+1.  **User Settings** (Global, applies to all windows).
+2.  **Workspace Settings** (Local, applies ONLY to the current folder).
+
+**⚠️ IF YOU ARE DEVELOPING LOCALLY OR OPENING THIS REPO:**
+Check your **Workspace Settings** tab!
+Local `.vscode/settings.json` files **OVERRIDE** your global User Settings.
+Ensure `Partner Bot: Use Controller` is checked ✅ in the **Workspace** tab if you are seeing "Direct Mode" behavior or XML tags.
+
+---
+
+## ✨ Features (v1.6.28)
+
+*   **🔒 100% Local**: Works with **Ollama** (Qwen 2.5, Llama 3). Your IP, your rules.
+*   **🧠 Hybrid Architecture**: 
+    *   **Extension**: Handles UI, file I/O, and command execution.
+    *   **Agent Controller**: A standalone Node.js brain process. It manages context, parses actions (JSON), and talks to Ollama.
+*   **⚡ Structured Editing**: Uses `create_file` and `edit_file` JSON actions for surgical precision.
+*   **🛑 Loop Protection (New)**: 
+    *   **Terminal Actions**: High-cost actions (like `generate_image`) force the agent to STOP and wait for user approval. No more runaway loops.
+    *   **Hard Kill Switch**: The "Stop" button is now a physical kill switch that severs the connection immediately.
+*   **🌉 Protocol Agnostic**: The Controller can now translate both JSON and legacy XML responses.
+*   **🛑 Auto-Fresh Terminals**: Blocking commands (like starting servers) now strictly use a managed `Vibe Engine (Auto)` terminal. The agent kills and recreates this terminal for every new blocking task, ensuring no "shell hijacking" or stuck processes.
+
+---
+
+## 🛠️ Setup & Configuration
+
+### 1. Install Ollama
+[Download Ollama](https://ollama.com) and pull a coding model:
+```bash
+ollama pull qwen2.5-coder:32b
+```
+
+### 2. Install the Extension
+Install `indirecttek-vibe-engine` from the VS Code Marketplace.
+
+### 3. Start the Agent Controller (Securely)
+The brain lives outside the editor for security and stability.
+
+```bash
+# 1. Pick a secret token (e.g. "my-secret-key")
+export VIBE_TOKEN=my-secret-key
+
+# 2. Run the controller (from source or installed package)
+npm run agent-controller
+```
+*Output: `[VibeAgentController] Listening on http://127.0.0.1:43110 (Secured)`*
+
+### 4. Configure VS Code
+In Settings -> `IndirectTek AI`:
+*   **Ollama Url**: `http://localhost:11434`
+*   **Model**: `qwen2.5-coder:32b`
+*   **Use Controller**: ✅ **Check this box** (CRITICAL)
+*   **Controller Token**: Enter your secret (e.g. `my-secret-key`)
+*   **Controller Port**: `43110` (Default)
+
+### 5. (Optional) Local Image Gen
+Set `Partner Bot: Fooocus Url` to your local Fooocus instance/Docker container to enable `generate_image` capability.
+
+### 6. 🎨 Vibe Studio (Web Client)
+This project includes a dedicated web interface for image generation called **Vibe Studio**. It connects to your local GPU (Fooocus API) and provides a user-friendly way to create images.
+
+**Features:**
+- 🖥️ **Wife-Friendly UI:** Clean, dark-mode interface.
+- ⏬ **Instant Downloads:** Save creates as PNGs directly to your computer.
+- 📏 **Custom Sizes:** Choose from presets or enter custom dimensions.
+- 🖼️ **Image Manipulation:** Supports Style Transfer and Face Swap.
+
+**How to Run:**
+Simply run the included script:
+```bash
+./start-studio.sh
+```
+Or manually:
+```bash
+cd vibe-studio
+npm install # First time only
+npm run dev
+```
+Open `http://localhost:5173` in your browser.
+
+---
+
+## 🛡️ Stability & Safety
+*   **Localhost Only**: The controller only listens on `127.0.0.1`.
+*   **Deep Abort**: Clicking "Stop" propagates a signal through the entire web stack, cancelling generic requests and image downloads instantly.
+*   **Single-Shot Actions**: Image generation is strictly limited to 1 per turn to prevent resource exhaustion.
+
+---
+
+## 📜 License
+
+**MIT License**. Built with ❤️ and ☕ by **[IndirectTek](https://indirecttek.com)**.
+
+Visit usage docs at [indirecttek.com](https://indirecttek.com).
+
+*Verified to run on Apple Silicon & Linux.*

package/bin/vibe-agent.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+console.log("🚀 Starting IndirectTek Vibe Agent (Standalone Mode)...");
+
+// Ensure we are running from the package root relative to this script
+// When installed via npm, this script is in node_modules/package/bin
+// The compiled output is in node_modules/package/out
+
+const compiledPath = path.join(__dirname, '../out/agent-controller.js');
+
+if (!fs.existsSync(compiledPath)) {
+    console.error(`❌ Error: Could not find compiled agent controller at: ${compiledPath}`);
+    console.error("If you are running from source, please run 'npm run compile' first.");
+    process.exit(1);
+}
+
+// Generate Token if missing
+if (!process.env.VIBE_TOKEN) {
+    const crypto = require('crypto');
+    const token = 'vibe-' + crypto.randomBytes(2).toString('hex');
+    process.env.VIBE_TOKEN = token;
+
+    console.log("================================================================");
+    console.log(`🔑  GENERATED TOKEN: ${token}`);
+    console.log("👉  Copy this token to VS Code Settings -> IndirectTek AI");
+    console.log("================================================================");
+} else {
+    console.log(`🔑  Using Token: ${process.env.VIBE_TOKEN}`);
+}
+
+// Pass control to the main controller
+require(compiledPath);

package/out/agent-controller.js

@@ -0,0 +1,449 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseActionsFromReply = parseActionsFromReply;
+const http = require("http");
+const node_fetch_1 = require("node-fetch");
+const DEFAULT_PORT = Number(process.env.VIBE_AGENT_PORT ?? 43110);
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
+        req.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf8');
+            try {
+                const parsed = raw ? JSON.parse(raw) : {};
+                resolve(parsed);
+            }
+            catch (e) {
+                reject(new Error('Invalid JSON body'));
+            }
+        });
+        req.on('error', (err) => reject(err));
+    });
+}
+const fs = require('fs');
+const path = require('path');
+function detectContextFromSummary(summary) {
+    // If no summary provided, fall back to "Generic" safest defaults
+    if (!summary)
+        return `*** TECHNOLOGY STACK (GENERIC) ***\n- **Runtime**: Node.js (assumed)\n- **Constraints**: Use 'npx' for all tools.`;
+    let techStack = ['- **Package Manager**: npm']; // Default
+    let constraints = ['- **NO Global Installs**: Do not assume tools are in PATH. Use `npx`.'];
+    let detected = [];
+    // 1. Cloudflare Detection (Look for wrangler.toml in the text summary)
+    if (summary.includes('wrangler.toml') || summary.includes('wrangler.json')) {
+        detected.push('Cloudflare');
+        techStack.push('- **Platform**: Cloudflare Workers / Pages');
+        techStack.push('- **Database**: Cloudflare D1 (SQLite). Usage: `npx wrangler d1 execute <db> --command "..."`');
+        techStack.push('- **Storage**: Cloudflare R2.');
+        techStack.push('  - CREATE Bucket: `npx wrangler r2 bucket create <name>`');
+        techStack.push('  - LIST Buckets: `npx wrangler r2 bucket list`');
+        techStack.push('- **Tools**: `npx wrangler`');
+        constraints.push('- **NO AWS**: Do not suggest S3, Lambda, DynamoDB, or EC2. Use Cloudflare equivalents (D1, R2).');
+    }
+    // 2. AWS Detection (CDK / SST)
+    else if (summary.includes('cdk.json') || summary.includes('sst.config.ts')) {
+        detected.push('AWS');
+        techStack.push('- **Platform**: AWS');
+        techStack.push('- **IaC**: AWS CDK / SST');
+        constraints.push('- **NO Cloudflare**: Do not use `wrangler`.');
+    }
+    // 3. Framework Detection
+    if (summary.includes('astro.config.mjs') || summary.includes('astro.config.ts')) {
+        detected.push('Astro');
+        techStack.push('- **Framework**: Astro');
+    }
+    else if (summary.includes('next.config.js') || summary.includes('next.config.mjs')) {
+        detected.push('Next.js');
+        techStack.push('- **Framework**: Next.js');
+    }
+    // 4. Fallback if empty (Generic Node)
+    if (detected.length === 0 && summary.includes('package.json')) {
+        detected.push('Node.js');
+        techStack.push('- **Runtime**: Node.js');
+    }
+    console.log(`[Context Detection] Detected: ${detected.join(', ') || 'Unknown'} (from Workspace Summary)`);
+    // Return the formatted block
+    return `*** STRICT TECHNOLOGY STACK (DETECTED) ***
+${techStack.join('\n')}
+
+*** NEGATIVE CONSTRAINTS ***
+${constraints.join('\n')}`;
+}
+async function callOllama(request, signal) {
+    const { ollama, mode, userMessage, history, workspaceSummary, visibleContext } = request;
+    // Use request-provided summary for detection
+    const dynamicContext = detectContextFromSummary(workspaceSummary);
+    const systemPrompt = mode === 'plan'
+        ? `You are a senior software architect.\nCreate a clear, phased implementation plan.\nDo NOT execute commands or modify files.\nRespond in Markdown.`
+        : mode === 'chat'
+            ? `You are a helpful senior engineer.\nExplain concepts and answer questions.\nYou may reference code context but DO NOT propose tool calls.\nRespond in Markdown.`
+            : `You are an AUTONOMOUS CODING AGENT.
+Your goal is to SOLVE the user's problem by directly editing the open project.
+
+${dynamicContext}
+
+*** TRANSPARENCY PROTOCOL ***
+You MUST start your "Thought" section by explicitly reporting the status of the PREVIOUS action.
+- Did the last command succeed?
+- Did it fail? Why?
+- What are you doing next based that result?
+
+*** TOOLS AVAILABLE ***
+- read_file(path): Read file content.
+- create_file(path, content): Create/Overwrite file.
+- search_replace(path, target, replacement): Targeted edit.
+- run_command(cmd): Run shell command.
+- list_files(dir): List directory.
+
+*** TOOL USAGE TIPS ***
+- **search_replace**:
+  - The \`target\` must MATCH EXACTLY (including whitespace).
+  - If it fails, try a smaller \`target\` or read the file again.
+  - **FALLBACK**: If \`search_replace\` keeps failing for a small file (< 200 lines), just use \`create_file\` to overwrite the whole thing with the corrected content.
+- **run_command**:
+  - Use \`npx\` for local tools.
+  - If a command is stuck, use \`Ctrl+C\` (not available here, so just stop).
+
+*** RESPONSE FORMAT ***
+Return a JSON object with this structure:
+{
+  "thought": "Report status of previous action. Then analyze current state and plan next step.",
+  "action": {
+    "tool": "tool_name",
+    "args": { ... }
+  }
+**AVAILABLE TOOLS:**
+1. create_file(path, content): Create new files.
+2. edit_file(path, search, replace): Edit existing files.
+3. run_command(command): Run shell commands.
+4. generate_image(prompt, output_path): Generate generic images using the host's AI.
+
+**RULES:**
+- NO XML tags (<CREATE_FILE>, etc.). ONLY use the JSON block.
+- The JSON block must be valid and parsable.
+- **IMAGE GENERATION**:
+  - You possess a NATIVE tool called 'generate_image'.
+  - If the user needs an image, **DO NOT** try to install Python, Stable Diffusion, or DALL-E scripts.
+  - **DO NOT** execute 'pip install'.
+  - ALWAYS simply output the 'generate_image' JSON action.
+  - Example: { "type": "generate_image", "prompt": "...", "output_path": "..." }.
+- **CLI TOOLS**:
+  - For tools like 'wrangler', 'eslint', 'tsc', 'vite', etc., **ALWAYS** use 'npx <command>'.
+  - Example: 'npx wrangler login', 'npx eslint .'`;
+    const messages = [];
+    messages.push({ role: 'system', content: systemPrompt });
+    if (workspaceSummary || visibleContext) {
+        const ctxPieces = [];
+        if (workspaceSummary)
+            ctxPieces.push(`[Workspace Summary]\n${workspaceSummary}`);
+        if (visibleContext)
+            ctxPieces.push(`[Visible Context]\n${visibleContext}`);
+        messages.push({
+            role: 'system',
+            content: ctxPieces.join('\n\n')
+        });
+    }
+    if (history && history.length > 0) {
+        messages.push(...history);
+    }
+    messages.push({ role: 'user', content: userMessage });
+    const endpoint = ollama.url.endsWith('/api/chat')
+        ? ollama.url
+        : `${ollama.url.replace(/\/$/, '')}/api/chat`;
+    const response = await (0, node_fetch_1.default)(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model: ollama.model,
+            messages,
+            stream: false
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    // Ollama can return NDJSON; aggregate message.content fields.
+    const lines = text.split('\n').filter((l) => l.trim() !== '');
+    let combined = '';
+    for (const line of lines) {
+        try {
+            const json = JSON.parse(line);
+            if (json.message && json.message.content) {
+                combined += json.message.content;
+            }
+        }
+        catch {
+            // ignore non-JSON lines
+        }
+    }
+    return combined || text;
+}
+async function callOllamaWithMessages(body, signal) {
+    const { ollama, messages } = body;
+    if (!ollama || !ollama.url || !ollama.model || !Array.isArray(messages)) {
+        throw new Error('Missing ollama configuration or messages array');
+    }
+    const endpoint = ollama.url.endsWith('/api/chat')
+        ? ollama.url
+        : `${ollama.url.replace(/\/$/, '')}/api/chat`;
+    const response = await (0, node_fetch_1.default)(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        signal: signal,
+        body: JSON.stringify({
+            model: ollama.model,
+            messages,
+            stream: false
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    const lines = text.split('\n').filter((l) => l.trim() !== '');
+    let combined = '';
+    for (const line of lines) {
+        try {
+            const json = JSON.parse(line);
+            if (json.message && json.message.content) {
+                combined += json.message.content;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return combined || text;
+}
+function parseActionsFromReply(rawInput, body) {
+    let raw = rawInput;
+    let actions;
+    if (body.mode === 'agent') {
+        // Look for an ```actions ... ``` block and parse it as JSON.
+        // Look for an ```actions ... ```, ```json ... ```, or ``` ... ``` block and parse it as JSON.
+        // We use a broader regex to catch models that ignore the specific 'actions' language tag.
+        const actionsRegex = /```(?:actions|json|jsonc)?\s*(\[[\s\S]*?\]|\{[\s\S]*?\})\s*```/i;
+        const match = actionsRegex.exec(raw);
+        if (match && match[1]) {
+            try {
+                const parsed = JSON.parse(match[1]);
+                let arr = [];
+                if (Array.isArray(parsed)) {
+                    arr = parsed;
+                }
+                else if (parsed && typeof parsed === 'object' && Array.isArray(parsed.actions)) {
+                    // Wrapped form: { "actions": [ ... ] }
+                    arr = parsed.actions;
+                }
+                const limits = body.limits || {};
+                const maxActions = typeof limits.maxActions === 'number' ? limits.maxActions : 3;
+                const filtered = [];
+                for (const rawItem of arr) {
+                    if (!rawItem || typeof rawItem !== 'object')
+                        continue;
+                    // Normalise fields: allow "file" as alias for "path".
+                    const path = typeof rawItem.path === 'string'
+                        ? rawItem.path
+                        : typeof rawItem.file === 'string'
+                            ? rawItem.file
+                            : undefined;
+                    const search = typeof rawItem.search === 'string' ? rawItem.search : undefined;
+                    const replace = typeof rawItem.replace === 'string' ? rawItem.replace : undefined;
+                    const content = typeof rawItem.content === 'string' ? rawItem.content : undefined;
+                    const command = typeof rawItem.command === 'string' ? rawItem.command : undefined;
+                    const prompt = typeof rawItem.prompt === 'string' ? rawItem.prompt : undefined;
+                    const output_path = typeof rawItem.output_path === 'string' ? rawItem.output_path : undefined;
+                    const type = typeof rawItem.type === 'string'
+                        ? rawItem.type
+                        : content && path
+                            ? 'create_file'
+                            : path && search && replace
+                                ? 'edit_file'
+                                : undefined;
+                    if (type === 'create_file' && path && content) {
+                        filtered.push({
+                            type: 'create_file',
+                            path,
+                            content
+                        });
+                    }
+                    else if (type === 'edit_file' && path && search && replace) {
+                        filtered.push({
+                            type: 'edit_file',
+                            path,
+                            search,
+                            replace
+                        });
+                    }
+                    else if (type === 'run_command' && command) {
+                        const maxRuns = typeof limits.maxRunCommands === 'number' ? limits.maxRunCommands : 1;
+                        if (filtered.filter(a => a.type === 'run_command').length < maxRuns) {
+                            filtered.push({
+                                type: 'run_command',
+                                command
+                            });
+                        }
+                    }
+                    else if (type === 'read_file' && path) {
+                        filtered.push({
+                            type: 'read_file',
+                            path
+                        });
+                    }
+                    else if (type === 'generate_image' && prompt) {
+                        filtered.push({
+                            type: 'generate_image',
+                            prompt,
+                            output_path
+                        });
+                    }
+                    if (filtered.length >= maxActions)
+                        break;
+                }
+                actions = filtered;
+            }
+            catch (e) {
+                // Invalid JSON block
+            }
+            if (actions && actions.length > 0) {
+                raw = raw.replace(match[0], '').trim();
+            }
+        }
+        // FAILSAFE: XML Fallback
+        if (!actions || actions.length === 0) {
+            const xmlActions = [];
+            const imgRegex = /<GENERATE_IMAGE>[\s\S]*?<PROMPT>([\s\S]*?)<\/PROMPT>[\s\S]*?<OUTPUT>([\s\S]*?)<\/OUTPUT>[\s\S]*?<\/GENERATE_IMAGE>/gi;
+            let xmlMatch;
+            while ((xmlMatch = imgRegex.exec(raw)) !== null) {
+                const prompt = xmlMatch[1].trim();
+                const output_path = xmlMatch[2].trim();
+                xmlActions.push({
+                    type: 'generate_image',
+                    prompt,
+                    output_path
+                });
+                // Strip from markdown
+                raw = raw.replace(xmlMatch[0], '').trim();
+            }
+            if (xmlActions.length > 0)
+                actions = xmlActions;
+        }
+    }
+    return { replyMarkdown: raw, actions: actions || [] };
+}
+const AUTH_TOKEN = process.env.VIBE_TOKEN || process.argv.find(arg => arg.startsWith('--token='))?.split('=')[1];
+// --- Global Abort Controller ---
+let activeAbortController = null;
+function createServer() {
+    const server = http.createServer(async (req, res) => {
+        // Token Auth
+        if (AUTH_TOKEN) {
+            const headerToken = req.headers['x-vibe-token'];
+            if (!headerToken || headerToken !== AUTH_TOKEN) {
+                // eslint-disable-next-line no-console
+                console.log(`[VibeAgentController] Blocked unauthorized request. Source: ${req.socket.remoteAddress}`);
+                res.writeHead(403, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Unauthorized: Invalid x-vibe-token' }));
+                return;
+            }
+        }
+        try {
+            // --- ABORT ENDPOINT ---
+            if (req.method === 'POST' && req.url === '/abort') {
+                debugLog('Received /abort request');
+                if (activeAbortController) {
+                    activeAbortController.abort();
+                    activeAbortController = null;
+                    console.log('🛑 [Deep Abort] Cancelled active Ollama request.');
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'aborted' }));
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'no_active_request' }));
+                }
+                return;
+            }
+            // ---------------------
+            if (req.method === 'POST' && req.url === '/agent') {
+                debugLog('Received /agent request');
+                const body = await readJsonBody(req);
+                if (!body || !body.mode || !body.ollama) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Missing required fields' }));
+                    return;
+                }
+                // Reset Abort Controller for new request
+                if (activeAbortController) {
+                    activeAbortController.abort(); // Kill any zombie requests
+                }
+                activeAbortController = new AbortController();
+                let raw;
+                try {
+                    if (Array.isArray(body.messages)) {
+                        // Proxy mode: extension sends full message history.
+                        debugLog(`Calling Ollama (Proxy Mode) with model: ${body.ollama.model}`);
+                        raw = await callOllamaWithMessages(body, activeAbortController.signal);
+                    }
+                    else {
+                        // Structured request mode (future use).
+                        debugLog(`Calling Ollama (Structured Mode) with model: ${body.ollama.model}`);
+                        raw = await callOllama(body, activeAbortController.signal);
+                    }
+                }
+                catch (err) {
+                    if (err.name === 'AbortError') {
+                        debugLog('Ollama request aborted.');
+                        res.writeHead(499, { 'Content-Type': 'application/json' }); // Client Closed Request
+                        res.end(JSON.stringify({ error: 'Aborted by user' }));
+                        return;
+                    }
+                    throw err;
+                }
+                finally {
+                    activeAbortController = null;
+                }
+                debugLog('Ollama response received');
+                const { replyMarkdown, actions } = parseActionsFromReply(raw, body);
+                const reply = {
+                    mode: body.mode,
+                    replyMarkdown,
+                    actions,
+                    usedModel: body.ollama.model
+                };
+                // Agent mode will eventually parse actions from the model output.
+                // For the initial version we only return markdown and let the extension
+                // continue to handle tool execution as today.
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(reply));
+                return;
+            }
+            if (req.method === 'GET' && req.url === '/health') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'ok', secured: !!AUTH_TOKEN }));
+                return;
+            }
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+        catch (error) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: error.message || 'Internal error' }));
+        }
+    });
+    server.listen(DEFAULT_PORT, '127.0.0.1', () => {
+        // eslint-disable-next-line no-console
+        console.log(`[VibeAgentController] Listening on http://127.0.0.1:${DEFAULT_PORT} ${AUTH_TOKEN ? '(Secured)' : '(No Auth Token provided)'}`);
+    });
+}
+// Add simple logging helper since we are debugging
+function debugLog(msg) {
+    const ts = new Date().toISOString();
+    console.log(`[${ts}] ${msg}`);
+}
+if (require.main === module) {
+    createServer();
+}
+//# sourceMappingURL=agent-controller.js.map