dave-code 1.0.4 → 1.2.0

package/bin/textWidth.js

@@ -0,0 +1,194 @@
+/**
+ * Single source of truth for terminal text measurement.
+ *
+ * Every renderer, menu, and header shares these helpers so a wide character is
+ * measured identically everywhere. Divergent local copies previously caused box
+ * borders and progress rows to drift apart by one or two columns.
+ */
+
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
+const OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+const STRING_CONTROL_RE = /\x1b[PX^_][\s\S]*?\x1b\\/g;
+const ESCAPE_RE = /\x1b(?:\[[0-?]*[ -/]*[@-~]|.)/g;
+
+// Zero-width: combining marks, variation selectors, joiners, and the BOM.
+const ZERO_WIDTH_RANGES = [
+  [0x0300, 0x036f], [0x0483, 0x0489], [0x0591, 0x05bd], [0x0610, 0x061a],
+  [0x064b, 0x065f], [0x0670, 0x0670], [0x06d6, 0x06dc], [0x0e31, 0x0e31],
+  [0x0e34, 0x0e3a], [0x0eb1, 0x0eb1], [0x1ab0, 0x1aff], [0x1dc0, 0x1dff],
+  [0x200b, 0x200f], [0x20d0, 0x20f0], [0xfe00, 0xfe0f], [0xfe20, 0xfe2f],
+  [0xfeff, 0xfeff], [0xe0100, 0xe01ef]
+];
+
+// Full-width: CJK, Hangul, Kana, fullwidth forms, and pictographs/emoji.
+const WIDE_RANGES = [
+  [0x1100, 0x115f], [0x2e80, 0x303e], [0x3041, 0x33ff], [0x3400, 0x4dbf],
+  [0x4e00, 0x9fff], [0xa000, 0xa4cf], [0xa960, 0xa97f], [0xac00, 0xd7a3],
+  [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60],
+  [0xffe0, 0xffe6], [0x16fe0, 0x16fe4], [0x17000, 0x18aff], [0x1b000, 0x1b2ff],
+  [0x1f004, 0x1f004], [0x1f0cf, 0x1f0cf], [0x1f18e, 0x1f18e], [0x1f191, 0x1f19a],
+  [0x1f200, 0x1f320], [0x1f32d, 0x1f335], [0x1f337, 0x1f37c], [0x1f37e, 0x1f393],
+  [0x1f3a0, 0x1f3ca], [0x1f3cf, 0x1f3d3], [0x1f3e0, 0x1f3f0], [0x1f3f4, 0x1f3f4],
+  [0x1f3f8, 0x1f43e], [0x1f440, 0x1f440], [0x1f442, 0x1f4fc], [0x1f4ff, 0x1f53d],
+  [0x1f54b, 0x1f54e], [0x1f550, 0x1f567], [0x1f57a, 0x1f57a], [0x1f595, 0x1f596],
+  [0x1f5a4, 0x1f5a4], [0x1f5fb, 0x1f64f], [0x1f680, 0x1f6c5], [0x1f6cc, 0x1f6cc],
+  [0x1f6d0, 0x1f6d2], [0x1f6eb, 0x1f6ec], [0x1f910, 0x1f9ff], [0x1fa70, 0x1faff],
+  [0x20000, 0x3fffd]
+];
+
+function inRanges(code, ranges) {
+  let low = 0;
+  let high = ranges.length - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (code < ranges[mid][0]) high = mid - 1;
+    else if (code > ranges[mid][1]) low = mid + 1;
+    else return true;
+  }
+  return false;
+}
+
+export function stripAnsi(text) {
+  return String(text ?? '').replace(ANSI_RE, '');
+}
+
+/**
+ * Remove escape sequences and control characters from model- or file-sourced
+ * text so untrusted content can never repaint or hijack the terminal.
+ */
+export function sanitizeUntrustedText(text) {
+  return String(text ?? '')
+    .replace(OSC_RE, '')
+    .replace(STRING_CONTROL_RE, '')
+    .replace(ESCAPE_RE, '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '');
+}
+
+export function charWidth(char) {
+  const code = char.codePointAt(0);
+  if (code === undefined) return 0;
+  if (code === 0x0a || code === 0x0d) return 0;
+  if (inRanges(code, ZERO_WIDTH_RANGES)) return 0;
+  if (code < 0x20 || (code >= 0x7f && code < 0xa0)) return 0;
+  return inRanges(code, WIDE_RANGES) ? 2 : 1;
+}
+
+export function displayWidth(text) {
+  let width = 0;
+  for (const char of stripAnsi(text)) width += charWidth(char);
+  return width;
+}
+
+/** Pad on the right to an exact display width; never truncates. */
+export function padEnd(text, width) {
+  const current = displayWidth(text);
+  return current >= width ? text : `${text}${' '.repeat(width - current)}`;
+}
+
+/** Center within an exact display width; never truncates. */
+export function padCenter(text, width) {
+  const current = displayWidth(text);
+  if (current >= width) return text;
+  const left = Math.floor((width - current) / 2);
+  return `${' '.repeat(left)}${text}${' '.repeat(width - current - left)}`;
+}
+
+/** Truncate from the right, appending an ellipsis when content is dropped. */
+export function truncateEnd(text, maxWidth, ellipsis = '…') {
+  const value = String(text ?? '');
+  if (displayWidth(value) <= maxWidth) return value;
+  const ellipsisWidth = displayWidth(ellipsis);
+  if (maxWidth <= ellipsisWidth) return ellipsis.slice(0, Math.max(0, maxWidth));
+  const target = maxWidth - ellipsisWidth;
+  let output = '';
+  let width = 0;
+  for (const char of value) {
+    const next = charWidth(char);
+    if (width + next > target) break;
+    output += char;
+    width += next;
+  }
+  return `${output}${ellipsis}`;
+}
+
+/**
+ * Truncate the middle, keeping both ends visible. Preferred for file paths,
+ * where the leading directory and the file name both carry meaning.
+ */
+export function truncateMiddle(text, maxWidth, ellipsis = '...') {
+  const value = String(text ?? '');
+  if (displayWidth(value) <= maxWidth) return value;
+  const ellipsisWidth = displayWidth(ellipsis);
+  if (maxWidth <= ellipsisWidth) return ellipsis.slice(0, Math.max(0, maxWidth));
+  const target = maxWidth - ellipsisWidth;
+  const leftTarget = Math.ceil(target / 2);
+  const rightTarget = target - leftTarget;
+
+  let left = '';
+  let leftWidth = 0;
+  for (const char of value) {
+    const next = charWidth(char);
+    if (leftWidth + next > leftTarget) break;
+    left += char;
+    leftWidth += next;
+  }
+
+  let right = '';
+  let rightWidth = 0;
+  for (const char of [...value].reverse()) {
+    const next = charWidth(char);
+    if (rightWidth + next > rightTarget) break;
+    right = char + right;
+    rightWidth += next;
+  }
+
+  return `${left}${ellipsis}${right}`;
+}
+
+/** Wrap to a display width, breaking mid-word only when a word cannot fit. */
+export function wrapText(text, width) {
+  const safeWidth = Math.max(1, Math.floor(width));
+  const lines = [];
+  const flush = line => lines.push(line.replace(/\s+$/, ''));
+  for (const paragraph of String(text ?? '').split('\n')) {
+    if (!paragraph) {
+      lines.push('');
+      continue;
+    }
+    let line = '';
+    let lineWidth = 0;
+    for (const word of paragraph.split(/(\s+)/)) {
+      if (!word) continue;
+      const wordWidth = displayWidth(word);
+      if (lineWidth + wordWidth <= safeWidth) {
+        line += word;
+        lineWidth += wordWidth;
+        continue;
+      }
+      if (/^\s+$/.test(word)) {
+        flush(line);
+        line = '';
+        lineWidth = 0;
+        continue;
+      }
+      if (line) {
+        flush(line);
+        line = '';
+        lineWidth = 0;
+      }
+      // A single word wider than the line must be split across rows.
+      for (const char of word) {
+        const next = charWidth(char);
+        if (lineWidth + next > safeWidth) {
+          flush(line);
+          line = '';
+          lineWidth = 0;
+        }
+        line += char;
+        lineWidth += next;
+      }
+    }
+    flush(line);
+  }
+  return lines;
+}

package/bin/thunderManager.js

@@ -0,0 +1,302 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const STORE_VERSION = 2;
+export const THUNDER_TIERS = Object.freeze({
+  balanced: { maxMembers: 6, concurrency: 4, validationDepth: 'standard' },
+  performance: { maxMembers: 9, concurrency: 6, validationDepth: 'deep' }
+});
+export const THUNDER_ROLES = Object.freeze([
+  'pm', 'techLead', 'frontend', 'backend', 'qa', 'designer', 'devops', 'securityData'
+]);
+export const MEMBER_STATUSES = new Set(['queued', 'working', 'waiting', 'reviewing', 'blocked', 'done']);
+export const TASK_STATUSES = new Set(['pending', 'in_progress', 'blocked', 'completed']);
+export const MESSAGE_TYPES = new Set(['update', 'question', 'answer', 'decision', 'handoff', 'risk', 'review']);
+
+let teamsBaseDir = path.join(os.homedir(), '.dave-code-teams');
+
+export function setTeamsBaseDirForTesting(directory) {
+  teamsBaseDir = directory;
+}
+
+function canonicalRoot(workspaceRoot) {
+  const resolved = path.resolve(workspaceRoot || process.cwd());
+  try {
+    const real = fs.realpathSync.native(resolved);
+    return process.platform === 'win32' ? real.toLowerCase() : real;
+  } catch {
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+  }
+}
+
+function workspaceKey(workspaceRoot) {
+  return crypto.createHash('sha256').update(canonicalRoot(workspaceRoot)).digest('hex');
+}
+
+export function getThunderStoreFile(workspaceRoot) {
+  return path.join(teamsBaseDir, `${workspaceKey(workspaceRoot)}.json`);
+}
+
+function safeText(value, max = 4000) {
+  return String(value ?? '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '').slice(0, max);
+}
+
+function atomicWrite(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temp = `${filePath}.${process.pid}.${crypto.randomBytes(5).toString('hex')}.tmp`;
+  fs.writeFileSync(temp, JSON.stringify(value, null, 2), { encoding: 'utf8', mode: 0o600 });
+  try { fs.chmodSync(temp, 0o600); } catch {}
+  try {
+    fs.renameSync(temp, filePath);
+  } catch (error) {
+    if (process.platform !== 'win32' || !fs.existsSync(filePath)) throw error;
+    fs.unlinkSync(filePath);
+    fs.renameSync(temp, filePath);
+  } finally {
+    if (fs.existsSync(temp)) fs.unlinkSync(temp);
+  }
+}
+
+function emptyStore(workspaceRoot) {
+  return { version: STORE_VERSION, workspaceRoot: canonicalRoot(workspaceRoot), teams: [] };
+}
+
+function normalizeMember(member) {
+  if (!member || !THUNDER_ROLES.includes(member.role)) return null;
+  return {
+    id: safeText(member.id || crypto.randomUUID(), 100),
+    role: member.role,
+    name: safeText(member.name || member.role, 80),
+    profile: safeText(member.profile || '', 120),
+    phase: ['scan', 'read', 'act', 'verify'].includes(member.phase) ? member.phase : 'read',
+    status: MEMBER_STATUSES.has(member.status) ? member.status : 'queued',
+    currentTask: member.currentTask ? safeText(member.currentTask, 120) : null,
+    latestReport: safeText(member.latestReport || '', 600),
+    waitingFor: member.waitingFor ? safeText(member.waitingFor, 100) : null,
+    tokenUsage: {
+      input: Number(member.tokenUsage?.input) || 0,
+      output: Number(member.tokenUsage?.output) || 0
+    },
+    contextUsage: {
+      usedTokens: Number(member.contextUsage?.usedTokens) || 0,
+      budgetTokens: Number(member.contextUsage?.budgetTokens) || 0
+    }
+  };
+}
+
+function normalizeTask(task) {
+  if (!task || typeof task !== 'object') return null;
+  return {
+    id: safeText(task.id || crypto.randomUUID(), 100),
+    title: safeText(task.title || 'Untitled task', 160),
+    purpose: safeText(task.purpose || '', 800),
+    owner: safeText(task.owner || '', 100),
+    status: TASK_STATUSES.has(task.status) ? task.status : 'pending',
+    dependencies: Array.isArray(task.dependencies) ? task.dependencies.map(value => safeText(value, 100)).slice(0, 20) : [],
+    inputs: Array.isArray(task.inputs) ? task.inputs.map(value => safeText(value, 500)).slice(0, 20) : [],
+    deliverable: safeText(task.deliverable || '', 1000),
+    fileScopes: Array.isArray(task.fileScopes) ? task.fileScopes.map(value => safeText(value, 300)).slice(0, 50) : [],
+    validation: safeText(task.validation || '', 1000)
+  };
+}
+
+function normalizeMessage(message) {
+  if (!message || !MESSAGE_TYPES.has(message.type)) return null;
+  return {
+    id: safeText(message.id || crypto.randomUUID(), 100),
+    from: safeText(message.from || '', 100),
+    to: safeText(message.to || '', 100),
+    type: message.type,
+    summary: safeText(message.summary || '', 1200),
+    refs: Array.isArray(message.refs) ? message.refs.map(value => safeText(value, 300)).slice(0, 20) : [],
+    requiresResponse: message.requiresResponse === true,
+    timestamp: Number(message.timestamp) || Date.now()
+  };
+}
+
+function normalizeTeam(team) {
+  if (!team || typeof team !== 'object' || !team.id) return null;
+  const tier = team.resourceProposal?.tier === 'performance' ? 'performance' : 'balanced';
+  return {
+    id: safeText(team.id, 100),
+    planId: team.planId ? safeText(team.planId, 100) : null,
+    planName: safeText(team.planName || '', 80),
+    request: safeText(team.request || '', 12000),
+    phase: ['intake', 'staffing', 'planning', 'awaiting_code', 'executing', 'reviewing', 'completed', 'blocked', 'cancelled'].includes(team.phase) ? team.phase : 'intake',
+    resourceProposal: {
+      tier,
+      concurrency: Math.min(THUNDER_TIERS[tier].concurrency, Math.max(1, Number(team.resourceProposal?.concurrency) || THUNDER_TIERS[tier].concurrency)),
+      validationDepth: safeText(team.resourceProposal?.validationDepth || THUNDER_TIERS[tier].validationDepth, 30),
+      rationale: safeText(team.resourceProposal?.rationale || '', 1200),
+      performanceRecommended: team.resourceProposal?.performanceRecommended === true,
+      approved: team.resourceProposal?.approved === true,
+      approvedAt: Number(team.resourceProposal?.approvedAt) || null
+    },
+    scanSnapshot: team.scanSnapshot && typeof team.scanSnapshot === 'object' ? {
+      snapshotId: safeText(team.scanSnapshot.snapshotId || '', 100),
+      totalFiles: Number(team.scanSnapshot.totalFiles) || 0,
+      totalBytes: Number(team.scanSnapshot.totalBytes) || 0,
+      cacheHits: Number(team.scanSnapshot.cacheHits) || 0,
+      languages: team.scanSnapshot.languages && typeof team.scanSnapshot.languages === 'object' ? team.scanSnapshot.languages : {},
+      directories: team.scanSnapshot.directories && typeof team.scanSnapshot.directories === 'object' ? team.scanSnapshot.directories : {}
+    } : null,
+    contextPlan: team.contextPlan && typeof team.contextPlan === 'object' ? {
+      snapshotId: safeText(team.contextPlan.snapshotId || '', 100),
+      contextWindowTokens: Number(team.contextPlan.contextWindowTokens) || 32768,
+      usableTokens: Number(team.contextPlan.usableTokens) || 0,
+      budgetTokens: Number(team.contextPlan.budgetTokens) || 0,
+      reserveTokens: Number(team.contextPlan.reserveTokens) || 0,
+      rationale: safeText(team.contextPlan.rationale || '', 1200),
+      degraded: team.contextPlan.degraded === true
+    } : null,
+    members: Array.isArray(team.members) ? team.members.map(normalizeMember).filter(Boolean).slice(0, 9) : [],
+    tasks: Array.isArray(team.tasks) ? team.tasks.map(normalizeTask).filter(Boolean).slice(0, 100) : [],
+    messages: Array.isArray(team.messages) ? team.messages.map(normalizeMessage).filter(Boolean).slice(-500) : [],
+    decisions: Array.isArray(team.decisions) ? team.decisions.map(value => safeText(value, 1200)).slice(-100) : [],
+    createdAt: Number(team.createdAt) || Date.now(),
+    updatedAt: Number(team.updatedAt) || Date.now()
+  };
+}
+
+export function loadThunderStore(workspaceRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(getThunderStoreFile(workspaceRoot), 'utf8'));
+    if (![1, STORE_VERSION].includes(parsed?.version) || !Array.isArray(parsed.teams)) return emptyStore(workspaceRoot);
+    return { ...emptyStore(workspaceRoot), teams: parsed.teams.map(normalizeTeam).filter(Boolean) };
+  } catch {
+    return emptyStore(workspaceRoot);
+  }
+}
+
+export function saveThunderStore(workspaceRoot, store) {
+  const normalized = {
+    ...emptyStore(workspaceRoot),
+    teams: (store.teams || []).map(normalizeTeam).filter(Boolean).slice(-50)
+  };
+  atomicWrite(getThunderStoreFile(workspaceRoot), normalized);
+  return normalized;
+}
+
+function roleMember(role, index = 1) {
+  const labels = {
+    pm: 'PM', techLead: 'Tech Lead', frontend: 'Frontend', backend: 'Backend', qa: 'QA',
+    designer: 'Product Design', devops: 'DevOps/SRE', securityData: 'Security/Data'
+  };
+  return normalizeMember({
+    id: `${role}-${index}`,
+    role,
+    name: index > 1 ? `${labels[role]} ${index}` : labels[role],
+    status: 'queued'
+  });
+}
+
+export function proposeThunderResources(request, { performanceApproved = false } = {}) {
+  const text = String(request || '');
+  const complex = /(?:架构|迁移|重构|全栈|性能|安全|部署|数据库|跨平台|architecture|migration|refactor|full.?stack|performance|security|deploy|database)/i.test(text);
+  const frontend = /(?:前端|界面|UI|UX|网页|组件|样式|terminal|renderer|frontend|react|vue|css)/i.test(text);
+  const backend = /(?:后端|API|数据库|服务|server|backend|database|auth|接口)/i.test(text);
+  const design = /(?:设计|排版|交互|视觉|样式|UI|UX|美观|design|layout|style|accessibility)/i.test(text);
+  const devops = /(?:部署|CI|CD|容器|监控|云|deploy|docker|pipeline|monitor|cloud)/i.test(text);
+  const security = /(?:安全|凭据|权限|隐私|数据分析|机器学习|security|credential|privacy|machine learning)/i.test(text);
+  const tier = complex && performanceApproved ? 'performance' : 'balanced';
+  const limit = THUNDER_TIERS[tier];
+  const members = [roleMember('pm'), roleMember('techLead')];
+  if (frontend || (!backend && !devops)) members.push(roleMember('frontend'));
+  if (backend || complex) members.push(roleMember('backend'));
+  if (complex && frontend && backend) members.push(roleMember('backend', 2));
+  if (design) members.push(roleMember('designer'));
+  if (devops) members.push(roleMember('devops'));
+  if (security) members.push(roleMember('securityData'));
+  if (complex || /(?:测试|质量|bug|修复|test|quality|fix)/i.test(text)) members.push(roleMember('qa'));
+  const unique = [];
+  for (const member of members) {
+    if (unique.length >= limit.maxMembers) break;
+    if (!unique.some(item => item.id === member.id)) unique.push(member);
+  }
+  return {
+    tier,
+    concurrency: Math.min(limit.concurrency, unique.length),
+    validationDepth: limit.validationDepth,
+    rationale: complex
+      ? 'Cross-cutting or high-risk work needs leadership, implementation, and independent review.'
+      : 'A compact office team is sufficient; unrelated specialists are removed.',
+    performanceRecommended: complex,
+    approved: false,
+    approvedAt: null,
+    members: unique
+  };
+}
+
+export function createThunderTeam(workspaceRoot, { request, planName, resourceProposal, planId = null, scanSnapshot = null, contextPlan = null }) {
+  const store = loadThunderStore(workspaceRoot);
+  const now = Date.now();
+  const team = normalizeTeam({
+    id: crypto.randomUUID(), planId, planName, request, phase: 'staffing', resourceProposal, scanSnapshot, contextPlan,
+    members: resourceProposal.members, tasks: [], messages: [], decisions: [], createdAt: now, updatedAt: now
+  });
+  store.teams.push(team);
+  saveThunderStore(workspaceRoot, store);
+  return team;
+}
+
+export function getThunderTeam(workspaceRoot, teamId) {
+  return loadThunderStore(workspaceRoot).teams.find(team => team.id === teamId) || null;
+}
+
+export function findThunderTeamForPlan(workspaceRoot, planId) {
+  return loadThunderStore(workspaceRoot).teams
+    .filter(team => team.planId === planId)
+    .sort((a, b) => b.updatedAt - a.updatedAt)[0] || null;
+}
+
+export function updateThunderTeam(workspaceRoot, teamId, updates) {
+  const store = loadThunderStore(workspaceRoot);
+  const index = store.teams.findIndex(team => team.id === teamId);
+  if (index === -1) return null;
+  const next = normalizeTeam({ ...store.teams[index], ...updates, id: teamId, updatedAt: Date.now() });
+  store.teams[index] = next;
+  saveThunderStore(workspaceRoot, store);
+  return next;
+}
+
+export function updateThunderMember(workspaceRoot, teamId, memberId, updates) {
+  const team = getThunderTeam(workspaceRoot, teamId);
+  if (!team) return null;
+  team.members = team.members.map(member => member.id === memberId ? normalizeMember({ ...member, ...updates, id: member.id }) : member);
+  return updateThunderTeam(workspaceRoot, teamId, { members: team.members });
+}
+
+export function upsertThunderTask(workspaceRoot, teamId, task) {
+  const team = getThunderTeam(workspaceRoot, teamId);
+  if (!team) return null;
+  const normalized = normalizeTask(task);
+  const index = team.tasks.findIndex(item => item.id === normalized.id);
+  if (index === -1) team.tasks.push(normalized); else team.tasks[index] = normalized;
+  return updateThunderTeam(workspaceRoot, teamId, { tasks: team.tasks });
+}
+
+export function addThunderMessage(workspaceRoot, teamId, message) {
+  const team = getThunderTeam(workspaceRoot, teamId);
+  if (!team) return null;
+  const normalized = normalizeMessage(message);
+  if (!normalized) throw new Error('Invalid Thunder message.');
+  team.messages.push(normalized);
+  return updateThunderTeam(workspaceRoot, teamId, { messages: team.messages });
+}
+
+export function approveThunderResources(workspaceRoot, teamId) {
+  const team = getThunderTeam(workspaceRoot, teamId);
+  if (!team) return null;
+  return updateThunderTeam(workspaceRoot, teamId, {
+    phase: 'planning',
+    resourceProposal: { ...team.resourceProposal, approved: true, approvedAt: Date.now() }
+  });
+}
+
+export function thunderSummary(workspaceRoot) {
+  const teams = loadThunderStore(workspaceRoot).teams;
+  const active = teams.filter(team => !['completed', 'cancelled'].includes(team.phase));
+  return { total: teams.length, active: active.length, latest: active.sort((a, b) => b.updatedAt - a.updatedAt)[0] || null };
+}