ninja-terminals 2.3.1 → 2.3.3

package/lib/nameGenerator.ts

@@ -0,0 +1,101 @@
+/**
+ * VeryRealNames - Absurd but plausible name generator
+ * Names sound like they COULD be real... but aren't
+ */
+
+const FIRST_NAMES = [
+  // Old-timey gems
+  'Hank', 'Gertrude', 'Chester', 'Mildred', 'Barnaby', 'Ethel', 'Cornelius', 'Bertha',
+  'Thaddeus', 'Gladys', 'Reginald', 'Edna', 'Archibald', 'Myrtle', 'Beauregard', 'Agatha',
+  'Wilbur', 'Prudence', 'Mortimer', 'Hortense', 'Bartholomew', 'Eunice', 'Horatio', 'Blanche',
+  'Cuthbert', 'Delphine', 'Engelbert', 'Geraldine', 'Humphrey', 'Imogene',
+  // Slightly unusual but real
+  'Grover', 'Cletus', 'Melvin', 'Dorcas', 'Floyd', 'Beulah', 'Lester', 'Opal',
+  'Merle', 'Velma', 'Elmer', 'Lurleen', 'Durwood', 'Wanda', 'Gus', 'Bernice',
+  'Norbert', 'Doreen', 'Seymour', 'Fern', 'Murray', 'Irma', 'Roscoe', 'Hazel',
+  // Fancy yet awkward
+  'Percival', 'Millicent', 'Fitzgerald', 'Clementine', 'Montgomery', 'Josephine',
+  'Wellington', 'Cordelia', 'Pemberton', 'Henrietta', 'Thurgood', 'Philomena',
+];
+
+const LAST_NAMES = [
+  // Food-adjacent
+  'Pancely', 'Biscuitson', 'Crumbsworth', 'Gravyton', 'Stewbottom', 'Butterham',
+  'Cheesley', 'Meatworth', 'Croutonski', 'Souperton', 'Hamsworth', 'Loafman',
+  'Brisketson', 'Cabbagely', 'Noodleman', 'Porridge', 'Beefington', 'Dumpling',
+  // Animal-infused
+  'Wombleton', 'Badgerly', 'Gooseman', 'Ducksworth', 'Weaselton', 'Moosebury',
+  'Ferretson', 'Hedgewood', 'Squirrelman', 'Toadsworth', 'Pigglesworth', 'Newterson',
+  'Crabshaw', 'Lobsterman', 'Clamsworthy', 'Oysterton',
+  // Body part blends
+  'Finklebottom', 'Rumplesworth', 'Kneely', 'Elbowton', 'Thumbleton', 'Noseberg',
+  'Earlington', 'Toesworth', 'Chinley', 'Knuckleton', 'Shoulderby', 'Ankleman',
+  // Silly suffixes
+  'Wobbleford', 'Snickerton', 'Puddlesworth', 'Bumblesby', 'Giggleston', 'Fumbleby',
+  'Tumblewood', 'Mumbleston', 'Bumbleworth', 'Crumbleford', 'Stumblebrook',
+  // Object-based
+  'Lampsworth', 'Chairington', 'Tableson', 'Doorknobby', 'Carpetman', 'Curtainsby',
+  'Bucketworth', 'Brickleton', 'Plungerby', 'Sockington',
+];
+
+export interface GeneratedName {
+  firstName: string;
+  lastName: string;
+  fullName: string;
+}
+
+/**
+ * Generate a single absurd-but-plausible name
+ */
+export function generateName(): GeneratedName {
+  const firstName = FIRST_NAMES[Math.floor(Math.random() * FIRST_NAMES.length)];
+  const lastName = LAST_NAMES[Math.floor(Math.random() * LAST_NAMES.length)];
+
+  return {
+    firstName,
+    lastName,
+    fullName: `${firstName} ${lastName}`,
+  };
+}
+
+/**
+ * Generate multiple unique names
+ */
+export function generateNames(count: number): GeneratedName[] {
+  const names: GeneratedName[] = [];
+  const seen = new Set<string>();
+
+  const maxPossible = FIRST_NAMES.length * LAST_NAMES.length;
+  const targetCount = Math.min(count, maxPossible);
+
+  while (names.length < targetCount) {
+    const name = generateName();
+    if (!seen.has(name.fullName)) {
+      seen.add(name.fullName);
+      names.push(name);
+    }
+  }
+
+  return names;
+}
+
+/**
+ * Get all available first names
+ */
+export function getFirstNames(): readonly string[] {
+  return FIRST_NAMES;
+}
+
+/**
+ * Get all available last names
+ */
+export function getLastNames(): readonly string[] {
+  return LAST_NAMES;
+}
+
+/**
+ * Get total possible unique combinations
+ */
+export function getTotalCombinations(): number {
+  return FIRST_NAMES.length * LAST_NAMES.length;
+}

package/lib/pre-dispatch.js

@@ -41,11 +41,13 @@ async function loadToolRatings() {
 
 /**
  * Generate tool guidance strings from ratings.
+ * Limited to top 5 warnings + top 5 recommendations to avoid flooding terminals.
  * @param {Map<string, object>} ratings
  * @returns {string[]}
  */
 function generateToolGuidance(ratings) {
-  const guidance = [];
+  const warnings = [];
+  const recommendations = [];
 
   for (const [tool, stats] of ratings) {
     const { rating, composite, success_rate } = stats;
@@ -54,16 +56,24 @@ function generateToolGuidance(ratings) {
       // Low-rated tool: suggest avoidance
       const alt = TOOL_ALTERNATIVES[tool];
       if (alt) {
-        guidance.push(`Avoid ${tool} for ${alt.useCase}, prefer ${alt.preferred} (${tool} has ${rating} rating: ${composite})`);
+        warnings.push({ tool, msg: `Avoid ${tool} for ${alt.useCase}, prefer ${alt.preferred} (${rating} rating)`, composite });
       } else {
-        guidance.push(`Use ${tool} cautiously — ${rating} rating (${composite}), success rate: ${(success_rate * 100).toFixed(0)}%`);
+        warnings.push({ tool, msg: `Use ${tool} cautiously — ${rating} rating, success: ${(success_rate * 100).toFixed(0)}%`, composite });
       }
     } else if (rating === 'S' || rating === 'A') {
       // High-rated tool: recommend preference
-      guidance.push(`Prefer ${tool} — reliable (${rating} rating: ${composite})`);
+      recommendations.push({ tool, msg: `Prefer ${tool} — ${rating} rating`, composite });
     }
   }
 
+  // Sort and limit: worst 5 warnings, best 5 recommendations
+  warnings.sort((a, b) => a.composite - b.composite);
+  recommendations.sort((a, b) => b.composite - a.composite);
+
+  const guidance = [];
+  for (const w of warnings.slice(0, 5)) guidance.push(w.msg);
+  for (const r of recommendations.slice(0, 5)) guidance.push(r.msg);
+
   return guidance;
 }
 

package/lib/runtime-session.js

@@ -0,0 +1,337 @@
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const SESSION_DIR = path.join(os.homedir(), '.ninja');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+const TOKEN_FILE = path.join(SESSION_DIR, 'token');
+const LEDGER_FILE = path.join(SESSION_DIR, 'dispatch-ledger.ndjson');
+const VERIFICATION_LEDGER_FILE = path.join(SESSION_DIR, 'verification-ledger.ndjson');
+const VISUAL_LEDGER_FILE = path.join(SESSION_DIR, 'visual-ledger.ndjson');
+
+function ensureSessionDir() {
+  fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
+}
+
+function isPortAvailable(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host);
+  });
+}
+
+async function findAvailablePort(preferredPort, host = '127.0.0.1', maxAttempts = 50) {
+  const start = Number.parseInt(preferredPort, 10);
+  if (!Number.isInteger(start) || start < 1 || start > 65535) {
+    throw new Error(`Invalid preferred port: ${preferredPort}`);
+  }
+
+  for (let port = start; port < start + maxAttempts && port <= 65535; port++) {
+    if (await isPortAvailable(port, host)) return port;
+  }
+
+  throw new Error(`No available port found from ${start} to ${Math.min(start + maxAttempts - 1, 65535)}`);
+}
+
+function writeRuntimeSession(session) {
+  ensureSessionDir();
+  const payload = {
+    version: 1,
+    pid: process.pid,
+    host: 'localhost',
+    createdAt: new Date().toISOString(),
+    ...session,
+  };
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(payload, null, 2) + '\n', { mode: 0o600 });
+  return payload;
+}
+
+function updateRuntimeSession(patch) {
+  const current = readRuntimeSession() || {};
+  return writeRuntimeSession({ ...current, ...patch, updatedAt: new Date().toISOString() });
+}
+
+function readRuntimeSession() {
+  try {
+    const raw = fs.readFileSync(SESSION_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function clearRuntimeSession() {
+  try {
+    fs.unlinkSync(SESSION_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+function writeAuthToken(token) {
+  ensureSessionDir();
+  fs.writeFileSync(TOKEN_FILE, token, { mode: 0o600 });
+}
+
+function readAuthToken() {
+  try {
+    return fs.readFileSync(TOKEN_FILE, 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+function requestJson({ host = 'localhost', port, path: reqPath, token, method = 'GET', body = null, timeoutMs = 3000 }) {
+  return new Promise((resolve, reject) => {
+    const payload = body ? JSON.stringify(body) : null;
+    const headers = {};
+    if (payload) {
+      headers['Content-Type'] = 'application/json';
+      headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    const req = http.request({
+      hostname: host,
+      port,
+      path: reqPath,
+      method,
+      headers,
+      timeout: timeoutMs,
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        let parsed = null;
+        try {
+          parsed = data ? JSON.parse(data) : null;
+        } catch {
+          parsed = data;
+        }
+        resolve({ statusCode: res.statusCode, body: parsed, raw: data });
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy(new Error(`Request timed out after ${timeoutMs}ms`));
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function healthCheckSession(session, timeoutMs = 3000) {
+  if (!session || !session.port) return { ok: false, error: 'No runtime session port' };
+  try {
+    const res = await requestJson({
+      host: session.host || 'localhost',
+      port: session.port,
+      path: '/health',
+      timeoutMs,
+    });
+    if (
+      res.statusCode >= 200 &&
+      res.statusCode < 300 &&
+      res.body &&
+      res.body.status === 'ok' &&
+      Object.prototype.hasOwnProperty.call(res.body, 'terminals')
+    ) {
+      return { ok: true, response: res.body };
+    }
+    return { ok: false, error: `HTTP ${res.statusCode}`, response: res.body };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function openBrowserTab(url) {
+  // Opt-in: only open browser if NINJA_OPEN_BROWSER=true
+  if (process.env.NINJA_OPEN_BROWSER !== '1' && process.env.NINJA_OPEN_BROWSER !== 'true') {
+    return false;
+  }
+
+  if (process.platform === 'darwin') {
+    const child = spawn('open', ['-a', 'Google Chrome', url], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.on('error', () => {
+      const fallback = spawn('open', [url], { detached: true, stdio: 'ignore' });
+      fallback.unref();
+    });
+    child.unref();
+    return true;
+  }
+
+  const opener = process.platform === 'win32' ? 'start' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['', url] : [url];
+  const child = spawn(opener, args, { detached: true, stdio: 'ignore', shell: process.platform === 'win32' });
+  child.unref();
+  return true;
+}
+
+// ── Dispatch Ledger ──────────────────────────────────────────
+
+function appendLedgerEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readLedgerEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    // Return last N entries (most recent)
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearLedger() {
+  try {
+    fs.unlinkSync(LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+// ── Verification Ledger ──────────────────────────────────────────
+// Records output/status checks after dispatch
+
+function appendVerificationEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(VERIFICATION_LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readVerificationEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(VERIFICATION_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearVerificationLedger() {
+  try {
+    fs.unlinkSync(VERIFICATION_LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+// ── Visual Ledger ──────────────────────────────────────────
+// Records browser visual inspections via claude-in-chrome
+
+const VALID_VISUAL_STAGES = ['pre-dispatch', 'post-dispatch', 'post-output', 'final-visual'];
+
+function appendVisualEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(VISUAL_LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readVisualEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(VISUAL_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearVisualLedger() {
+  try {
+    fs.unlinkSync(VISUAL_LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+function hasVisualAfter(afterTimestamp, options = {}) {
+  const entries = readVisualEntries(100);
+  return entries.some(e => {
+    if (!e.timestamp || e.timestamp <= afterTimestamp) return false;
+    if (options.stage && e.stage !== options.stage) return false;
+    if (options.terminalId && e.terminalId !== options.terminalId) return false;
+    return true;
+  });
+}
+
+module.exports = {
+  SESSION_DIR,
+  SESSION_FILE,
+  TOKEN_FILE,
+  LEDGER_FILE,
+  VERIFICATION_LEDGER_FILE,
+  VISUAL_LEDGER_FILE,
+  VALID_VISUAL_STAGES,
+  findAvailablePort,
+  writeRuntimeSession,
+  updateRuntimeSession,
+  readRuntimeSession,
+  clearRuntimeSession,
+  writeAuthToken,
+  readAuthToken,
+  healthCheckSession,
+  requestJson,
+  openBrowserTab,
+  appendLedgerEntry,
+  readLedgerEntries,
+  clearLedger,
+  appendVerificationEntry,
+  readVerificationEntries,
+  clearVerificationLedger,
+  appendVisualEntry,
+  readVisualEntries,
+  clearVisualLedger,
+  hasVisualAfter,
+};

package/lib/status-detect.js

@@ -37,7 +37,7 @@ const SPINNER_RE = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]|Thinking|Generating/i;
  * Detect the current operational status of a Claude Code terminal.
  *
  * @param {string[]} lines - Array of ANSI-stripped lines (from LineBuffer)
- * @returns {'idle'|'working'|'waiting_approval'|'compacting'|'done'|'blocked'|'error'}
+ * @returns {'idle'|'working'|'waiting_approval'|'compacting'|'done'|'blocked'|'error'|'exited'}
  */
 function detectStatus(lines) {
   if (!lines || lines.length === 0) return 'idle';
@@ -51,8 +51,18 @@ function detectStatus(lines) {
   const lastContentLine = contentLines.slice(-1)[0] || '';
   const last10 = trimmed.slice(-10);
 
+  // Closed or disconnected PTY session
+  if (/\[Connection closed\]|Connection closed/i.test(last50)) {
+    return 'exited';
+  }
+
+  // Rate-limit and explicit blocking menus are not active work
+  if (/out of (extra )?usage|rate-limit-options|Stop and wait for limit to reset|Upgrade your plan/i.test(last50)) {
+    return 'blocked';
+  }
+
   // Prompt detection — idle if prompt is visible and no recent tool work
-  const hasPrompt = last10.some(l => /^[>❯]$/.test(l));
+  const hasPrompt = last10.some(l => /^[>❯]/.test(l) || /Try\s+"[^"]+"/i.test(l));
   const hasShortcutsHint = last10.some(
     l => /\?.*for\s*shortcuts/i.test(l) || l === '?forshortcuts'
   );
@@ -74,8 +84,9 @@ function detectStatus(lines) {
   if (/auto-compact|compressing|compacting/i.test(last50)) return 'compacting';
 
   // Explicit status markers (convention for orchestrator scripts)
-  if (/STATUS: DONE/i.test(last50)) return 'done';
-  if (/STATUS: BLOCKED/i.test(last50)) return 'blocked';
+  if (/^\s*STATUS:\s*DONE/im.test(last50)) return 'done';
+  if (/^\s*STATUS:\s*BLOCKED/im.test(last50)) return 'blocked';
+  if (/^\s*STATUS:\s*ERROR/im.test(last50)) return 'error';
 
   // Active tool use
   if (TOOL_RE.test(last50)) return 'working';
@@ -221,9 +232,62 @@ function extractStructuredEvents(lines, terminalLabel) {
   return events;
 }
 
+// ---------------------------------------------------------------------------
+// Task Status Parsing (semantic status from worker output)
+// ---------------------------------------------------------------------------
+
+/**
+ * Valid task status states.
+ * @type {string[]}
+ */
+const VALID_TASK_STATES = ['pending', 'running', 'done', 'blocked', 'error', 'unknown'];
+
+/**
+ * Regex patterns for parsing STATUS: markers.
+ * Captures the status type and optional message.
+ */
+const TASK_STATUS_PATTERNS = [
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*DONE\s*[-—]?\s*(.*)/i, state: 'done' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*BLOCKED\s*[-—]?\s*(.*)/i, state: 'blocked' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*ERROR[:\s]*[-—]?\s*(.*)/i, state: 'error' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*RUNNING\s*[-—]?\s*(.*)/i, state: 'running' },
+];
+
+/**
+ * Parse terminal output for the most recent STATUS: marker.
+ * Scans from end to find the latest semantic task status.
+ *
+ * @param {string[]} lines - Array of ANSI-stripped lines
+ * @returns {{ state: string, marker: string, message: string } | null}
+ */
+function parseTaskStatus(lines) {
+  if (!lines || lines.length === 0) return null;
+
+  // Scan from the end — most recent status wins
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    for (const { re, state } of TASK_STATUS_PATTERNS) {
+      const match = line.match(re);
+      if (match) {
+        return {
+          state,
+          marker: match[0].trim(),
+          message: match[1]?.trim() || '',
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
 module.exports = {
   stripAnsi,
   detectStatus,
   extractContextPct,
   extractStructuredEvents,
+  parseTaskStatus,
+  VALID_TASK_STATES,
 };