ur-agent 1.14.1 → 1.16.0

package/docs/CONFIGURATION.md

@@ -4,22 +4,65 @@ UR reads configuration from CLI flags, environment variables, and project or use
 
 ## Model Provider
 
-UR runs models strictly through the local Ollama app. The request endpoint is fixed and cannot be reconfigured from UR:
+UR runs models strictly through the local Ollama app. The default request endpoint is:
 
 ```text
 http://localhost:11434/api
 ```
 
-Any model exposed by that local Ollama app can be used, including local models and Ollama Cloud-backed models. UR does not call remote provider APIs directly and does not manage model API keys.
+Any model exposed by that Ollama app can be used, including local models and Ollama Cloud-backed models. UR does not call remote provider APIs directly and does not manage model API keys.
 
-Model selection environment variables:
+### Reconfiguring the Ollama host
+
+The endpoint can be changed from UR in three ways, in order of precedence:
+
+1. `--ollama-host <url>` CLI flag (session only)
+2. `OLLAMA_HOST` environment variable
+3. `ollama.host` in user settings (`~/.ur/settings.json`)
+
+Examples:
+
+```sh
+# Session-only
+ur --ollama-host http://192.168.1.50:11434
+
+# Via environment
+OLLAMA_HOST=http://192.168.1.50:11434 ur
+
+# Persistent setting
+ur --settings '{"ollama":{"host":"http://192.168.1.50:11434"}}'
+```
+
+Model selection environment variables still work the same way:
 
 ```sh
 OLLAMA_MODEL=qwen3-coder:480b-cloud
 UR_MODEL=qwen3-coder:480b-cloud
 ```
 
-`OLLAMA_MODEL` selects the model name and takes precedence over `UR_MODEL`. If neither is set, UR lets its Ollama router choose from the model list advertised by the local Ollama app. If that discovery fails, the built-in fallback is `qwen3-coder:480b-cloud`. Neither variable can change the endpoint.
+`OLLAMA_MODEL` selects the model name and takes precedence over `UR_MODEL`. If neither is set, UR lets its Ollama router choose from the model list advertised by the configured Ollama app. If that discovery fails, the built-in fallback is `qwen3-coder:480b-cloud`.
+
+### Discovering LAN Ollama servers
+
+UR can scan your active local subnets for other Ollama servers and show a picker. This works for both wired Ethernet and wireless (Wi-Fi/WLAN) interfaces:
+
+```sh
+ur --discover-ollama
+```
+
+To make the picker appear on every startup, enable it in user settings:
+
+```json
+{
+  "ollama": {
+    "lanDiscovery": true
+  }
+}
+```
+
+The scan is limited to active local IPv4 interfaces, ignores loopback/link-local
+addresses, and uses bounded concurrency with short timeouts. It is opt-in and
+never runs automatically unless enabled.
 
 ## CLI Flags
 

package/docs/USAGE.md

@@ -64,7 +64,22 @@ ur --model qwen3-coder:480b-cloud
 ur --model qwen2.5-coder:latest
 ```
 
-UR talks only to the local Ollama app at the fixed endpoint `http://localhost:11434/api`. The endpoint cannot be changed from UR. Models exposed by that local app are valid, including Ollama Cloud-backed models. UR does not call provider APIs directly or manage model API keys.
+UR talks to the local Ollama app at `http://localhost:11434/api` by default, but you can point it at another Ollama server on your LAN or in another location:
+
+```sh
+# Discover and pick a LAN Ollama server at startup
+ur --discover-ollama
+
+# Point to a specific Ollama server for this session
+ur --ollama-host http://192.168.1.50:11434
+
+# Persistent setting
+ur --settings '{"ollama":{"host":"http://192.168.1.50:11434"}}'
+```
+
+Precedence: `--ollama-host` > `OLLAMA_HOST` env > `ollama.host` setting > `localhost:11434`.
+
+Models exposed by the chosen Ollama app are valid, including local models and Ollama Cloud-backed models. UR does not call provider APIs directly or manage model API keys.
 
 ## Project Instructions
 
@@ -84,11 +99,16 @@ UR includes slash commands and CLI subcommands for common workflows:
 - `ur agents` to list configured agents
 - `ur agent-trends` to inspect coverage for current agent technology trends
 - `ur a2a card` to print UR's Agent Card metadata for A2A discovery
+- `ur bg ...` to run detached local background agents with optional worktrees and PRs
+- `ur code-index watch` to keep the local semantic code index fresh
+- `ur memory retention ...` to prune project-local memory by TTL, max entries, and decay
 - `ur spec ...` to scaffold requirements, design, and tasks, then run a spec task list
 - `ur escalate ...` to plan, run, or ask an oracle model for hard tasks
 - `ur arena ...` to run multiple agents on the same task and select a winner
 - `ur ci-loop ...` to run tests, repair failures, and rerun with a bounded loop
 - `ur artifacts ...` to capture reviewable diffs, test runs, notes, and feedback
+- `ur ide diff ...` to capture editor-readable inline diff bundles
+- `ur eval bench ...` to import local SWE-bench, Terminal-Bench, or Aider Polyglot exports
 - `ur doctor` to inspect CLI health
 - `ur update` or `ur upgrade` to check for updates
 
@@ -106,6 +126,9 @@ ur arena "implement a debounce helper" --agents 2 --dry-run
 ur escalate run "refactor the cache layer" --force-oracle --dry-run
 ur ci-loop --command "bun test" --dry-run
 ur artifacts capture-diff
+ur bg run "fix the flaky parser test" --worktree --dry-run
+ur ide diff capture --title "Working tree review"
+ur eval bench list
 ```
 
 ## Permissions

package/docs/VALIDATION.md

@@ -8,7 +8,8 @@ You need:
 
 - A running Ollama server (`ollama serve`) with at least one model available
   in the local Ollama app. Local models and Ollama Cloud-backed models both
-  work because UR talks to the local app.
+  work because UR talks to the configured Ollama host.
+- A second Ollama server on the LAN if you want to test network discovery.
 - UR installed globally (`npm install -g ur-agent`) or this repo installed
   globally (`bun add -g github:Maitham16/UR-mapek`) or a
   local checkout (`bun run dev`).
@@ -17,7 +18,25 @@ You need:
 
 ```sh
 ur --version
-# expected: 1.14.1 (Ur)
+# expected: 1.16.0 (Ur)
+```
+
+## 0.1 Network Ollama discovery (1.16.0)
+
+With at least one other Ollama server reachable on your LAN:
+
+```sh
+ur --discover-ollama
+```
+
+Expected: a picker appears listing `This computer` plus the LAN host(s). Select
+the LAN host, then run a prompt and confirm traffic goes to the selected host.
+
+Without a LAN host, you can still verify host configuration:
+
+```sh
+ur --ollama-host http://localhost:11434 -p "say hi"
+ur --settings '{"ollama":{"host":"http://localhost:11434"}}' -p "say hi"
 ```
 
 ## 1. Marketplace tree resolves

package/extensions/vscode-ur-inline-diffs/README.md

@@ -0,0 +1,23 @@
+# UR Inline Diffs for VS Code
+
+Native VS Code surface for UR inline diff bundles.
+
+## Workflow
+
+Create a bundle from the UR CLI:
+
+```sh
+ur ide diff capture --title "Parser fix"
+```
+
+Open VS Code in the same workspace. The UR activity-bar view lists bundles from
+`.ur/ide/diffs/manifest.json`.
+
+Supported actions:
+
+- refresh the bundle list
+- open a patch preview with metadata and comments
+- add a comment that writes back to the UR metadata and manifest
+
+The extension is local-only. It reads and writes files under the current
+workspace and does not call any model provider or network service.

package/extensions/vscode-ur-inline-diffs/extension.js

@@ -0,0 +1,186 @@
+const fs = require('node:fs')
+const path = require('node:path')
+const vscode = require('vscode')
+
+function workspaceRoot() {
+  return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+}
+
+function diffsRoot(root) {
+  return path.join(root, '.ur', 'ide', 'diffs')
+}
+
+function manifestPath(root) {
+  return path.join(diffsRoot(root), 'manifest.json')
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`)
+}
+
+function loadManifest(root) {
+  const manifest = readJson(manifestPath(root), { version: 1, diffs: [] })
+  return Array.isArray(manifest.diffs) ? manifest : { version: 1, diffs: [] }
+}
+
+function patchPath(root, bundle) {
+  return path.join(diffsRoot(root), bundle.patchFile)
+}
+
+function metadataPath(root, bundle) {
+  return path.join(diffsRoot(root), bundle.metadataFile)
+}
+
+function escapeHtml(text) {
+  return String(text)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+class DiffItem extends vscode.TreeItem {
+  constructor(bundle) {
+    super(`${bundle.id}: ${bundle.title}`, vscode.TreeItemCollapsibleState.None)
+    this.bundle = bundle
+    this.contextValue = 'diff'
+    this.description = `${bundle.status} · ${bundle.files?.length ?? 0} file(s)`
+    this.tooltip = `${bundle.title}\n${bundle.patchFile}`
+    this.command = {
+      command: 'urInlineDiffs.open',
+      title: 'Open Inline Diff',
+      arguments: [this],
+    }
+  }
+}
+
+class DiffProvider {
+  constructor() {
+    this._onDidChangeTreeData = new vscode.EventEmitter()
+    this.onDidChangeTreeData = this._onDidChangeTreeData.event
+  }
+
+  refresh() {
+    this._onDidChangeTreeData.fire()
+  }
+
+  getTreeItem(item) {
+    return item
+  }
+
+  getChildren() {
+    const root = workspaceRoot()
+    if (!root) return []
+    return loadManifest(root)
+      .diffs
+      .slice()
+      .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
+      .map(bundle => new DiffItem(bundle))
+  }
+}
+
+function renderDiffHtml(root, bundle) {
+  const patch = fs.existsSync(patchPath(root, bundle))
+    ? fs.readFileSync(patchPath(root, bundle), 'utf8')
+    : ''
+  const comments = bundle.comments ?? []
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body { font: 13px/1.45 var(--vscode-editor-font-family); color: var(--vscode-editor-foreground); padding: 16px; }
+    h1 { font-size: 18px; margin: 0 0 4px; }
+    .meta { color: var(--vscode-descriptionForeground); margin-bottom: 14px; }
+    pre { background: var(--vscode-editor-background); border: 1px solid var(--vscode-panel-border); padding: 12px; overflow: auto; }
+    .comments { margin-top: 18px; }
+    .comment { border-top: 1px solid var(--vscode-panel-border); padding: 8px 0; }
+    .where { color: var(--vscode-descriptionForeground); }
+  </style>
+</head>
+<body>
+  <h1>${escapeHtml(bundle.title)}</h1>
+  <div class="meta">${escapeHtml(bundle.id)} · ${escapeHtml(bundle.status)} · ${escapeHtml(bundle.files?.length ?? 0)} file(s)</div>
+  <pre>${escapeHtml(patch)}</pre>
+  <section class="comments">
+    <h2>Comments</h2>
+    ${comments.length === 0 ? '<p class="meta">No comments yet.</p>' : comments.map(comment => {
+      const where = comment.file ? `${comment.file}${comment.line ? `:${comment.line}` : ''}` : 'General'
+      return `<div class="comment"><div class="where">${escapeHtml(where)} · ${escapeHtml(comment.at ?? '')}</div><div>${escapeHtml(comment.text)}</div></div>`
+    }).join('')}
+  </section>
+</body>
+</html>`
+}
+
+async function openDiff(item) {
+  const root = workspaceRoot()
+  const bundle = item?.bundle
+  if (!root || !bundle) {
+    vscode.window.showWarningMessage('No UR inline diff selected.')
+    return
+  }
+  const panel = vscode.window.createWebviewPanel(
+    'urInlineDiff',
+    `UR ${bundle.id}`,
+    vscode.ViewColumn.Active,
+    { enableScripts: false },
+  )
+  const latest = readJson(metadataPath(root, bundle), bundle)
+  panel.webview.html = renderDiffHtml(root, latest)
+}
+
+async function commentDiff(item, provider) {
+  const root = workspaceRoot()
+  const bundle = item?.bundle
+  if (!root || !bundle) {
+    vscode.window.showWarningMessage('No UR inline diff selected.')
+    return
+  }
+  const text = await vscode.window.showInputBox({
+    title: `Comment on ${bundle.id}`,
+    prompt: 'Comment text',
+    ignoreFocusOut: true,
+  })
+  if (!text?.trim()) return
+
+  const manifest = loadManifest(root)
+  const manifestBundle = manifest.diffs.find(diff => diff.id === bundle.id)
+  if (!manifestBundle) {
+    vscode.window.showErrorMessage(`UR inline diff not found: ${bundle.id}`)
+    return
+  }
+  const at = new Date().toISOString()
+  const comment = { at, text: text.trim() }
+  manifestBundle.status = 'commented'
+  manifestBundle.updatedAt = at
+  manifestBundle.comments = [...(manifestBundle.comments ?? []), comment]
+  writeJson(manifestPath(root), manifest)
+  writeJson(metadataPath(root, manifestBundle), manifestBundle)
+  provider.refresh()
+  vscode.window.showInformationMessage(`Added UR comment to ${bundle.id}.`)
+}
+
+function activate(context) {
+  const provider = new DiffProvider()
+  context.subscriptions.push(
+    vscode.window.registerTreeDataProvider('urInlineDiffs', provider),
+    vscode.commands.registerCommand('urInlineDiffs.refresh', () => provider.refresh()),
+    vscode.commands.registerCommand('urInlineDiffs.open', item => openDiff(item)),
+    vscode.commands.registerCommand('urInlineDiffs.comment', item => commentDiff(item, provider)),
+  )
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate }

package/extensions/vscode-ur-inline-diffs/media/ur.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="UR">
+  <rect width="64" height="64" rx="12" fill="#161616"/>
+  <path d="M16 16v18c0 9 6 15 16 15s16-6 16-15V16h-8v18c0 5-3 8-8 8s-8-3-8-8V16h-8z" fill="#f5f5f5"/>
+  <path d="M36 16h12v8h-7v7h-5V16z" fill="#64d2ff"/>
+</svg>

package/extensions/vscode-ur-inline-diffs/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "ur-inline-diffs",
+  "displayName": "UR Inline Diffs",
+  "description": "Review UR inline diff bundles from .ur/ide/diffs inside VS Code.",
+  "version": "1.16.0",
+  "publisher": "ur-agent",
+  "engines": {
+    "vscode": "^1.92.0"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [
+    "onView:urInlineDiffs",
+    "onCommand:urInlineDiffs.refresh",
+    "onCommand:urInlineDiffs.open",
+    "onCommand:urInlineDiffs.comment"
+  ],
+  "main": "./extension.js",
+  "contributes": {
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "ur",
+          "title": "UR",
+          "icon": "media/ur.svg"
+        }
+      ]
+    },
+    "views": {
+      "ur": [
+        {
+          "id": "urInlineDiffs",
+          "name": "Inline Diffs"
+        }
+      ]
+    },
+    "commands": [
+      {
+        "command": "urInlineDiffs.refresh",
+        "title": "UR: Refresh Inline Diffs"
+      },
+      {
+        "command": "urInlineDiffs.open",
+        "title": "UR: Open Inline Diff"
+      },
+      {
+        "command": "urInlineDiffs.comment",
+        "title": "UR: Comment On Inline Diff"
+      }
+    ],
+    "menus": {
+      "view/title": [
+        {
+          "command": "urInlineDiffs.refresh",
+          "when": "view == urInlineDiffs",
+          "group": "navigation"
+        }
+      ],
+      "view/item/context": [
+        {
+          "command": "urInlineDiffs.open",
+          "when": "view == urInlineDiffs && viewItem == diff",
+          "group": "inline"
+        },
+        {
+          "command": "urInlineDiffs.comment",
+          "when": "view == urInlineDiffs && viewItem == diff",
+          "group": "inline"
+        }
+      ]
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ur-agent",
-  "version": "1.14.1",
+  "version": "1.16.0",
   "description": "UR terminal coding agent CLI",
   "type": "module",
   "packageManager": "bun@1.3.14",
@@ -28,6 +28,7 @@
     "dist",
     "docs",
     "documentation",
+    "extensions",
     "examples",
     "CHANGELOG.md",
     "QUALITY.md",