mixdog 0.7.18 → 0.8.0

package/scripts/smoke-loop.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const DEFAULT_DURATION_MS = 5 * 60 * 60 * 1000;
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const prefix = `${name}=`;
+  const hit = process.argv.find((arg) => arg.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : fallback;
+}
+
+function argFlag(name) {
+  return process.argv.includes(name);
+}
+
+function parseDuration(value, fallback) {
+  const raw = String(value || '').trim();
+  if (!raw) return fallback;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/i);
+  if (!match) throw new Error(`invalid duration: ${raw}`);
+  const n = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : 3_600_000;
+  return Math.max(1, Math.floor(n * mult));
+}
+
+function resolveOptionalPath(value, fallback) {
+  const raw = String(value || '').trim();
+  const picked = raw || fallback;
+  if (!picked) return null;
+  return isAbsolute(picked) ? picked : resolve(root, picked);
+}
+
+function runNode(args, label, timeoutMs = 180_000) {
+  const startedAt = performance.now();
+  const result = spawnSync(process.execPath, args, {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+  const ms = performance.now() - startedAt;
+  if (result.status !== 0) {
+    const out = `${result.error ? `${result.error}\n` : ''}${result.stdout || ''}${result.stderr || ''}`.trim();
+    throw new Error(`${label} failed in ${ms.toFixed(1)}ms:\n${out}`);
+  }
+  return { ms, stdout: result.stdout || '', stderr: result.stderr || '' };
+}
+
+function runSmokeAll(iteration) {
+  let totalMs = 0;
+  const steps = [];
+  for (const script of ['scripts/boot-smoke.mjs', 'scripts/tool-smoke.mjs']) {
+    const result = runNode([script], `${script} iteration ${iteration}`);
+    totalMs += result.ms;
+    steps.push({
+      script,
+      ms: Math.round(result.ms * 10) / 10,
+    });
+  }
+  return { ms: totalMs, steps };
+}
+
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+
+function rssMb() {
+  return Math.round((process.memoryUsage().rss / 1024 / 1024) * 10) / 10;
+}
+
+function summarize(values) {
+  if (!values.length) return { min: 0, max: 0, avg: 0 };
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const avg = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return {
+    min: Math.round(min * 10) / 10,
+    max: Math.round(max * 10) / 10,
+    avg: Math.round(avg * 10) / 10,
+  };
+}
+
+function serializeError(error) {
+  return {
+    name: error?.name || 'Error',
+    message: error?.message || String(error),
+    stack: error?.stack || null,
+  };
+}
+
+const durationMs = parseDuration(argValue('--duration', process.env.MIXDOG_SMOKE_LOOP_DURATION), DEFAULT_DURATION_MS);
+const intervalMs = parseDuration(argValue('--interval', process.env.MIXDOG_SMOKE_LOOP_INTERVAL), 0);
+const maxIterations = Number(argValue('--iterations', process.env.MIXDOG_SMOKE_LOOP_ITERATIONS || 0)) || Infinity;
+const logPath = argFlag('--no-log')
+  ? null
+  : resolveOptionalPath(
+    argValue('--log', process.env.MIXDOG_SMOKE_LOOP_LOG),
+    '.mixdog/data/history/smoke-loop.jsonl',
+  );
+const startedAt = Date.now();
+const since = new Date(startedAt).toISOString();
+const deadline = startedAt + durationMs;
+let iteration = 0;
+const smokeTimes = [];
+const rssSamples = [];
+
+function writeLoopLog(row) {
+  if (!logPath) return;
+  mkdirSync(dirname(logPath), { recursive: true });
+  appendFileSync(logPath, `${JSON.stringify({
+    ts: new Date().toISOString(),
+    pid: process.pid,
+    ...row,
+  })}\n`, { encoding: 'utf8', mode: 0o600 });
+}
+
+function writeFatalLog(error) {
+  writeLoopLog({
+    type: 'error',
+    iteration,
+    elapsed_ms: Date.now() - startedAt,
+    error: serializeError(error),
+  });
+}
+
+process.on('uncaughtException', (error) => {
+  writeFatalLog(error);
+  process.stderr.write(`${error?.stack || error}\n`);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  writeFatalLog(error);
+  process.stderr.write(`${error.stack || error}\n`);
+  process.exit(1);
+});
+
+const startRss = rssMb();
+writeLoopLog({
+  type: 'start',
+  duration_ms: durationMs,
+  interval_ms: intervalMs,
+  max_iterations: Number.isFinite(maxIterations) ? maxIterations : null,
+  since,
+  rss_mb: startRss,
+});
+process.stdout.write(`smoke loop start duration=${durationMs}ms interval=${intervalMs}ms since=${since} rss_mb=${startRss} log=${logPath || 'off'}\n`);
+
+while (Date.now() < deadline && iteration < maxIterations) {
+  iteration += 1;
+  const iterStartedAt = Date.now();
+  const smoke = runSmokeAll(iteration);
+  smokeTimes.push(smoke.ms);
+  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1'], `failures iteration ${iteration}`, 60_000);
+  if (!/tool failures:\s+0\/0 shown/.test(failure.stdout)) {
+    throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
+  }
+  const currentRss = rssMb();
+  rssSamples.push(currentRss);
+  const elapsedMs = Date.now() - startedAt;
+  writeLoopLog({
+    type: 'iteration',
+    iteration,
+    smoke_ms: Math.round(smoke.ms * 10) / 10,
+    steps: smoke.steps,
+    rss_mb: currentRss,
+    elapsed_ms: elapsedMs,
+  });
+  const stepSummary = smoke.steps.map((step) => `${step.script.replace(/^scripts\//, '')}=${step.ms}ms`).join(' ');
+  process.stdout.write(`iteration ${iteration} ok smoke_ms=${smoke.ms.toFixed(1)} ${stepSummary} rss_mb=${currentRss} elapsed_ms=${elapsedMs}\n`);
+  const remaining = deadline - Date.now();
+  if (remaining <= 0 || iteration >= maxIterations) break;
+  if (intervalMs > 0) await sleep(Math.min(intervalMs, remaining));
+  if (Date.now() === iterStartedAt) await sleep(1);
+}
+
+const smokeSummary = summarize(smokeTimes);
+const rssSummary = summarize(rssSamples);
+const totalElapsedMs = Date.now() - startedAt;
+writeLoopLog({
+  type: 'summary',
+  iterations: iteration,
+  elapsed_ms: totalElapsedMs,
+  smoke_ms: smokeSummary,
+  rss_mb: rssSummary,
+});
+process.stdout.write(
+  `smoke loop passed iterations=${iteration} elapsed_ms=${totalElapsedMs} `
+  + `smoke_ms=min:${smokeSummary.min},avg:${smokeSummary.avg},max:${smokeSummary.max} `
+  + `rss_mb=min:${rssSummary.min},avg:${rssSummary.avg},max:${rssSummary.max}\n`,
+);

package/scripts/smoke.mjs

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+function runNode(args, label, options = {}) {
+  const child = spawnSync(process.execPath, args, {
+    cwd: root,
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 10000,
+  });
+  if (child.status !== 0) {
+    process.stderr.write(child.stderr || child.stdout || `${label} failed\n`);
+    process.exit(child.status || 1);
+  }
+  return child;
+}
+
+const child = runNode(['src/cli.mjs', '--help'], 'help smoke');
+const isolatedStatuslineEnv = {
+  MIXDOG_DATA_DIR: resolve(root, '.mixdog-smoke-data-empty'),
+  MIXDOG_HOME: resolve(root, '.mixdog-smoke-home-empty'),
+  MIXDOG_CONFIG_DIR: resolve(root, '.mixdog-smoke-config-empty'),
+};
+
+if (!child.stdout.includes('standalone mixdog CLI/TUI coding agent')) {
+  process.stderr.write(`unexpected help output:\n${child.stdout}`);
+  process.exit(1);
+}
+
+runNode(['--input-type=module', '-e', `
+  const mod = await import('./src/tui/dist/index.mjs');
+  if (typeof mod.runTui !== 'function') throw new Error('runTui export missing');
+`], 'tui bundle import smoke');
+
+runNode(['--input-type=module', '-e', `
+  process.stdout.columns = 120;
+  const { renderStatusline } = await import('./src/ui/statusline.mjs');
+  const line = await renderStatusline({
+    provider: 'openai',
+    model: 'gpt-5.5',
+    contextWindow: 1000000,
+    stats: { currentContextTokens: 999 },
+  });
+  if (/▓/.test(line) || !line.includes('░') || !line.includes('0.1%')) throw new Error('sub-1% context bar should stay empty: ' + JSON.stringify(line));
+`], 'statusline sub-percent context smoke', { env: isolatedStatuslineEnv });
+
+runNode(['--input-type=module', '-e', `
+  process.stdout.columns = 120;
+  const { renderStatusline } = await import('./src/ui/statusline.mjs');
+  const line = await renderStatusline({
+    provider: 'openai',
+    model: 'gpt-5.5',
+    contextWindow: 950000,
+    rawContextWindow: 1000000,
+    stats: { currentContextTokens: 900000 },
+  });
+  if (!line.includes('94%') || line.includes('100%')) throw new Error('statusline context% should use effective compact capacity, not the 90% auto-compact trigger: ' + JSON.stringify(line));
+`], 'statusline compact-capacity context smoke', { env: isolatedStatuslineEnv });
+
+runNode(['--input-type=module', '-e', `
+  process.stdout.columns = 120;
+  const { renderStatusline } = await import('./src/ui/statusline.mjs');
+  const line = await renderStatusline({
+    provider: 'openai',
+    model: 'gpt-5.5',
+    contextWindow: 950000,
+    stats: { currentContextTokens: 350000, currentContextSource: 'estimated' },
+  });
+  if (line.includes('37%') || !line.includes('0%')) throw new Error('statusline must not show local estimated context as session usage: ' + JSON.stringify(line));
+`], 'statusline estimated-context isolation smoke', { env: isolatedStatuslineEnv });
+
+runNode(['--input-type=module', '-e', `
+  const { mkdtempSync, mkdirSync, writeFileSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const { join } = await import('node:path');
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-status-smoke-'));
+  mkdirSync(join(root, 'runtime'), { recursive: true });
+  writeFileSync(join(root, 'runtime', 'active-instance.json'), JSON.stringify({
+    gateway_port: 3468,
+    gateway_server_pid: process.pid,
+    gateway_provider: 'openai',
+    gateway_model: 'gpt-5.5',
+    gateway_context_window: 950000,
+    gateway_raw_context_window: 1000000,
+    gateway_auto_compact_token_limit: 950000,
+    gateway_context_used_pct: 37,
+    gateway_cc_session_id: 'other-session',
+    gateway_updated_at: Date.now()
+  }));
+  process.env.MIXDOG_RUNTIME_ROOT = join(root, 'runtime');
+  const { loadGatewayStatus } = await import('./src/vendor/statusline/bin/statusline-route.mjs');
+  const status = loadGatewayStatus({ sessionId: 'fresh-session', clientHostPid: process.pid, activeContextTokens: 0 });
+  if (status?.contextUsedPct === 37) throw new Error('statusline leaked active-instance context from another session');
+`], 'statusline session metrics isolation smoke', { env: isolatedStatuslineEnv });
+
+const boot = spawnSync(process.execPath, ['src/cli.mjs', '--help'], {
+  cwd: root,
+  env: { ...process.env, MIXDOG_BOOT_PROFILE: '1' },
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'pipe'],
+  timeout: 10000,
+});
+
+if (boot.status !== 0 || !boot.stderr.includes('[mixdog-boot]') || !boot.stderr.includes('app:run:start')) {
+  process.stderr.write(boot.stderr || boot.stdout || 'boot profile smoke failed\n');
+  process.exit(boot.status || 1);
+}
+
+process.stdout.write('smoke passed ✓\n');

package/scripts/tool-failures.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+function argValue(name, fallback = null) {
+  const idx = process.argv.indexOf(name);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  const pref = `${name}=`;
+  const hit = process.argv.find((arg) => arg.startsWith(pref));
+  return hit ? hit.slice(pref.length) : fallback;
+}
+
+const limit = Math.max(1, Number.parseInt(argValue('--limit', '40'), 10) || 40);
+const dataDir = argValue('--data-dir', null);
+const mixdogHome = process.env.MIXDOG_HOME || resolve(homedir(), '.mixdog');
+const mixdogDataDir = process.env.MIXDOG_DATA_DIR || resolve(mixdogHome, 'data');
+const sinceArg = argValue('--since', null);
+const toolFilter = argValue('--tool', null);
+const roleFilter = argValue('--role', null);
+const categoryFilter = argValue('--category', null);
+const jsonMode = process.argv.includes('--json');
+const files = dataDir
+  ? [resolve(dataDir, 'history', 'tool-failures.jsonl')]
+    : [
+      resolve(process.cwd(), '.mixdog', 'data', 'history', 'tool-failures.jsonl'),
+      resolve(mixdogDataDir, 'history', 'tool-failures.jsonl'),
+    ];
+
+function readRows(file) {
+  if (!existsSync(file)) return [];
+  return readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return { file, ...JSON.parse(line) };
+      } catch {
+        return { file, parse_error: line };
+      }
+    });
+}
+
+function inc(map, key) {
+  map.set(key, (map.get(key) || 0) + 1);
+}
+
+function short(value, max = 180) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function timeLabel(ts) {
+  const n = Number(ts);
+  if (!Number.isFinite(n) || n <= 0) return '-';
+  try {
+    return new Date(n).toISOString();
+  } catch {
+    return String(ts);
+  }
+}
+
+function parseSince(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  if (/^now$/i.test(raw)) return Date.now();
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    return n > 10_000_000_000 ? n : n * 1000;
+  }
+  const rel = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i);
+  if (rel) {
+    const n = Number(rel[1]);
+    const unit = rel[2].toLowerCase();
+    const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : unit === 'h' ? 3_600_000 : 86_400_000;
+    return Date.now() - n * mult;
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function rowTool(row) {
+  return row.tool_name || row.toolName || row.tool || row.name || '(unknown)';
+}
+
+function rowCategory(row) {
+  return row.category || row.result_kind || row.resultKind || '(uncategorized)';
+}
+
+const sinceTs = parseSince(sinceArg);
+const rows = files.flatMap(readRows)
+  .filter((row) => sinceTs == null || Number(row.ts || 0) >= sinceTs)
+  .filter((row) => !toolFilter || rowTool(row) === toolFilter)
+  .filter((row) => !roleFilter || String(row.role || '-') === roleFilter)
+  .filter((row) => !categoryFilter || rowCategory(row) === categoryFilter)
+  .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
+const recent = rows.slice(-limit);
+const byTool = new Map();
+const byCategory = new Map();
+for (const row of recent) {
+  const tool = rowTool(row);
+  const category = rowCategory(row);
+  inc(byTool, tool);
+  inc(byCategory, `${tool} / ${category}`);
+}
+
+if (jsonMode) {
+  console.log(JSON.stringify({
+    shown: recent.length,
+    matched: rows.length,
+    since: sinceTs ? new Date(sinceTs).toISOString() : null,
+    filters: {
+      tool: toolFilter,
+      role: roleFilter,
+      category: categoryFilter,
+    },
+    sources: files.filter(existsSync),
+    tools: Object.fromEntries([...byTool.entries()].sort((a, b) => b[1] - a[1])),
+    categories: Object.fromEntries([...byCategory.entries()].sort((a, b) => b[1] - a[1])),
+    rows: recent,
+  }, null, 2));
+  process.exit(0);
+}
+
+console.log(`tool failures: ${recent.length}/${rows.length} shown`);
+if (sinceTs) console.log(`since: ${new Date(sinceTs).toISOString()}`);
+const filterParts = [
+  toolFilter ? `tool=${toolFilter}` : '',
+  roleFilter ? `role=${roleFilter}` : '',
+  categoryFilter ? `category=${categoryFilter}` : '',
+].filter(Boolean);
+if (filterParts.length) console.log(`filters: ${filterParts.join(', ')}`);
+if (files.length > 0) console.log(`sources: ${files.filter(existsSync).join(', ') || '(none)'}`);
+console.log(`tools: ${[...byTool.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+console.log(`categories: ${[...byCategory.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)'}`);
+for (const row of recent) {
+  const tool = rowTool(row);
+  const category = rowCategory(row);
+  const args = short(JSON.stringify(row.tool_args || row.args || {}), 140);
+  const result = short(row.error_first_line || row.error_preview || row.result || row.error || row.message || '', 220);
+  const role = row.role || '-';
+  console.log(`- ${timeLabel(row.ts)} iter=${row.iteration ?? '-'} role=${role} ${tool} ${category} args=${args}${result ? ` result=${result}` : ''}`);
+}