create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/lib/session-standup.js

@@ -0,0 +1,409 @@
+'use strict';
+
+const { normalizeAttention } = require('./standup-attention');
+
+const LANE_DEFS = [
+  {
+    id: 'needs_user',
+    title: 'Needs User',
+    description: 'Approvals, questions, blockers, or failed work that need operator attention.',
+  },
+  {
+    id: 'ready_review',
+    title: 'Ready Review',
+    description: 'Sessions with reviewable work, finished changes, or worktree cleanup to handle.',
+  },
+  {
+    id: 'running',
+    title: 'Running',
+    description: 'Active sessions that are still producing work.',
+  },
+  {
+    id: 'continue_later',
+    title: 'Continue Later',
+    description: 'Idle sessions worth preserving for context reuse.',
+  },
+];
+
+const LANE_ORDER = new Map(LANE_DEFS.map((lane, index) => [lane.id, index]));
+const STALE_AFTER_MS = 30 * 60 * 1000;
+
+function truncateText(value, max = 180) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1)).trim()}...`;
+}
+
+function valueText(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'object') {
+    return value.text || value.summary || value.phase || value.next || '';
+  }
+  return String(value);
+}
+
+function progressText(progress) {
+  if (!progress) return '';
+  if (typeof progress === 'string') return progress;
+  if (typeof progress === 'object') {
+    return progress.summary || progress.next || progress.phase || '';
+  }
+  return String(progress);
+}
+
+function toMs(value) {
+  if (!value) return 0;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function toIso(value) {
+  const ms = toMs(value);
+  return ms ? new Date(ms).toISOString() : null;
+}
+
+function ageLabel(now, value) {
+  const ms = toMs(value);
+  if (!ms) return '';
+  const age = Math.max(0, now - ms);
+  if (age < 60 * 1000) return 'just now';
+  const minutes = Math.round(age / (60 * 1000));
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+
+function normalizeStatus(status) {
+  const text = String(status || '').toLowerCase();
+  if (!text) return 'unknown';
+  if (text === 'busy') return 'running';
+  if (text === 'waiting_input') return 'waiting_input';
+  if (text === 'waiting-for-input') return 'waiting';
+  if (['running', 'waiting', 'idle', 'exited', 'unknown'].includes(text)) return text;
+  return text;
+}
+
+function addIndexEntries(map, item) {
+  if (!item || typeof item !== 'object') return;
+  for (const key of ['id', 'sessionId', 'ctmSessionId', 'agentSessionId', 'claudeSessionId']) {
+    const value = item[key];
+    if (value) map.set(String(value), item);
+  }
+}
+
+function buildIndex(items) {
+  const map = new Map();
+  for (const item of items || []) addIndexEntries(map, item);
+  return map;
+}
+
+function lookupForSession(index, session) {
+  if (!index || !session) return null;
+  const ids = [
+    session.id,
+    session.sessionId,
+    session.ctmSessionId,
+    session.agentSessionId,
+    session.claudeSessionId,
+  ];
+  for (const id of ids) {
+    if (id && index.has(String(id))) return index.get(String(id));
+  }
+  return null;
+}
+
+function statusForSession(session, status, summary) {
+  if (session?.waitingForInput) return 'waiting_input';
+  const candidates = [
+    session?.standupStatus,
+    session?.liveStatus,
+    session?.computedStatus,
+    session?.state,
+    status?.captureStatus,
+    status?.status,
+    summary?.captureStatus,
+    summary?.status,
+    session?.serverState,
+    session?.status,
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeStatus(candidate);
+    if (normalized && normalized !== 'unknown') return normalized;
+  }
+  return 'unknown';
+}
+
+function isWalleSession(session) {
+  return session?.type === 'walle' || session?.agentType === 'walle' || session?.agent === 'walle';
+}
+
+function standupStatusForSession(session, status, summary) {
+  const normalized = statusForSession(session, status, summary);
+  // A quiet Wall-E chat is available for the next message, not blocked on
+  // operator input. Older live projections used "waiting" for that idle state.
+  if (normalized === 'waiting' && isWalleSession(session) && !session?.waitingForInput) return 'idle';
+  return normalized;
+}
+
+function worktreeEvidence(worktree) {
+  if (!worktree) return '';
+  const dirtyFiles = Number(worktree.dirtyFiles || 0);
+  const unmergedCommits = Number(worktree.unmergedCommits || 0);
+  const parts = [];
+  if (dirtyFiles) parts.push(`${dirtyFiles} dirty`);
+  if (unmergedCommits) parts.push(`${unmergedCommits} unmerged`);
+  if (!parts.length && worktree.summary) parts.push(worktree.summary);
+  return parts.length ? `worktree ${parts.join(', ')}` : '';
+}
+
+function hasReviewableWork(session, summaryText, progress) {
+  const worktree = session?.worktreeStatus || session?.worktree || null;
+  if (worktree) {
+    if (worktree.needsAttention) return true;
+    if (Number(worktree.dirtyFiles || 0) > 0) return true;
+    if (Number(worktree.unmergedCommits || 0) > 0) return true;
+  }
+  const text = `${summaryText || ''} ${progressText(progress)}`.toLowerCase();
+  return /\b(done|completed|complete|verified|passed|ready for review|all work done)\b/.test(text);
+}
+
+function hasFailureSignal(summaryText, progress) {
+  const text = `${summaryText || ''} ${progressText(progress)}`.toLowerCase();
+  return /\b(cannot proceed|blocked|blocker|stuck|permission denied|fatal|panic|segmentation fault|uncaught|unhandled exception|traceback|command failed|build failed|tests? failed|npm err!)\b/.test(text);
+}
+
+function attentionForSession(session, summary) {
+  return normalizeAttention(summary?.attention || session?.attention || null);
+}
+
+function prependEvidence(evidence, items) {
+  const out = [];
+  for (const item of items || []) {
+    const text = truncateText(item, 90);
+    if (text && !out.some(existing => existing.toLowerCase() === text.toLowerCase())) out.push(text);
+  }
+  for (const item of evidence || []) {
+    const text = truncateText(item, 90);
+    if (text && !out.some(existing => existing.toLowerCase() === text.toLowerCase())) out.push(text);
+  }
+  return out.slice(0, 5);
+}
+
+function baseEvidence({ session, status, summary, now, intentText, progress }) {
+  const evidence = [];
+  if (status === 'waiting_input') evidence.push('waiting input');
+  else if (status === 'waiting') evidence.push('waiting');
+  else if (status === 'running') evidence.push('running');
+  const branch = session?.branch || session?.gitBranch || session?.worktreeStatus?.branch || '';
+  if (branch) evidence.push(`branch ${branch}`);
+  const wtEvidence = worktreeEvidence(session?.worktreeStatus || session?.worktree);
+  if (wtEvidence) evidence.push(wtEvidence);
+  const age = ageLabel(now, latestActivity(session, summary));
+  if (age) evidence.push(`last activity ${age}`);
+  if (intentText && summary?.intent?.source === 'prompt-fallback') {
+    evidence.push(`prompt: ${truncateText(intentText, 80)}`);
+  }
+  const progressPhase = progress && typeof progress === 'object' ? progress.phase : '';
+  if (progressPhase && !['unknown', status].includes(String(progressPhase))) {
+    evidence.push(`phase ${progressPhase}`);
+  }
+  return evidence.slice(0, 5);
+}
+
+function latestActivity(session, summary) {
+  const values = [
+    summary?.lastActivity,
+    summary?.progress?.updatedAt,
+    summary?.intent?.updatedAt,
+    session?.lastPtyActivity,
+    session?.lastActivity,
+    session?.modifiedAt,
+    session?.fileModifiedAt,
+    session?.createdAt,
+  ];
+  let latest = 0;
+  for (const value of values) {
+    const ms = toMs(value);
+    if (ms > latest) latest = ms;
+  }
+  return latest;
+}
+
+function classifySessionStandup(session, signals = {}, now = Date.now()) {
+  const summary = signals.summary || {};
+  const streamStatus = signals.status || {};
+  const status = standupStatusForSession(session, streamStatus, summary);
+  const intent = summary.intent || summary.summary || summary.displayPrompt || summary.lastPrompt || session?.label || '';
+  const intentString = truncateText(valueText(intent), 160);
+  const progress = summary.progress || '';
+  const progressString = truncateText(progressText(progress), 180);
+  const summaryText = valueText(summary.summary) || intentString;
+  const lastActivityMs = latestActivity(session, summary);
+  const ageMs = lastActivityMs ? Math.max(0, now - lastActivityMs) : null;
+  const waitingReason = session?.waitingReason || streamStatus?.reason || summary?.statusEvidence?.[0] || '';
+  const reviewable = hasReviewableWork(session, summaryText, progress);
+  const attention = attentionForSession(session, summary);
+  const hasStructuredAttention = !!(summary?.attention || session?.attention);
+  const attentionSeverity = attention?.severity || 'none';
+  const failed = attentionSeverity === 'failure'
+    || (!hasStructuredAttention && hasFailureSignal(summaryText, progress));
+  const warning = attentionSeverity === 'warning';
+  const isWaiting = status === 'waiting_input' || status === 'waiting';
+  const isRunning = status === 'running' || status === 'busy';
+
+  let lane = 'continue_later';
+  let actionKind = 'resume';
+  let actionLabel = 'Continue';
+  let recommendation = 'Session is idle; reuse this context when you have the next instruction.';
+  let confidence = 'medium';
+
+  if (isWaiting) {
+    lane = 'needs_user';
+    actionKind = status === 'waiting_input' || /approval|choice|input/i.test(waitingReason)
+      ? 'approval_needed'
+      : 'needs_input';
+    actionLabel = 'Respond';
+    recommendation = actionKind === 'approval_needed'
+      ? 'Approval or input is waiting in the terminal.'
+      : 'The session appears to need user input before it can continue.';
+    confidence = 'high';
+  } else if (isRunning) {
+    lane = 'running';
+    actionKind = 'watch';
+    actionLabel = 'Open';
+    recommendation = 'Work is still running; no operator action is needed yet.';
+    confidence = status === 'running' ? 'high' : 'medium';
+  } else if (failed) {
+    lane = 'needs_user';
+    actionKind = 'investigate';
+    actionLabel = 'Inspect';
+    recommendation = attention?.recommendation || 'A current blocker or failure appears to need attention.';
+    confidence = attention?.confidence || 'medium';
+  } else if (warning) {
+    lane = 'needs_user';
+    actionKind = 'warning';
+    actionLabel = 'Review';
+    recommendation = attention?.recommendation || 'A current warning appears to need attention.';
+    confidence = attention?.confidence || 'medium';
+  } else if (reviewable) {
+    lane = 'ready_review';
+    actionKind = 'review';
+    actionLabel = 'Review';
+    recommendation = 'Review the session output or finish the worktree changes.';
+    confidence = session?.worktreeStatus ? 'high' : 'medium';
+  } else if (ageMs != null && ageMs > STALE_AFTER_MS) {
+    lane = 'continue_later';
+    actionKind = 'resume';
+    actionLabel = 'Resume';
+    recommendation = 'Session is quiet; resume it only if this preserved context is still useful.';
+    confidence = 'medium';
+  }
+
+  let evidence = baseEvidence({ session, status, summary, now, intentText: intentString, progress });
+  if ((failed || warning) && attention?.evidence?.length) {
+    evidence = prependEvidence(evidence, attention.evidence);
+  }
+  if (failed && !isRunning && !evidence.some(item => /failed|blocked|blocker|error|failure/i.test(item))) {
+    evidence.unshift('possible blocker');
+  }
+  if (warning && !isRunning && !evidence.some(item => /warn|caution|risk|attention/i.test(item))) {
+    evidence.unshift('warning');
+  }
+
+  const title = truncateText(
+    session?.label || summary?.displayPrompt || summary?.lastPrompt || intentString || session?.id || 'Session',
+    90
+  );
+
+  return {
+    id: session?.id || session?.sessionId || '',
+    agentSessionId: session?.agentSessionId || session?.claudeSessionId || null,
+    title,
+    agent: session?.agentType || session?.agent || session?.type || 'session',
+    provider: session?.model_provider || session?.provider || '',
+    model: session?.model_id || session?.model || '',
+    cwd: session?.cwd || '',
+    project: session?.project || session?.cwd || '',
+    branch: session?.branch || session?.gitBranch || session?.worktreeStatus?.branch || '',
+    status,
+    lane,
+    actionKind,
+    actionLabel,
+    recommendation,
+    confidence,
+    evidence,
+    attention: attention && attention.severity !== 'none' ? attention : null,
+    intent: intentString,
+    progress: progressString,
+    lastActivity: toIso(lastActivityMs),
+    ageMs,
+    worktree: session?.worktreeStatus || session?.worktree || null,
+    capabilities: session?.agentCapabilities || session?.capabilities || {},
+    priority: LANE_ORDER.get(lane) ?? 99,
+  };
+}
+
+function sortCards(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  const actionOrder = {
+    approval_needed: 0,
+    needs_input: 1,
+    investigate: 2,
+    warning: 3,
+    review: 4,
+    watch: 5,
+    resume: 6,
+    archive: 7,
+  };
+  const ao = actionOrder[a.actionKind] ?? 99;
+  const bo = actionOrder[b.actionKind] ?? 99;
+  if (ao !== bo) return ao - bo;
+  return (toMs(b.lastActivity) || 0) - (toMs(a.lastActivity) || 0);
+}
+
+function buildSessionStandupSnapshot({ sessions = [], summaries = [], statuses = [], now = Date.now() } = {}) {
+  const summaryIndex = buildIndex(summaries);
+  const statusIndex = buildIndex(statuses);
+  const cards = sessions
+    .map(session => classifySessionStandup(session, {
+      summary: lookupForSession(summaryIndex, session),
+      status: lookupForSession(statusIndex, session),
+    }, now))
+    .filter(card => card.id)
+    .sort(sortCards);
+
+  const counts = { total: cards.length };
+  for (const lane of LANE_DEFS) counts[lane.id] = 0;
+  for (const card of cards) counts[card.lane] = (counts[card.lane] || 0) + 1;
+
+  const lanes = LANE_DEFS.map(lane => ({
+    ...lane,
+    count: counts[lane.id] || 0,
+    sessions: cards.filter(card => card.lane === lane.id),
+  }));
+
+  return {
+    generatedAt: new Date(now).toISOString(),
+    counts,
+    lanes,
+    sessions: cards,
+  };
+}
+
+module.exports = {
+  LANE_DEFS,
+  classifySessionStandup,
+  buildSessionStandupSnapshot,
+  _private: {
+    normalizeStatus,
+    standupStatusForSession,
+    latestActivity,
+    truncateText,
+    hasFailureSignal,
+  },
+};