recomposable 1.0.1 → 1.1.0

package/README.md

@@ -1,19 +1,13 @@
-```
-  __      __ _  _   _   _    ___
-  \ \    / /| || | /_\ | |  | __|        .
-   \ \/\/ / | __ |/ _ \| |__| _|       ":"
-    \_/\_/  |_||_/_/ \_|____|___|   ___:____     |"\/"|
-                                  ,'        `.    \  /
-   docker compose manager         |  O        \___/  |
-                                  ~^~^~^~^~^~^~^~^~^~^~^~
-```
-
 # recomposable
 
 A lightweight Docker Compose TUI manager with vim keybindings. Monitor service status, restart or rebuild containers, and tail logs — all from your terminal.
 
+Eliminate switching between countless terminal tabs or windows to rebuild you docker compose containers.
+
 Zero dependencies. Pure Node.js.
 
+![recomposable list view](screenshots/list-view.png)
+
 ## Install
 
 ```bash
@@ -40,6 +34,23 @@ EOF
 recomposable
 ```
 
+## Features
+
+- **Multi-file support** — manage services across multiple compose files, grouped by file
+- **Live status** — polls container state, health, build and restart times
+- **CPU/Memory monitoring** — live CPU% and memory usage per container, with configurable color thresholds
+- **Port mappings** — shows published ports for each service
+- **Log pattern scanning** — counts WRN/ERR (configurable) occurrences across all services
+- **Inline log panel** — tail logs for the selected service without leaving the list view, with search (`/`)
+- **Full log view** — scrollable full-screen log viewer with live auto-scroll and search (`/`, `n`/`N`)
+- **Start / Stop / Restart / Rebuild** — full container lifecycle management per service
+- **No cache mode** — toggle to force a full clean rebuild (`--no-cache` + `--force-recreate`), off by default
+- **Vim keybindings** — navigate with `j`/`k`, `G`/`gg`, and more
+
+## Full Log View
+
+![recomposable full logs view](screenshots/logs-view.png)
+
 ## Adding Compose Files
 
 Create a `recomposable.json` file in your project root:
@@ -48,9 +59,7 @@ Create a `recomposable.json` file in your project root:
 {
   "composeFiles": [
     "docker-compose.yml"
-  ],
-  "pollInterval": 3000,
-  "logTailLines": 100
+  ]
 }
 ```
 
@@ -81,22 +90,52 @@ recomposable -f docker-compose.yml -f docker-compose.prod.yml
 |---|---|---|
 | `composeFiles` | `[]` | Array of docker-compose file paths (relative to `recomposable.json`) |
 | `pollInterval` | `3000` | Status polling interval in milliseconds |
-| `logTailLines` | `100` | Number of log lines to show when entering log view |
+| `logTailLines` | `100` | Number of log lines to show when entering full log view |
+| `logScanPatterns` | `["WRN]", "ERR]"]` | Patterns to count in container logs |
+| `logScanLines` | `1000` | Number of log lines to scan for pattern counts |
+| `logScanInterval` | `10000` | Pattern scanning interval in milliseconds |
+| `bottomLogCount` | `10` | Number of log lines shown in the inline log panel |
+| `statsInterval` | `5000` | CPU/memory polling interval in milliseconds |
+| `statsBufferSize` | `6` | Number of samples for rolling average (e.g. 6 x 5s = 30s window) |
+| `cpuWarnThreshold` | `50` | CPU % above which the column turns yellow |
+| `cpuDangerThreshold` | `100` | CPU % above which the column turns red |
+| `memWarnThreshold` | `512` | Memory in MB above which the column turns yellow |
+| `memDangerThreshold` | `1024` | Memory in MB above which the column turns red |
 
 ## Keybindings
 
+### List view
+
 | Key | Action |
 |---|---|
 | `j` / `Down` | Move cursor down |
 | `k` / `Up` | Move cursor up |
-| `s` | Restart selected service |
-| `r` | Rebuild selected service (`up -d --build`) |
-| `l` / `Enter` | View logs for selected service |
-| `Esc` / `l` | Exit log view |
+| `s` | Start (if stopped) or restart (if running) |
+| `p` | Stop selected service |
+| `b` | Rebuild selected service (`up -d --build`) |
+| `n` | Toggle no-cache mode (rebuild with `--no-cache` + `--force-recreate`) |
+| `f` / `Enter` | Full-screen log view for selected service |
+| `l` | Toggle inline log panel |
+| `/` | Search in inline log panel |
 | `G` | Jump to bottom |
 | `gg` | Jump to top |
 | `q` | Quit |
-| `Ctrl+C` | Quit |
+
+### Full log view
+
+| Key | Action |
+|---|---|
+| `j` / `Down` | Scroll down |
+| `k` / `Up` | Scroll up |
+| `Ctrl+D` | Page down |
+| `Ctrl+U` | Page up |
+| `G` | Jump to bottom (live mode) |
+| `gg` | Jump to top |
+| `/` | Search logs |
+| `n` | Next search match |
+| `N` | Previous search match |
+| `Esc` / `f` | Exit log view |
+| `q` | Quit |
 
 ## Status Icons
 
@@ -104,9 +143,13 @@ recomposable -f docker-compose.yml -f docker-compose.prod.yml
 |---|---|
 | Green circle | Running (healthy) |
 | Red circle | Running (unhealthy) |
-| Yellow circle | Rebuilding / Restarting |
+| Yellow circle | Rebuilding / Restarting / Starting / Stopping |
 | Gray circle | Stopped |
 
+## Todo
+
+- Log search should search all container logs, not only the lines currently tailed by the tool
+
 ## Requirements
 
 - Node.js >= 16

package/index.js

@@ -3,14 +3,14 @@
 
 const fs = require('fs');
 const path = require('path');
-const { listServices, getStatuses, rebuildService, restartService, tailLogs, getContainerId, tailContainerLogs, fetchContainerLogs } = require('./lib/docker');
+const { listServices, getStatuses, rebuildService, restartService, stopService, startService, tailLogs, getContainerId, tailContainerLogs, fetchContainerLogs, fetchContainerStats, parseStatsLine } = require('./lib/docker');
 const { MODE, createState, statusKey, buildFlatList, moveCursor, selectedEntry } = require('./lib/state');
 const { clearScreen, showCursor, renderListView, renderLogView } = require('./lib/renderer');
 
 // --- Config ---
 
 function loadConfig() {
-  const defaults = { composeFiles: [], pollInterval: 3000, logTailLines: 100, logScanPatterns: ['WRN]', 'ERR]'], logScanLines: 1000, logScanInterval: 10000 };
+  const defaults = { composeFiles: [], pollInterval: 3000, logTailLines: 100, logScanPatterns: ['WRN]', 'ERR]'], logScanLines: 1000, logScanInterval: 10000, statsInterval: 5000, statsBufferSize: 6, bottomLogCount: 10, cpuWarnThreshold: 50, cpuDangerThreshold: 100, memWarnThreshold: 512, memDangerThreshold: 1024 };
 
   // Load from recomposable.json in current working directory
   const configPath = path.join(process.cwd(), 'recomposable.json');
@@ -127,6 +127,80 @@ function pollLogCounts(state) {
   }
 }
 
+// --- Stats Polling ---
+
+let statsPollActive = false;
+
+function pollContainerStats(state) {
+  if (statsPollActive) return;
+
+  const idToKey = new Map();
+  for (const group of state.groups) {
+    if (group.error) continue;
+    for (const service of group.services) {
+      const sk = statusKey(group.file, service);
+      const st = state.statuses.get(sk);
+      if (!st || st.state !== 'running' || !st.id) continue;
+      idToKey.set(st.id, sk);
+    }
+  }
+
+  const ids = [...idToKey.keys()];
+  if (ids.length === 0) return;
+
+  statsPollActive = true;
+  const child = fetchContainerStats(ids);
+  let output = '';
+  child.stdout.on('data', (d) => { output += d.toString(); });
+  child.stderr.on('data', () => {});
+  child.on('close', () => {
+    statsPollActive = false;
+    const bufferSize = state.config.statsBufferSize || 6;
+
+    for (const line of output.trim().split('\n')) {
+      if (!line.trim()) continue;
+      const parsed = parseStatsLine(line);
+      if (!parsed) continue;
+
+      // Find the statusKey for this container ID
+      let sk = null;
+      for (const [id, key] of idToKey) {
+        if (parsed.id.startsWith(id) || id.startsWith(parsed.id)) {
+          sk = key;
+          break;
+        }
+      }
+      if (!sk) continue;
+
+      // Update circular buffer
+      if (!state.containerStatsHistory.has(sk)) {
+        state.containerStatsHistory.set(sk, { cpu: new Array(bufferSize).fill(0), mem: new Array(bufferSize).fill(0), idx: 0, count: 0 });
+      }
+      const hist = state.containerStatsHistory.get(sk);
+      hist.cpu[hist.idx] = parsed.cpuPercent;
+      hist.mem[hist.idx] = parsed.memUsageBytes;
+      hist.idx = (hist.idx + 1) % bufferSize;
+      hist.count = Math.min(hist.count + 1, bufferSize);
+
+      // Compute rolling average
+      let cpuSum = 0, memSum = 0;
+      for (let i = 0; i < hist.count; i++) {
+        cpuSum += hist.cpu[i];
+        memSum += hist.mem[i];
+      }
+      state.containerStats.set(sk, {
+        cpuPercent: cpuSum / hist.count,
+        memUsageBytes: memSum / hist.count,
+      });
+    }
+
+    if (state.mode === MODE.LIST) throttledRender(state);
+  });
+  child.on('error', () => {
+    statsPollActive = false;
+  });
+}
+
 // --- Rendering ---
 
 function render(state) {
@@ -173,6 +247,10 @@ function updateSelectedLogs(state) {
   // Same container already selected, nothing to do
   if (state.selectedLogKey === sk) return;
 
+  // Clear bottom search when switching services
+  state.bottomSearchQuery = '';
+  state.bottomSearchActive = false;
+
   // Cancel any pending debounced log fetch
   if (logFetchTimer) {
     clearTimeout(logFetchTimer);
@@ -221,7 +299,7 @@ function doRebuild(state) {
     state.bottomLogTails.delete(sk);
   }
 
-  const child = rebuildService(entry.file, entry.service);
+  const child = rebuildService(entry.file, entry.service, { noCache: state.noCache });
   state.rebuilding.set(sk, child);
 
   state.bottomLogLines.set(sk, { action: 'rebuilding', service: entry.service, lines: [] });
@@ -236,7 +314,8 @@ function doRebuild(state) {
     const newLines = parts.filter(l => l.trim().length > 0).map(stripAnsi).filter(Boolean);
     if (newLines.length === 0) return;
     info.lines.push(...newLines);
-    if (info.lines.length > 10) info.lines = info.lines.slice(-10);
+    const maxLines = state.config.bottomLogCount || 10;
+    if (info.lines.length > maxLines) info.lines = info.lines.slice(-maxLines);
     if (state.mode === MODE.LIST) throttledRender(state);
   };
 
@@ -246,6 +325,8 @@ function doRebuild(state) {
 
   child.on('close', () => {
     state.rebuilding.delete(sk);
+    state.containerStatsHistory.delete(sk);
+    state.containerStats.delete(sk);
     pollStatuses(state);
 
     // Show container application logs after rebuild+start
@@ -271,7 +352,8 @@ function startBottomLogTail(state, sk, file, service) {
   const containerId = getContainerId(file, service);
   if (!containerId) return;
 
-  const logChild = tailContainerLogs(containerId, 10);
+  const maxLines = state.config.bottomLogCount || 10;
+  const logChild = tailContainerLogs(containerId, maxLines);
   state.bottomLogTails.set(sk, logChild);
 
   let buf = '';
@@ -284,7 +366,7 @@ function startBottomLogTail(state, sk, file, service) {
     const newLines = parts.filter(l => l.trim().length > 0).map(stripAnsi).filter(Boolean);
     if (newLines.length === 0) return;
     info.lines.push(...newLines);
-    if (info.lines.length > 10) info.lines = info.lines.slice(-10);
+    if (info.lines.length > maxLines) info.lines = info.lines.slice(-maxLines);
     if (state.mode === MODE.LIST) throttledRender(state);
   };
 
@@ -313,6 +395,8 @@ function doRestart(state) {
 
   child.on('close', () => {
     state.restarting.delete(sk);
+    state.containerStatsHistory.delete(sk);
+    state.containerStats.delete(sk);
     pollStatuses(state);
 
     // Show container application logs after restart
@@ -327,6 +411,67 @@ function doRestart(state) {
   });
 }
 
+function doStop(state) {
+  const entry = selectedEntry(state);
+  if (!entry) return;
+
+  const sk = statusKey(entry.file, entry.service);
+  if (state.stopping.has(sk) || state.rebuilding.has(sk) || state.restarting.has(sk)) return;
+
+  // Only stop running containers
+  const st = state.statuses.get(sk);
+  if (!st || st.state !== 'running') return;
+
+  // Kill any existing log tail for this service
+  if (state.bottomLogTails.has(sk)) {
+    state.bottomLogTails.get(sk).kill('SIGTERM');
+    state.bottomLogTails.delete(sk);
+  }
+
+  const child = stopService(entry.file, entry.service);
+  state.stopping.set(sk, child);
+  state.bottomLogLines.set(sk, { action: 'stopping', service: entry.service, lines: [] });
+  render(state);
+
+  child.on('close', () => {
+    state.stopping.delete(sk);
+    state.bottomLogLines.delete(sk);
+    pollStatuses(state);
+    if (state.mode === MODE.LIST) render(state);
+  });
+}
+
+function doStart(state) {
+  const entry = selectedEntry(state);
+  if (!entry) return;
+
+  const sk = statusKey(entry.file, entry.service);
+  if (state.starting.has(sk) || state.rebuilding.has(sk) || state.restarting.has(sk) || state.stopping.has(sk)) return;
+
+  // Only start stopped/exited containers
+  const st = state.statuses.get(sk);
+  if (st && st.state === 'running') return;
+
+  const child = startService(entry.file, entry.service);
+  state.starting.set(sk, child);
+  state.bottomLogLines.set(sk, { action: 'starting', service: entry.service, lines: [] });
+  render(state);
+
+  child.on('close', () => {
+    state.starting.delete(sk);
+    pollStatuses(state);
+
+    const info = state.bottomLogLines.get(sk);
+    if (info) {
+      info.action = 'started';
+      info.lines = [];
+    }
+
+    startBottomLogTail(state, sk, entry.file, entry.service);
+    if (state.mode === MODE.LIST) render(state);
+  });
+}
+
 function enterLogs(state) {
   const entry = selectedEntry(state);
   if (!entry) return;
@@ -340,6 +485,10 @@ function enterLogs(state) {
   state.logLines = [];
   state.logScrollOffset = 0;
   state.logAutoScroll = true;
+  state.logSearchQuery = '';
+  state.logSearchActive = false;
+  state.logSearchMatches = [];
+  state.logSearchMatchIdx = -1;
 
   const child = tailLogs(entry.file, entry.service, state.config.logTailLines);
   state.logChild = child;
@@ -388,6 +537,51 @@ function exitLogs(state) {
   render(state);
 }
 
+// --- Log Search ---
+
+function executeLogSearch(state) {
+  const query = state.logSearchQuery;
+  state.logSearchMatches = [];
+  state.logSearchMatchIdx = -1;
+  if (!query) return;
+
+  const lowerQuery = query.toLowerCase();
+  for (let i = 0; i < state.logLines.length; i++) {
+    if (state.logLines[i].toLowerCase().includes(lowerQuery)) {
+      state.logSearchMatches.push(i);
+    }
+  }
+
+  if (state.logSearchMatches.length > 0) {
+    state.logSearchMatchIdx = 0;
+    scrollToLogLine(state, state.logSearchMatches[0]);
+  }
+}
+
+function scrollToLogLine(state, lineIdx) {
+  const { rows = 24 } = process.stdout;
+  const headerHeight = 9; // logo + separator + legend + info line
+  const availableRows = Math.max(1, rows - headerHeight);
+  const totalLines = state.logLines.length;
+
+  // logScrollOffset is lines from bottom
+  state.logScrollOffset = Math.max(0, totalLines - lineIdx - Math.floor(availableRows / 2));
+  state.logAutoScroll = state.logScrollOffset === 0;
+  render(state);
+}
+
+function jumpToNextMatch(state) {
+  if (state.logSearchMatches.length === 0) return;
+  state.logSearchMatchIdx = (state.logSearchMatchIdx + 1) % state.logSearchMatches.length;
+  scrollToLogLine(state, state.logSearchMatches[state.logSearchMatchIdx]);
+}
+
+function jumpToPrevMatch(state) {
+  if (state.logSearchMatches.length === 0) return;
+  state.logSearchMatchIdx = (state.logSearchMatchIdx - 1 + state.logSearchMatches.length) % state.logSearchMatches.length;
+  scrollToLogLine(state, state.logSearchMatches[state.logSearchMatchIdx]);
+}
+
 // --- Input Handling ---
 
 function handleKeypress(state, key) {
@@ -398,6 +592,29 @@ function handleKeypress(state, key) {
   }
 
   if (state.mode === MODE.LOGS) {
+    // Search input mode — capture keypresses into the search query
+    if (state.logSearchActive) {
+      if (key === '\x1b') {
+        // ESC cancels search
+        state.logSearchActive = false;
+        state.logSearchQuery = '';
+        render(state);
+      } else if (key === '\r') {
+        // Enter executes search
+        state.logSearchActive = false;
+        executeLogSearch(state);
+        render(state);
+      } else if (key === '\x7f' || key === '\b') {
+        // Backspace
+        state.logSearchQuery = state.logSearchQuery.slice(0, -1);
+        render(state);
+      } else if (key.length === 1 && key >= ' ') {
+        state.logSearchQuery += key;
+        render(state);
+      }
+      return;
+    }
+
     const { rows = 24 } = process.stdout;
     const pageSize = Math.max(1, Math.floor(rows / 2));
     const maxOffset = Math.max(0, state.logLines.length - 1);
@@ -440,6 +657,36 @@ function handleKeypress(state, key) {
         if (state.logScrollOffset === 0) state.logAutoScroll = true;
         render(state);
         break;
+      case '/':
+        state.logSearchActive = true;
+        state.logSearchQuery = '';
+        render(state);
+        break;
+      case 'n':
+        jumpToNextMatch(state);
+        break;
+      case 'N':
+        jumpToPrevMatch(state);
+        break;
+    }
+    return;
+  }
+
+  // LIST mode — bottom panel search input
+  if (state.bottomSearchActive) {
+    if (key === '\x1b') {
+      state.bottomSearchActive = false;
+      state.bottomSearchQuery = '';
+      render(state);
+    } else if (key === '\r') {
+      state.bottomSearchActive = false;
+      render(state);
+    } else if (key === '\x7f' || key === '\b') {
+      state.bottomSearchQuery = state.bottomSearchQuery.slice(0, -1);
+      render(state);
+    } else if (key.length === 1 && key >= ' ') {
+      state.bottomSearchQuery += key;
+      render(state);
     }
     return;
   }
@@ -458,11 +705,28 @@ function handleKeypress(state, key) {
       updateSelectedLogs(state);
       render(state);
       break;
-    case 'r':
+    case 'b':
       doRebuild(state);
       break;
-    case 's':
-      doRestart(state);
+    case 's': {
+      const sEntry = selectedEntry(state);
+      if (sEntry) {
+        const sSk = statusKey(sEntry.file, sEntry.service);
+        const sSt = state.statuses.get(sSk);
+        if (sSt && sSt.state === 'running') {
+          doRestart(state);
+        } else {
+          doStart(state);
+        }
+      }
+      break;
+    }
+    case 'p':
+      doStop(state);
+      break;
+    case 'n':
+      state.noCache = !state.noCache;
+      render(state);
       break;
     case 'f':
     case '\r': // Enter
@@ -483,6 +747,13 @@ function handleKeypress(state, key) {
       break;
     case 'g': // gg handled via double-tap buffer below
       break;
+    case '/':
+      if (state.showBottomLogs) {
+        state.bottomSearchActive = true;
+        state.bottomSearchQuery = '';
+        render(state);
+      }
+      break;
   }
 }
 
@@ -531,6 +802,12 @@ function createInputHandler(state) {
       const ch = buf[0];
       buf = buf.slice(1);
 
+      // In search input mode, send all chars directly
+      if (state.logSearchActive || state.bottomSearchActive) {
+        handleKeypress(state, ch);
+        continue;
+      }
+
       // Handle gg (go to top)
       if (ch === 'g') {
         if (gPending) {
@@ -577,6 +854,14 @@ function cleanup(state) {
     child.kill('SIGTERM');
   }
   state.restarting.clear();
+  for (const [, child] of state.stopping) {
+    child.kill('SIGTERM');
+  }
+  state.stopping.clear();
+  for (const [, child] of state.starting) {
+    child.kill('SIGTERM');
+  }
+  state.starting.clear();
   for (const [, child] of state.bottomLogTails) {
     child.kill('SIGTERM');
   }
@@ -591,6 +876,9 @@ function cleanup(state) {
   if (state.pollTimer) {
     clearInterval(state.pollTimer);
   }
+  if (state.statsTimer) {
+    clearInterval(state.statsTimer);
+  }
   process.stdout.write('\x1b[r' + showCursor() + '\x1b[0m');
 }
 
@@ -642,6 +930,14 @@ function main() {
     }
   }, config.logScanInterval || 10000);
 
+  // Stats polling loop
+  pollContainerStats(state);
+  state.statsTimer = setInterval(() => {
+    if (state.mode === MODE.LIST) {
+      pollContainerStats(state);
+    }
+  }, config.statsInterval || 5000);
+
   // Terminal resize
   process.stdout.on('resize', () => {
     render(state);

package/lib/docker.js

@@ -27,10 +27,14 @@ function getStatuses(file) {
   let containers;
 
   // docker compose ps outputs NDJSON (one object per line) or a JSON array
-  if (trimmed.startsWith('[')) {
-    containers = JSON.parse(trimmed);
-  } else {
-    containers = trimmed.split('\n').filter(Boolean).map(line => JSON.parse(line));
+  try {
+    if (trimmed.startsWith('[')) {
+      containers = JSON.parse(trimmed);
+    } else {
+      containers = trimmed.split('\n').filter(Boolean).map(line => JSON.parse(line));
+    }
+  } catch {
+    return new Map();
   }
 
   const idToService = new Map();
@@ -41,7 +45,31 @@ function getStatuses(file) {
     const health = (c.Health || '').toLowerCase();
     const createdAt = c.CreatedAt || null;
     const id = c.ID || null;
-    statuses.set(name, { state, health, createdAt, startedAt: null, id: id || null });
+
+    // Extract published ports
+    let ports = [];
+    if (Array.isArray(c.Publishers)) {
+      for (const p of c.Publishers) {
+        if (p.PublishedPort && p.PublishedPort > 0) {
+          ports.push({ published: p.PublishedPort, target: p.TargetPort });
+        }
+      }
+    } else if (c.Ports) {
+      // Fallback: parse from Ports string like "0.0.0.0:3000->3000/tcp"
+      const portMatches = c.Ports.matchAll(/(\d+)->(\d+)/g);
+      for (const m of portMatches) {
+        ports.push({ published: parseInt(m[1], 10), target: parseInt(m[2], 10) });
+      }
+    }
+    // Deduplicate by published port
+    const seen = new Set();
+    ports = ports.filter(p => {
+      if (seen.has(p.published)) return false;
+      seen.add(p.published);
+      return true;
+    });
+
+    statuses.set(name, { state, health, createdAt, startedAt: null, id: id || null, ports });
     if (id) idToService.set(id, name);
   }
 
@@ -72,13 +100,49 @@ function getStatuses(file) {
   return statuses;
 }
 
-function rebuildService(file, service) {
+function rebuildService(file, service, opts = {}) {
   const cwd = path.dirname(path.resolve(file));
-  const args = ['compose', '-f', path.resolve(file), 'up', '-d', '--build', service];
-  const child = spawn('docker', args, {
+  const resolvedFile = path.resolve(file);
+  const spawnOpts = {
     cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: false,
     env: { ...process.env, BUILDKIT_PROGRESS: 'plain' },
-  });
+  };
+
+  if (opts.noCache) {
+    // Chain: build --no-cache then up --force-recreate (skip all caches)
+    // Use safe spawn (no shell) to avoid command injection
+    const { EventEmitter } = require('events');
+    const { PassThrough } = require('stream');
+    const emitter = new EventEmitter();
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    emitter.stdout = stdout;
+    emitter.stderr = stderr;
+
+    const buildChild = spawn('docker', ['compose', '-f', resolvedFile, 'build', '--no-cache', service], spawnOpts);
+    buildChild.stdout.pipe(stdout, { end: false });
+    buildChild.stderr.pipe(stderr, { end: false });
+
+    buildChild.on('close', (code) => {
+      if (code !== 0) {
+        stdout.end();
+        stderr.end();
+        emitter.emit('close', code);
+        return;
+      }
+      const upChild = spawn('docker', ['compose', '-f', resolvedFile, 'up', '-d', '--force-recreate', service], spawnOpts);
+      upChild.stdout.pipe(stdout);
+      upChild.stderr.pipe(stderr);
+      upChild.on('close', (upCode) => emitter.emit('close', upCode));
+      emitter.kill = (sig) => upChild.kill(sig);
+    });
+
+    emitter.kill = (sig) => buildChild.kill(sig);
+    return emitter;
+  }
+
+  const args = ['compose', '-f', resolvedFile, 'up', '-d', '--build', service];
+  const child = spawn('docker', args, spawnOpts);
   return child;
 }
 
@@ -120,4 +184,48 @@ function restartService(file, service) {
   return child;
 }
 
-module.exports = { listServices, getStatuses, rebuildService, restartService, tailLogs, getContainerId, tailContainerLogs, fetchContainerLogs };
+function stopService(file, service) {
+  const cwd = path.dirname(path.resolve(file));
+  const args = ['compose', '-f', path.resolve(file), 'stop', service];
+  const child = spawn('docker', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: false });
+  return child;
+}
+
+function startService(file, service) {
+  const cwd = path.dirname(path.resolve(file));
+  const args = ['compose', '-f', path.resolve(file), 'start', service];
+  const child = spawn('docker', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: false });
+  return child;
+}
+
+function fetchContainerStats(containerIds) {
+  const args = ['stats', '--no-stream', '--format', '{{json .}}', ...containerIds];
+  const child = spawn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+  return child;
+}
+
+function parseMemString(str) {
+  if (!str) return 0;
+  const match = str.match(/^([\d.]+)\s*(B|KiB|MiB|GiB|TiB|kB|MB|GB|TB)$/i);
+  if (!match) return 0;
+  const val = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  const multipliers = { b: 1, kib: 1024, mib: 1024 * 1024, gib: 1024 * 1024 * 1024, tib: 1024 * 1024 * 1024 * 1024, kb: 1000, mb: 1e6, gb: 1e9, tb: 1e12 };
+  return val * (multipliers[unit] || 1);
+}
+
+function parseStatsLine(jsonStr) {
+  try {
+    const obj = JSON.parse(jsonStr);
+    const cpuPercent = parseFloat((obj.CPUPerc || '').replace('%', '')) || 0;
+    const memUsageStr = (obj.MemUsage || '').split('/')[0].trim();
+    const memUsageBytes = parseMemString(memUsageStr);
+    const id = obj.ID || '';
+    const name = obj.Name || '';
+    return { id, name, cpuPercent, memUsageBytes };
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { listServices, getStatuses, rebuildService, restartService, stopService, startService, tailLogs, getContainerId, tailContainerLogs, fetchContainerLogs, fetchContainerStats, parseStatsLine, parseMemString };

package/lib/renderer.js

@@ -76,8 +76,8 @@ function showCursor() {
   return `${ESC}?25h`;
 }
 
-function statusIcon(status, isRebuilding, isRestarting) {
-  if (isRebuilding || isRestarting) return `${FG_YELLOW}\u25CF${RESET}`;
+function statusIcon(status, isRebuilding, isRestarting, isStopping, isStarting) {
+  if (isRebuilding || isRestarting || isStopping || isStarting) return `${FG_YELLOW}\u25CF${RESET}`;
   if (!status) return `${FG_GRAY}\u25CB${RESET}`;
 
   const { state, health } = status;
@@ -89,7 +89,9 @@ function statusIcon(status, isRebuilding, isRestarting) {
   return `${FG_GRAY}\u25CB${RESET}`;
 }
 
-function statusText(status, isRebuilding, isRestarting) {
+function statusText(status, isRebuilding, isRestarting, isStopping, isStarting) {
+  if (isStopping) return `${FG_YELLOW}STOPPING...${RESET}`;
+  if (isStarting) return `${FG_YELLOW}STARTING...${RESET}`;
   if (isRestarting) return `${FG_YELLOW}RESTARTING...${RESET}`;
   if (isRebuilding) return `${FG_YELLOW}REBUILDING...${RESET}`;
   if (!status) return `${FG_GRAY}stopped${RESET}`;
@@ -109,8 +111,15 @@ function statusText(status, isRebuilding, isRestarting) {
   return `${DIM}${text}${RESET}`;
 }
 
+function formatMem(bytes) {
+  if (bytes <= 0) return '-';
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}K`;
+  if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / (1024 * 1024))}M`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
+
 function renderLegend(opts = {}) {
-  const { logPanelActive = false, fullLogsActive = false, logsScrollMode = false } = opts;
+  const { logPanelActive = false, fullLogsActive = false, logsScrollMode = false, noCacheActive = false } = opts;
   const item = (text, active) => {
     if (active) return `${BG_HIGHLIGHT} ${text} ${RESET}`;
     return `${DIM}${text}${RESET}`;
@@ -121,12 +130,16 @@ function renderLegend(opts = {}) {
       item('[j/k] scroll', false),
       item('[G] bottom', false),
       item('[gg] top', false),
+      item('[/] search', false),
+      item('[n/N] next/prev', false),
       item('[Q]uit', false),
     ].join('  ');
   }
   return [
-    item('[R]ebuild', false),
-    item('[S]restart', false),
+    item('Re[B]uild', false),
+    item('[S]tart/restart', false),
+    item('Sto[P]', false),
+    item('[N]o cache', noCacheActive),
     item('[F]ull logs', fullLogsActive),
     item('[L]og panel', logPanelActive),
     item('[Q]uit', false),
@@ -142,7 +155,7 @@ function renderListView(state) {
   for (const line of LOGO) {
     buf.push(line);
   }
-  const help = renderLegend({ logPanelActive: state.showBottomLogs });
+  const help = renderLegend({ logPanelActive: state.showBottomLogs, noCacheActive: state.noCache });
   buf.push(` ${FG_GRAY}${'─'.repeat(Math.max(0, columns - 2))}${RESET}`);
   buf.push(` ${help}`);
 
@@ -157,10 +170,53 @@ function renderListView(state) {
       const info = state.bottomLogLines.get(sk);
       if (info) {
         bottomBuf.push(` ${FG_GRAY}${'─'.repeat(Math.max(0, columns - 2))}${RESET}`);
-        const actionColor = info.action === 'rebuilding' || info.action === 'restarting' ? FG_YELLOW : FG_GREEN;
-        bottomBuf.push(` ${actionColor}${info.action} ${BOLD}${info.service}${RESET}`);
+        const actionColor = info.action === 'rebuilding' || info.action === 'restarting' || info.action === 'stopping' || info.action === 'starting' ? FG_YELLOW : FG_GREEN;
+        let headerLine = ` ${actionColor}${info.action} ${BOLD}${info.service}${RESET}`;
+        // Show search info
+        const bq = state.bottomSearchQuery || '';
+        if (bq && !state.bottomSearchActive) {
+          const matchCount = info.lines.filter(l => l.toLowerCase().includes(bq.toLowerCase())).length;
+          headerLine += matchCount > 0
+            ? `  ${DIM}search: "${bq}" (${matchCount} match${matchCount !== 1 ? 'es' : ''})${RESET}`
+            : `  ${FG_RED}search: "${bq}" (no matches)${RESET}`;
+        }
+        bottomBuf.push(headerLine);
+
+        const searchQuery = bq && !state.bottomSearchActive ? bq : '';
+
         for (const line of info.lines) {
-          bottomBuf.push(`  ${FG_GRAY}${line.substring(0, columns - 4)}${RESET}`);
+          let coloredLine = line.substring(0, columns - 4);
+          // Highlight search query
+          if (searchQuery) {
+            const lowerLine = coloredLine.toLowerCase();
+            const lowerQ = searchQuery.toLowerCase();
+            if (lowerLine.includes(lowerQ)) {
+              let result = '';
+              let pos = 0;
+              while (pos < coloredLine.length) {
+                const idx = lowerLine.indexOf(lowerQ, pos);
+                if (idx === -1) { result += coloredLine.substring(pos); break; }
+                result += coloredLine.substring(pos, idx);
+                result += `${REVERSE}${FG_YELLOW}${coloredLine.substring(idx, idx + searchQuery.length)}${RESET}${FG_GRAY}`;
+                pos = idx + searchQuery.length;
+              }
+              coloredLine = result;
+            }
+          }
+          // Highlight log scan patterns
+          for (let pi = 0; pi < patterns.length; pi++) {
+            const p = patterns[pi];
+            if (coloredLine.includes(p)) {
+              const color = PATTERN_COLORS[pi % PATTERN_COLORS.length];
+              coloredLine = coloredLine.split(p).join(`${color}${p}${RESET}${FG_GRAY}`);
+            }
+          }
+          bottomBuf.push(`  ${FG_GRAY}${coloredLine}${RESET}`);
+        }
+
+        // Search prompt
+        if (state.bottomSearchActive) {
+          bottomBuf.push(`${BOLD}/${RESET}${state.bottomSearchQuery}${BOLD}_${RESET}`);
         }
       }
     }
@@ -187,6 +243,7 @@ function renderListView(state) {
       }
       let colHeader = `${DIM}     ${'SERVICE'.padEnd(24)} ${'STATUS'.padEnd(22)} ${'BUILT'.padEnd(12)} ${'RESTARTED'.padEnd(12)}`;
       for (const p of patterns) colHeader += patternLabel(p).padStart(5) + ' ';
+      colHeader += `   ${'CPU/MEM'.padStart(16)} ${'PORTS'.padEnd(14)}`;
       lines.push({ type: 'colheader', text: colHeader + RESET });
     }
 
@@ -194,10 +251,42 @@ function renderListView(state) {
     const st = state.statuses.get(sk);
     const rebuilding = state.rebuilding.has(sk);
     const restarting = state.restarting.has(sk);
-    const icon = statusIcon(st, rebuilding, restarting);
-    const stext = statusText(st, rebuilding, restarting);
+    const stopping = state.stopping.has(sk);
+    const starting = state.starting.has(sk);
+    const icon = statusIcon(st, rebuilding, restarting, stopping, starting);
+    const stext = statusText(st, rebuilding, restarting, stopping, starting);
     const name = entry.service.padEnd(24);
     const statusPadded = padVisible(stext, 22);
+
+    // CPU/MEM column
+    let cpuMemStr;
+    const stats = state.containerStats ? state.containerStats.get(sk) : null;
+    if (stats && st && st.state === 'running') {
+      const cpu = stats.cpuPercent;
+      const mem = stats.memUsageBytes;
+      const cpuWarn = state.config.cpuWarnThreshold || 50;
+      const cpuDanger = state.config.cpuDangerThreshold || 100;
+      const memWarn = (state.config.memWarnThreshold || 512) * 1024 * 1024;
+      const memDanger = (state.config.memDangerThreshold || 1024) * 1024 * 1024;
+      let color = DIM;
+      if (cpu > cpuDanger || mem > memDanger) color = FG_RED;
+      else if (cpu > cpuWarn || mem > memWarn) color = FG_YELLOW;
+      const cpuText = cpu.toFixed(1) + '%';
+      const memText = formatMem(mem);
+      cpuMemStr = padVisible(`${color}${cpuText} / ${memText}${RESET}`, 16);
+    } else {
+      cpuMemStr = padVisible(`${DIM}-${RESET}`, 16);
+    }
+
+    // Ports column
+    let portsStr;
+    if (st && st.ports && st.ports.length > 0) {
+      const portsText = st.ports.map(p => p.published).join(' ');
+      portsStr = padVisible(`${DIM}${portsText}${RESET}`, 14);
+    } else {
+      portsStr = padVisible(`${DIM}-${RESET}`, 14);
+    }
+
     const built = padVisible(relativeTime(st ? st.createdAt : null), 12);
     const restarted = padVisible(relativeTime(st ? st.startedAt : null), 12);
     const pointer = i === state.cursor ? `${REVERSE}` : '';
@@ -214,7 +303,7 @@ function renderListView(state) {
 
     lines.push({
       type: 'service',
-      text: `${pointer}   ${icon} ${FG_WHITE}${name}${RESET} ${statusPadded} ${built} ${restarted}${countsStr}${endPointer}`,
+      text: `${pointer}   ${icon} ${FG_WHITE}${name}${RESET} ${statusPadded} ${built} ${restarted}${countsStr}  ${cpuMemStr} ${portsStr}${endPointer}`,
       flatIdx: i,
     });
   }
@@ -270,6 +359,25 @@ function truncateLine(str, maxWidth) {
   return str;
 }
 
+function highlightSearchInLine(line, query) {
+  if (!query) return line;
+  const lowerLine = line.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  let result = '';
+  let pos = 0;
+  while (pos < line.length) {
+    const idx = lowerLine.indexOf(lowerQuery, pos);
+    if (idx === -1) {
+      result += line.substring(pos);
+      break;
+    }
+    result += line.substring(pos, idx);
+    result += `${REVERSE}${FG_YELLOW}${line.substring(idx, idx + query.length)}${RESET}`;
+    pos = idx + query.length;
+  }
+  return result;
+}
+
 function renderLogView(state) {
   const { columns = 80, rows = 24 } = process.stdout;
   const buf = [];
@@ -284,13 +392,24 @@ function renderLogView(state) {
   const serviceName = entry ? entry.service : '???';
   const totalLines = state.logLines.length;
 
+  let statusLine = ` ${FG_GREEN}full logs ${BOLD}${serviceName}${RESET}`;
   const scrollStatus = state.logAutoScroll
     ? `${FG_GREEN}live${RESET}`
     : `${FG_YELLOW}paused ${DIM}line ${Math.max(1, totalLines - state.logScrollOffset)} / ${totalLines}${RESET}`;
-  buf.push(` ${FG_GREEN}full logs ${BOLD}${serviceName}${RESET}  ${scrollStatus}`);
+  statusLine += `  ${scrollStatus}`;
 
+  // Show search match count
+  if (state.logSearchQuery && state.logSearchMatches.length > 0) {
+    statusLine += `  ${DIM}match ${state.logSearchMatchIdx + 1}/${state.logSearchMatches.length}${RESET}`;
+  } else if (state.logSearchQuery && state.logSearchMatches.length === 0) {
+    statusLine += `  ${FG_RED}no matches${RESET}`;
+  }
+  buf.push(statusLine);
+
+  // Reserve 1 row for search prompt if active
+  const bottomReserved = state.logSearchActive ? 1 : 0;
   const headerHeight = buf.length;
-  const availableRows = Math.max(1, rows - headerHeight);
+  const availableRows = Math.max(1, rows - headerHeight - bottomReserved);
 
   let endLine;
   if (state.logAutoScroll || state.logScrollOffset === 0) {
@@ -300,15 +419,28 @@ function renderLogView(state) {
   }
   const startLine = Math.max(0, endLine - availableRows);
 
+  const searchQuery = state.logSearchQuery || '';
+  const matchSet = searchQuery ? new Set(state.logSearchMatches) : null;
+
   for (let i = startLine; i < endLine; i++) {
-    buf.push(truncateLine(state.logLines[i], columns));
+    let line = state.logLines[i];
+    if (matchSet && matchSet.has(i)) {
+      line = highlightSearchInLine(line, searchQuery);
+    }
+    buf.push(truncateLine(line, columns));
   }
 
-  // Pad to fill screen (prevents ghost content from previous render)
-  for (let i = buf.length; i < rows; i++) {
+  // Pad to fill screen
+  const targetRows = rows - bottomReserved;
+  for (let i = buf.length; i < targetRows; i++) {
     buf.push('');
   }
 
+  // Search prompt at the bottom
+  if (state.logSearchActive) {
+    buf.push(`${BOLD}/${RESET}${state.logSearchQuery}${BOLD}_${RESET}`);
+  }
+
   return buf.join('\n');
 }
 

package/lib/state.js

@@ -11,8 +11,13 @@ function createState(config) {
     statuses: new Map(),   // "file::service" -> { state, health }
     rebuilding: new Map(), // "file::service" -> childProcess
     restarting: new Map(), // "file::service" -> childProcess
+    stopping: new Map(),   // "file::service" -> childProcess
+    starting: new Map(),   // "file::service" -> childProcess
+    containerStats: new Map(),        // statusKey -> { cpuPercent, memUsageBytes }
+    containerStatsHistory: new Map(), // statusKey -> { cpu: number[], mem: number[], idx, count }
     logChild: null,
     scrollOffset: 0,
+    noCache: false,
     showBottomLogs: true,
     bottomLogLines: new Map(), // statusKey -> { action, service, lines: [] }
     bottomLogTails: new Map(), // statusKey -> childProcess (log tail after restart)
@@ -21,6 +26,12 @@ function createState(config) {
     logLines: [],              // buffered log lines for full log view
     logScrollOffset: 0,        // lines from bottom (0 = at bottom)
     logAutoScroll: true,       // auto-scroll to bottom on new data
+    logSearchQuery: '',
+    logSearchActive: false,    // true when typing search query
+    logSearchMatches: [],      // array of line indices
+    logSearchMatchIdx: -1,     // current match position
+    bottomSearchQuery: '',
+    bottomSearchActive: false, // true when typing search in bottom panel
     config,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recomposable",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Docker Compose TUI manager with vim keybindings — monitor, restart, rebuild, and tail logs for your services",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "files": [
     "index.js",
-    "lib/"
+    "lib/",
+    "screenshots/"
   ],
   "keywords": [
     "docker",