loom-agent 1.2.36 → 1.2.37

package/CHANGELOG.md

@@ -4,6 +4,59 @@ All notable changes to **Loom Code** are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased] — completion harness, specialist agents, headless browser, TUI refresh
+
+### Added
+- **Drive-to-completion harness (`src/core/session.js`).** When the model ends
+  a turn with todos still pending/in_progress (the "stops between tasks"
+  failure), the loop injects a continuation listing the unfinished items — up
+  to 5 nudges per turn, build mode only, only when the turn actually wrote
+  todos. Cancelled/completed items via todowrite stop the nudging cleanly.
+  Child subagent sessions inherit the same guard.
+- **Transient provider-error retry.** Network blips / 5xx / stream resets now
+  retry the model call twice (side-effect free) instead of killing the turn
+  mid-task.
+- **Specialist subagents (`src/core/agents.js`)**: `research` (multi-source
+  investigation, sourced report), `coder` (isolated implementation),
+  `reviewer` (severity-ranked code review), `tester` (reproduce → test →
+  green), `web` (headless-browser work). All non-delegating (`no task tool`).
+- **Main orchestrator prompt.** The `build` primary agent now carries an
+  orchestrator role prompt (todo-first, delegate-to-specialists, verify,
+  finish). Primary-agent prompts are actually wired into the system prompt now
+  (`Session._primaryBlock()`) — previously `build`/`plan`/`chat` prompts were
+  registry-only and never reached the model.
+- **`browser` tool (`src/tools/browser.js`).** Headless Chromium control via
+  Playwright: goto/click/fill/press/text/eval/links/screenshot/close. Engine:
+  bundled `playwright` if installed, else `playwright-core` + system
+  Chrome/Edge. The page singleton persists across calls. Permissions: passive
+  reads allow, interactive click/fill/press ask.
+
+### Changed
+- **TUI design overhaul.** The splash leads with the full LOOM CODE wordmark
+  in solid terracotta over a separator rule and a pill-style status
+  row; the default "Loom Dark" (and Light) palettes got deeper surface
+  stepping so panels read without borders. Every selection surface — command
+  palette, slash/file popups, select modals, permission popup — now uses a
+  tinted active row with a `▸` marker; the command palette finally renders
+  each command's description; modals gained a title divider; toasts carry a
+  kind-colored status dot (● ok / ✖ error / ◆ info) and clip long text so
+  they never cover the chat. System notices sit on a tinted surface, the
+  assistant footer is brand-colored, markdown headings get an h1/h2/h3 color
+  hierarchy, the input placeholder color-codes /commands @file !shell, and
+  hard-coded reds now follow the theme's error color. Still grid-line-free in
+  the main view — color and spacing do the work, no box frames.
+- **Sidebar version now tracks `package.json`** (it was stuck at a hardcoded
+  v1.2.0 while the package moved on); splash and sidebar share one source.
+- **`task` tool description now lists every built-in subagent with its specialty.**
+- **Stop messages show the real state, not canned text.** Continuation nudges
+  now quote the model's ACTUAL last message plus the open todo list (instead
+  of one identical line every time); the empty-reply nudge reports the real
+  tool-call count; a build turn that ends with open todos returns them
+  (`resp.openTodos`) and the TUI appends "Stopped with N todo(s) still open: …"
+  with the actual items; the interrupt line reports kept chars + the
+  in-progress todo; the plan-complete line includes the planned step count;
+  "(no response)"/"(interrupted)" placeholders describe what happened.
+
 ## [1.2.36] — fix `loom web` / `loom acp` / `loom attach`
 
 ### Fixed

package/README.md

@@ -10,6 +10,7 @@
 [![npm version](https://img.shields.io/npm/v/loom-agent?style=flat&color=blue)](https://www.npmjs.com/package/loom-agent)
 [![License: MIT](https://img.shields.io/npm/l/loom-agent?style=flat&color=green)](LICENSE)
 [![Platform: Win/Mac/Linux](https://img.shields.io/badge/platform-Win--Mac--Linux-orange)](#)
+[![Website: loomcluster.in](https://img.shields.io/badge/website-loomcluster.in-success)](https://loomcluster.in/)
 
 ![Loom Code splash — connected to NVIDIA](docs/screenshot.png)
 
@@ -29,7 +30,8 @@ An AI-powered coding agent for the terminal with multi-provider support and a fu
 - Session memory, /undo, /redo, /compact, /reset, /fork
 - One-shot print mode: `loom -p "query"`
 - Editor integration via the Agent Client Protocol (ACP): `loom acp` (JSON-RPC over stdio) so Zed, JetBrains, and Neovim plugins can drive Loom as their coding agent
-- Browser interface via `loom web` — a zero-dependency Node HTTP server (chat in the browser, password auth, CORS) plus `loom attach` to share the same server from the terminal; optional mDNS advertising as `loom.local` via [bonjour-service](https://www.npmjs.com/package/bonjour-service)
+- OpenCode-style agent harness: main orchestrator agent delegates to specialist subagents (`research`, `coder`, `reviewer`, `tester`, `web`, `explore`, `scout`) via the `task` tool, and a drive-to-completion loop keeps working while todos are still open
+- Headless browser tool (`browser`) — navigate, click, fill, read the DOM, and screenshot real pages from the `web` agent
 - Usage & billing tracking per session + lifetime
 
 ## Prerequisites
@@ -49,7 +51,7 @@ An AI-powered coding agent for the terminal with multi-provider support and a fu
 
 Install from npm (global — installs the `loom` command):
 ```bash
-npm install -g loom-code
+npm install -g loom-agent
 ```
 
 Or run from source:
@@ -102,35 +104,8 @@ loom --version
 loom --help
 loom --basic                      # skip TUI, use line-mode REPL
 loom acp                          # ACP subprocess mode for editor integrations
-loom web                          # browser interface (HTTP server, opens browser)
-loom attach http://localhost:4096 # attach the terminal to a running loom web
 ```
 
-## Web
-
-Loom runs in your browser with `loom web` — a zero-dependency HTTP server that
-serves a single-page UI and drives the same core session loop as the TUI. Same
-providers/models, tools, MCP servers, and saved sessions; chat streams live in
-the browser, and a shared terminal client can attach to the same server.
-
-```bash
-loom web                           # 127.0.0.1, random port, opens the browser
-loom web --port 4096               # fixed port
-loom web --hostname 0.0.0.0        # reachable on the LAN
-loom web --mdns                    # advertise as loom.local (implies 0.0.0.0)
-loom web --mdns-domain proj.local  # custom mDNS domain
-loom web --cors https://example.com
-LOOM_SERVER_PASSWORD=secret loom web   # password-protect (user: LOOM_SERVER_USERNAME, default "loom")
-
-# Attach the terminal (shares the server's sessions/state):
-loom attach http://localhost:4096
-```
-
-Config-file equivalent (`~/.loom/config.json`): `{ "server": { "port": 4096,
-"hostname": "0.0.0.0", "mdns": true, "cors": ["https://example.com"] } }` — CLI
-flags take precedence. Full flags, the JSON API, and `loom attach` options are
-documented in **[docs/web.md](docs/web.md)**.
-
 ## Editor integration (ACP)
 
 Loom implements the [Agent Client Protocol (ACP)](https://agentclientprotocol.com)

package/bin/loom-bun.js

@@ -74,7 +74,7 @@ process.title = "loom-code";
     const args = process.argv.slice(2);
     const coreMode = args.includes("--basic") || args.includes("-p") || args.includes("--print")
       || args.includes("--help") || args.includes("-h") || args.includes("--version") || args.includes("-v")
-      || ["acp", "web", "attach", "graph"].includes(args[0]);
+      || ["acp", "graph"].includes(args[0]);
     if (!coreMode) {
       await import("@opentui/solid/preload");
       await import("../src/tui-open.tsx");
@@ -82,19 +82,11 @@ process.title = "loom-code";
     }
     // Subcommands that must never reach the interactive CLI/TUI: cli.main()
     // has no handler for them and would fall through to launching the full
-    // screen app (`loom web` painted the splash instead of serving HTTP).
-    if (args[0] === "web") {
-      require("../src/web/web-server.js").main();
-      return;
-    }
+    // screen app instead of running the requested command.
     if (args[0] === "acp") {
       require("../src/acp/acp-server.js").main();
       return;
     }
-    if (args[0] === "attach") {
-      require("../src/web/attach.js").main();
-      return;
-    }
     const { main } = require("../src/core/cli.js");
     await main();
   } catch (err) {

package/bin/loom.js

@@ -24,16 +24,6 @@ process.on('unhandledRejection', (reason) => {
     require('../src/acp/acp-server').main();
     return;
   }
-  if (sub === 'web') {
-    // Browser interface: HTTP server on 127.0.0.1, opens the browser.
-    require('../src/web/web-server').main();
-    return;
-  }
-  if (sub === 'attach') {
-    // Terminal client for a running `loom web` server.
-    require('../src/web/attach').main();
-    return;
-  }
   try {
     await updateCheck();
     await main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loom-agent",
-  "version": "1.2.36",
+  "version": "1.2.37",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toshalkumbhar8979-design/loomcode.git"
@@ -24,7 +24,7 @@
     "dev": "node --watch src/index.js",
     "setup": "node src/setup.js",
     "test": "bun run src/tui/test-interactive.tsx && bun run test:unit && bun run lint:core",
-    "test:unit": "bun test src/core/agents.test.js src/core/hooks.test.js src/core/custom-commands.test.js src/core/background-tasks.test.js src/core/memory.test.js src/core/subagent-log.test.js src/core/session.test.js src/tools/index.test.js src/tools/security.test.js src/providers/providers.test.js src/providers/caching.test.js src/providers/caching-thinking.test.js src/providers/registry.test.js src/mcp/mcp-client.test.js src/mcp/mcp-manager.test.js src/core/session-store.test.js src/skills/skills-manager.test.js src/core/usage.test.js src/core/permissions.test.js src/core/format.test.js src/acp/acp-server.test.js src/web/web-server.test.js src/tui/keybinds.test.ts",
+    "test:unit": "bun test src/core/agents.test.js src/core/hooks.test.js src/core/custom-commands.test.js src/core/background-tasks.test.js src/core/memory.test.js src/core/subagent-log.test.js src/core/session.test.js src/tools/index.test.js src/tools/security.test.js src/providers/providers.test.js src/providers/caching.test.js src/providers/caching-thinking.test.js src/providers/registry.test.js src/mcp/mcp-client.test.js src/mcp/mcp-manager.test.js src/core/session-store.test.js src/skills/skills-manager.test.js src/core/usage.test.js src/core/permissions.test.js src/core/format.test.js src/acp/acp-server.test.js src/tui/keybinds.test.ts",
     "lint:core": "node node_modules/typescript/bin/tsc -p tsconfig.core.json",
     "smoke:acp": "node scripts/acp-smoke.js",
     "tui": "bun bin/loom-tui.js",
@@ -38,11 +38,12 @@
     "@opentui/core": "0.5.3",
     "@opentui/solid": "0.5.3",
     "@shikijs/themes": "4.4.3",
-    "bonjour-service": "^1.4.4",
+    "@supabase/supabase-js": "^2.45.0",
     "boxen": "^8.0.0",
     "chalk": "^5.3.0",
     "cli-spinners": "^3.2.0",
     "commander": "^12.1.0",
+    "convex": "^1.14.0",
     "dayjs": "^1.11.0",
     "diff": "^7.0.0",
     "dotenv": "^16.4.0",
@@ -50,6 +51,7 @@
     "inquirer": "^12.1.0",
     "openai": "^5.23.2",
     "ora": "^8.0.0",
+    "playwright-core": "^1.64.1",
     "shell-quote": "^1.8.1",
     "solid-js": "1.9.12",
     "strip-ansi": "^7.1.0",
@@ -97,10 +99,7 @@
     "LOOM.md",
     "docs/acp.md",
     "scripts/acp-smoke.js",
-    "scripts/postinstall.js",
-    "docs/web.md",
-    "src/web/index.html",
-    "src/web/graph-view.html"
+    "scripts/postinstall.js"
   ],
   "keywords": [
     "ai",

package/src/connectors/convex.js

@@ -0,0 +1,356 @@
+// Convex connector — real-time backend, database, functions, auth
+const { ConvexHttpClient } = require('convex/browser');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_DIR = process.env.LOOM_CONFIG_DIR || path.join(require('os').homedir(), '.loom');
+const CONNECTORS_FILE = path.join(CONFIG_DIR, 'connectors.json');
+
+function loadConnectors() {
+    try {
+        if (fs.existsSync(CONNECTORS_FILE)) {
+            return JSON.parse(fs.readFileSync(CONNECTORS_FILE, 'utf8'));
+        }
+    } catch {}
+    return { supabase: {}, convex: {}, deploy: {} };
+}
+
+function saveConnectors(cfg) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONNECTORS_FILE, JSON.stringify(cfg, null, 2));
+}
+
+function getConvexConfig() {
+    const cfg = loadConnectors();
+    return cfg.convex || {};
+}
+
+function setConvexConfig(config) {
+    const cfg = loadConnectors();
+    cfg.convex = { ...cfg.convex, ...config };
+    saveConnectors(cfg);
+}
+
+function createConvexClient(overrideConfig = {}) {
+    const config = { ...getConvexConfig(), ...overrideConfig };
+    if (!config.url) {
+        throw new Error('Convex not configured. Run: loom connectors convex --url <deployment-url>');
+    }
+    return new ConvexHttpClient(config.url);
+}
+
+// Query helpers
+async function query(functionName, args = {}) {
+    const client = createConvexClient();
+    return await client.query(functionName, args);
+}
+
+async function mutation(functionName, args = {}) {
+    const client = createConvexClient();
+    return await client.mutation(functionName, args);
+}
+
+async function action(functionName, args = {}) {
+    const client = createConvexClient();
+    return await client.action(functionName, args);
+}
+
+// Subscription helpers (for real-time updates)
+function subscribe(functionName, args, onUpdate) {
+    const client = createConvexClient();
+    return client.onUpdate(functionName, args, onUpdate);
+}
+
+// Auth helpers (using Convex's built-in auth)
+async function signIn(email, password) {
+    return await mutation('auth:signIn', { email, password });
+}
+
+async function signUp(email, password, name) {
+    return await mutation('auth:signUp', { email, password, name });
+}
+
+async function signOut() {
+    return await mutation('auth:signOut', {});
+}
+
+async function getCurrentUser() {
+    return await query('auth:getCurrentUser', {});
+}
+
+async function resetPassword(email) {
+    return await mutation('auth:resetPassword', { email });
+}
+
+// Database operations (using Convex's query/mutation pattern)
+async function list(table, options = {}) {
+    const { filter, orderBy, limit, pagination } = options;
+    return await query(`${table}:list`, { filter, orderBy, limit, pagination });
+}
+
+async function get(table, id) {
+    return await query(`${table}:get`, { id });
+}
+
+async function create(table, data) {
+    return await mutation(`${table}:create`, { data });
+}
+
+async function update(table, id, data) {
+    return await mutation(`${table}:update`, { id, data });
+}
+
+async function remove(table, id) {
+    return await mutation(`${table}:delete`, { id });
+}
+
+// File storage (Convex file storage)
+async function uploadFile(file, metadata = {}) {
+    // First get upload URL
+    const uploadUrl = await action('storage:getUploadUrl', { metadata });
+    // Upload to the signed URL
+    const response = await fetch(uploadUrl.uploadUrl, {
+        method: 'POST',
+        body: file,
+        headers: { 'Content-Type': file.type || 'application/octet-stream' }
+    });
+    if (!response.ok) throw new Error('Upload failed');
+    const storageId = await response.text();
+    return { storageId, ...metadata };
+}
+
+async function getFileUrl(storageId) {
+    return await query('storage:getUrl', { storageId });
+}
+
+// Realtime subscriptions
+function watchQuery(functionName, args, callback) {
+    const client = createConvexClient();
+    return client.watchQuery(functionName, args, callback);
+}
+
+// Project scaffolding for Convex
+async function scaffoldConvexProject(projectName, template = 'react') {
+    const projectPath = path.join(process.cwd(), projectName);
+    fs.mkdirSync(projectPath, { recursive: true });
+    
+    // Create convex directory structure
+    const convexDir = path.join(projectPath, 'convex');
+    fs.mkdirSync(convexDir, { recursive: true });
+    
+    const templates = {
+        'schema.ts': `import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  users: defineTable({
+    name: v.string(),
+    email: v.string(),
+    avatar: v.optional(v.string()),
+  }).index("by_email", ["email"]),
+  
+  messages: defineTable({
+    userId: v.id("users"),
+    content: v.string(),
+    channel: v.string(),
+  }).index("by_channel", ["channel"]),
+  
+  tasks: defineTable({
+    title: v.string(),
+    completed: v.boolean(),
+    assigneeId: v.optional(v.id("users")),
+  }).index("by_assignee", ["assigneeId"]),
+});`,
+        
+        'auth.ts': `import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+
+export const signUp = mutation({
+  args: { email: v.string(), password: v.string(), name: v.string() },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db.query("users").filter(q => q.eq(q.field("email"), args.email)).unique();
+    if (existing) throw new Error("Email already registered");
+    const userId = await ctx.db.insert("users", { name: args.name, email: args.email });
+    return { userId };
+  }
+});
+
+export const signIn = mutation({
+  args: { email: v.string(), password: v.string() },
+  handler: async (ctx, args) => {
+    const user = await ctx.db.query("users").filter(q => q.eq(q.field("email"), args.email)).unique();
+    if (!user) throw new Error("Invalid credentials");
+    // In production, verify password hash here
+    return { userId: user._id };
+  }
+});
+
+export const getCurrentUser = query({
+  args: {},
+  handler: async (ctx) => {
+    // Implement session logic
+    return null;
+  }
+});`,
+        
+        'tasks.ts': `import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+
+export const list = query({
+  args: { userId: v.optional(v.id("users")) },
+  handler: async (ctx, args) => {
+    let q = ctx.db.query("tasks");
+    if (args.userId) q = q.filter(q => q.eq(q.field("assigneeId"), args.userId));
+    return await q.collect();
+  }
+});
+
+export const create = mutation({
+  args: { title: v.string(), assigneeId: v.optional(v.id("users")) },
+  handler: async (ctx, args) => {
+    const taskId = await ctx.db.insert("tasks", { 
+      title: args.title, 
+      completed: false, 
+      assigneeId: args.assigneeId 
+    });
+    return { taskId };
+  }
+});
+
+export const toggle = mutation({
+  args: { id: v.id("tasks") },
+  handler: async (ctx, args) => {
+    const task = await ctx.db.get(args.id);
+    if (!task) throw new Error("Task not found");
+    await ctx.db.patch(args.id, { completed: !task.completed });
+    return { success: true };
+  }
+});`,
+        
+        'chat.ts': `import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+
+export const sendMessage = mutation({
+  args: { channel: v.string(), content: v.string() },
+  handler: async (ctx, args) => {
+    const user = await ctx.db.query("users").filter(q => q.eq(q.field("email"), "demo@loom")).unique();
+    const messageId = await ctx.db.insert("messages", {
+      userId: user?._id,
+      content: args.content,
+      channel: args.channel
+    });
+    return { messageId };
+  }
+});
+
+export const getMessages = query({
+  args: { channel: v.string(), limit: v.optional(v.number()) },
+  handler: async (ctx, args) => {
+    let q = ctx.db.query("messages").filter(q => q.eq(q.field("channel"), args.channel));
+    if (args.limit) q = q.take(args.limit);
+    return await q.collect();
+  }
+});`
+    };
+    
+    // Write template files
+    for (const [file, content] of Object.entries(templates)) {
+        fs.writeFileSync(path.join(convexDir, file), content);
+    }
+    
+    // Create package.json with convex
+    const packageJson = {
+        name: projectName,
+        version: '0.0.1',
+        private: true,
+        scripts: {
+            dev: 'convex dev & vite',
+            build: 'convex deploy && vite build',
+            convex: 'convex'
+        },
+        dependencies: {
+            convex: '^1.14.0',
+            react: '^18.3.0',
+            'react-dom': '^18.3.0'
+        },
+        devDependencies: {
+            vite: '^5.0.0',
+            '@vitejs/plugin-react': '^4.0.0',
+            typescript: '^5.0.0'
+        }
+    };
+    fs.writeFileSync(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+    
+    // Vite config
+    fs.writeFileSync(path.join(projectPath, 'vite.config.ts'), 
+        `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\nexport default defineConfig({ plugins: [react()], server: { port: 3000, host: true } })`);
+    
+    // Basic React app
+    fs.mkdirSync(path.join(projectPath, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(projectPath, 'src/main.tsx'),
+        `import React from 'react'\nimport ReactDOM from 'react-dom/client'\nimport App from './App'\nimport './index.css'\nReactDOM.createRoot(document.getElementById('root')).render(<React.StrictMode><App /></React.StrictMode>)`);
+    
+    fs.writeFileSync(path.join(projectPath, 'src/App.tsx'),
+        `import { useQuery } from 'convex/react'\nimport { api } from '../convex/_generated/api'\n\nfunction App() {\n  const tasks = useQuery(api.tasks.list)\n  return (\n    <div style={{padding: '2rem', fontFamily: 'system-ui'}}\n      <h1>${projectName}</h1>\n      <ul>\n        {tasks?.map(t => <li key={t._id}><input type="checkbox" checked={t.completed} /> {t.title}</li>)}\n      </ul>\n    </div>\n  )\n}\nexport default App`);
+    
+    fs.writeFileSync(path.join(projectPath, 'src/index.css'), 
+        `* { box-sizing: border-box; } body { margin: 0; font-family: system-ui; background: #fafafa; }`);
+    
+    fs.writeFileSync(path.join(projectPath, 'index.html'),
+        `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${projectName}</title></head><body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body></html>`);
+    
+    // tsconfig
+    fs.writeFileSync(path.join(projectPath, 'tsconfig.json'),
+        JSON.stringify({
+            compilerOptions: {
+                target: 'ES2020',
+                useDefineForClassFields: true,
+                lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+                module: 'ESNext',
+                skipLibCheck: true,
+                moduleResolution: 'bundler',
+                allowImportingTsExtensions: true,
+                resolveJsonModule: true,
+                isolatedModules: true,
+                noEmit: true,
+                jsx: 'react-jsx',
+                strict: true,
+                noUnusedLocals: true,
+                noUnusedParameters: true,
+                noFallthroughCasesInSwitch: true
+            },
+            include: ['src'],
+            references: [{ path: './tsconfig.node.json' }]
+        }, null, 2));
+    
+    fs.writeFileSync(path.join(projectPath, 'tsconfig.node.json'),
+        JSON.stringify({
+            compilerOptions: {
+                composite: true,
+                skipLibCheck: true,
+                module: 'ESNext',
+                moduleResolution: 'bundler',
+                allowSyntheticDefaultImports: true
+            },
+            include: ['vite.config.ts']
+        }, null, 2));
+    
+    // Initialize git
+    try { require('child_process').execSync('git init', { cwd: projectPath, stdio: 'ignore' }); } catch {}
+    
+    return projectPath;
+}
+
+module.exports = {
+    createConvexClient,
+    getConvexConfig,
+    setConvexConfig,
+    query, mutation, action, subscribe,
+    signIn, signUp, signOut, getCurrentUser, resetPassword,
+    list, get, create, update, remove,
+    uploadFile, getFileUrl,
+    watchQuery,
+    scaffoldConvexProject,
+    loadConnectors, saveConnectors
+};