@dotdrelle/wiki-manager 0.6.17

package/src/core/activity.js

@@ -0,0 +1,236 @@
+export function parseJsonText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function basename(value) {
+  return String(value ?? '').split('/').filter(Boolean).pop() ?? '';
+}
+
+function terminalStatus(status) {
+  return ['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'error'].includes(String(status ?? '').toLowerCase());
+}
+
+function activityKey(activity) {
+  const id = activity?.id ?? activity?.jobId ?? activity?.job_id;
+  const source = activity?.source ?? activity?.agent ?? activity?.poll?.server ?? 'mcp';
+  return `${source}:${id ?? activity?.kind ?? activity?.label ?? 'activity'}`;
+}
+
+function normalizePlanSteps(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) return null;
+  return steps.map((s, i) => ({
+    id: s != null && s.id != null ? String(s.id) : String(i + 1),
+    label: s != null ? String(s.label ?? s.description ?? s.name ?? s.id ?? (i + 1)) : String(i + 1),
+  }));
+}
+
+function normalizePoll(poll) {
+  if (!poll || typeof poll !== 'object') return null;
+  const server = poll.server ?? poll.source ?? poll.agent;
+  const tool = poll.tool ?? poll.name;
+  if (!server || !tool) return null;
+  return {
+    server: String(server),
+    tool: String(tool),
+    args: poll.args && typeof poll.args === 'object' ? poll.args : {},
+    intervalMs: Number.isFinite(Number(poll.intervalMs)) ? Math.max(1000, Number(poll.intervalMs)) : 2500,
+  };
+}
+
+export function normalizeActivity(activity, fallback = {}) {
+  if (!activity || typeof activity !== 'object') return null;
+  const id = activity.id ?? activity.jobId ?? activity.job_id ?? fallback.id ?? fallback.jobId ?? null;
+  const source = activity.source ?? activity.agent ?? fallback.source ?? activity.poll?.server ?? 'mcp';
+  const kind = activity.kind ?? activity.type ?? fallback.kind ?? 'job';
+  const status = activity.status ?? activity.state ?? fallback.status ?? 'running';
+  const progress = activity.progress && typeof activity.progress === 'object' ? activity.progress : {};
+  const step = progress.step ?? progress.phase ?? progress.currentStep ?? activity.step ?? activity.currentStep ?? null;
+  const percent = Number.isFinite(Number(progress.percent ?? activity.percent))
+    ? Number(progress.percent ?? activity.percent)
+    : null;
+  const stepId = progress.stepId != null ? String(progress.stepId) : null;
+  const stepIndex = Number.isFinite(Number(progress.stepIndex)) ? Number(progress.stepIndex) : null;
+  const stepTotal = Number.isFinite(Number(progress.stepTotal)) ? Number(progress.stepTotal) : null;
+  const rawPlan = activity.plan && typeof activity.plan === 'object' ? activity.plan : null;
+  const planSteps = normalizePlanSteps(rawPlan?.steps);
+  const label = activity.label ?? [
+    source,
+    kind,
+    step,
+  ].filter(Boolean).join(' ');
+  const normalized = {
+    key: null,
+    id,
+    source: String(source),
+    kind: String(kind),
+    label: String(label || `${source} ${kind}`),
+    status: String(status),
+    progress: {
+      ...progress,
+      ...(step ? { step: String(step) } : {}),
+      ...(percent !== null ? { percent } : {}),
+      ...(stepId !== null ? { stepId } : {}),
+      ...(stepIndex !== null ? { stepIndex } : {}),
+      ...(stepTotal !== null ? { stepTotal } : {}),
+    },
+    plan: planSteps ? { steps: planSteps } : null,
+    poll: normalizePoll(activity.poll ?? fallback.poll),
+    startedAt: activity.startedAt ?? fallback.startedAt ?? null,
+    updatedAt: activity.updatedAt ?? new Date().toISOString(),
+    error: activity.error ?? null,
+    terminal: Boolean(activity.terminal ?? terminalStatus(status)),
+  };
+  normalized.key = activityKey(normalized);
+  return normalized;
+}
+
+function productionActivityFromPayload(payload) {
+  const progress = payload?.progress;
+  const job = payload?.job;
+  const jobId = payload?.jobId ?? job?.jobId;
+  if (!progress && !job && !jobId) return null;
+  const status = job?.status ?? payload?.status ?? progress?.status ?? 'running';
+  const percent = Number.isFinite(Number(progress?.percent)) ? Number(progress.percent) : null;
+  const sourceCount = Number(progress?.sourceCount);
+  const sourceIndex = Number(progress?.sourceIndex);
+  const sourceDoneCount = Number(progress?.sourceDoneCount);
+  const fileProgress = Number.isFinite(sourceCount) && sourceCount > 0
+    ? Number.isFinite(sourceIndex)
+      ? `file ${Math.min(sourceCount, sourceIndex + 1)}/${sourceCount}`
+      : Number.isFinite(sourceDoneCount)
+        ? `files ${Math.min(sourceCount, sourceDoneCount)}/${sourceCount}`
+        : null
+    : null;
+  const batchProgress = progress?.batchCount
+    ? `batch ${Number(progress.batchIndex ?? 0) + 1}/${progress.batchCount}`
+    : null;
+  const progressDetail = batchProgress && /^batch\s+\d+\/\d+/i.test(String(progress?.detail ?? ''))
+    ? null
+    : progress?.detail;
+  const step = progress?.phase ?? progress?.currentStep ?? job?.type ?? 'production';
+  const detail = [
+    step,
+    status,
+    percent !== null ? `${Math.round(percent)}%` : null,
+    fileProgress,
+    batchProgress,
+    progress?.source ? basename(progress.source) : null,
+    progress?.template ? basename(progress.template) : null,
+    progress?.deliverable ? basename(progress.deliverable) : null,
+    progressDetail,
+    progress?.lastEvent ? `last ${progress.lastEvent}` : null,
+  ].filter(Boolean).join(' · ');
+  return normalizeActivity({
+    id: jobId,
+    source: 'production',
+    kind: job?.type ?? payload?.type ?? progress?.phase ?? progress?.currentStep ?? 'job',
+    label: detail ? `Production: ${detail}` : `Production: ${status}`,
+    status,
+    progress: {
+      ...(progress ?? {}),
+      ...(percent !== null ? { percent } : {}),
+      step,
+    },
+    poll: jobId ? {
+      server: 'production',
+      tool: 'production_job_status',
+      args: { jobId },
+      intervalMs: 2500,
+    } : null,
+    error: job?.error ?? payload?.error ?? null,
+  });
+}
+
+export function extractActivity(payload, context = {}) {
+  if (!payload || typeof payload !== 'object') return null;
+  if (payload._activity) {
+    return normalizeActivity(payload._activity, { source: context.server });
+  }
+  if (context.server === 'production') {
+    return productionActivityFromPayload(payload);
+  }
+  return null;
+}
+
+export function rememberActivity(session, activity) {
+  const normalized = normalizeActivity(activity);
+  if (!normalized) return null;
+  session.activities ??= {};
+  session.activities[normalized.key] = {
+    ...(session.activities[normalized.key] ?? {}),
+    ...normalized,
+  };
+  if (normalized.source === 'production') {
+    session.productionActivity = {
+      jobId: normalized.id,
+      status: normalized.status,
+      label: normalized.label,
+      terminal: normalized.terminal,
+      updatedAt: normalized.updatedAt,
+    };
+  }
+  return normalized;
+}
+
+export function rememberActivityFromPayload(session, payload, context = {}) {
+  const activity = extractActivity(payload, context);
+  return rememberActivity(session, activity);
+}
+
+export function sessionActivities(session) {
+  return Object.values(session.activities ?? {})
+    .sort((a, b) => String(a.updatedAt ?? '').localeCompare(String(b.updatedAt ?? '')));
+}
+
+export function formatActivityLine(activity) {
+  if (!activity) return '';
+  const percent = Number.isFinite(Number(activity.progress?.percent))
+    ? `${Math.round(Number(activity.progress.percent))}%`
+    : null;
+  const step = activity.progress?.step ?? activity.progress?.phase ?? activity.progress?.currentStep ?? null;
+  const parts = [
+    activity.label,
+    activity.status,
+    step && !String(activity.label).includes(String(step)) ? step : null,
+    percent && !String(activity.label).includes(percent) ? percent : null,
+    activity.error ? `error ${activity.error}` : null,
+  ].filter(Boolean);
+  return parts.join(' · ');
+}
+
+export function formatActivitySummary(source, action, resultText) {
+  const text = String(resultText ?? '').trim();
+  if (!text) return null;
+  const payload = parseJsonText(text);
+  const activity = extractActivity(payload, { server: source, tool: action });
+  if (activity) return formatActivityLine(activity);
+  const jobId = payload?.jobId ?? payload?.job_id ?? payload?.job?.jobId ?? payload?.job?.job_id;
+  const status = payload?.status ?? payload?.job?.status ?? payload?.progress?.status;
+  const detail = payload?.message ?? payload?.detail ?? payload?.progress?.detail;
+  const structured = [status, jobId ? `job ${jobId}` : null, detail].filter(Boolean).join(' · ');
+  if (structured) return `${source}.${action}: ${structured}`;
+
+  const usefulLine = text
+    .split('\n')
+    .map((line) => line.trim())
+    .find((line) => /\b(job|job_id|jobId|status|started|running|done|failed|error|warning|complete|completed|created|indexed)\b/i.test(line))
+    ?? text.split('\n').map((line) => line.trim()).find(Boolean);
+  return usefulLine ? `${source}.${action}: ${usefulLine.slice(0, 120)}` : null;
+}
+
+export function formatActivityError(source, action, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const lines = message
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const cause = lines.find((line) => /cannot connect to the docker daemon/i.test(line))
+    ?? lines.find((line) => /\b(error|failed|cannot|unable|denied|missing|not found)\b/i.test(line))
+    ?? lines.at(-1)
+    ?? message;
+  return `${source}.${action}: error · ${cause.slice(0, 120)}`;
+}

package/src/core/activity.test.js

@@ -0,0 +1,127 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeActivity, extractActivity, rememberActivity, rememberActivityFromPayload } from './activity.js';
+
+test('normalizeActivity: plan.steps preserved with id and label', () => {
+  const a = normalizeActivity({
+    id: 'job-1',
+    source: 'prod',
+    label: 'Test',
+    status: 'running',
+    plan: { steps: [{ id: 'extract', label: 'Extraction' }, { id: 'build', label: 'Build' }] },
+    progress: {},
+  });
+  assert.deepEqual(a.plan.steps, [
+    { id: 'extract', label: 'Extraction' },
+    { id: 'build', label: 'Build' },
+  ]);
+});
+
+test('normalizeActivity: plan null when steps is empty array', () => {
+  const a = normalizeActivity({ id: '1', status: 'running', plan: { steps: [] } });
+  assert.equal(a.plan, null);
+});
+
+test('normalizeActivity: plan null when no plan field', () => {
+  const a = normalizeActivity({ id: '1', status: 'running' });
+  assert.equal(a.plan, null);
+});
+
+test('normalizeActivity: step id falls back to 1-based index when missing', () => {
+  const a = normalizeActivity({
+    id: '1',
+    status: 'running',
+    plan: { steps: [{ label: 'Step A' }, { label: 'Step B' }] },
+  });
+  assert.equal(a.plan.steps[0].id, '1');
+  assert.equal(a.plan.steps[0].label, 'Step A');
+  assert.equal(a.plan.steps[1].id, '2');
+});
+
+test('normalizeActivity: stepId/stepIndex/stepTotal normalized from progress', () => {
+  const a = normalizeActivity({
+    id: '1',
+    status: 'running',
+    progress: { stepId: 'build', stepIndex: 2, stepTotal: 3 },
+  });
+  assert.equal(a.progress.stepId, 'build');
+  assert.equal(a.progress.stepIndex, 2);
+  assert.equal(a.progress.stepTotal, 3);
+});
+
+test('normalizeActivity: stepId/stepIndex absent when not provided', () => {
+  const a = normalizeActivity({ id: '1', status: 'running', progress: {} });
+  assert.equal(a.progress.stepId, undefined);
+  assert.equal(a.progress.stepIndex, undefined);
+});
+
+test('extractActivity: extracts _activity.plan.steps from payload', () => {
+  const payload = {
+    _activity: {
+      id: 'j1',
+      source: 'custom',
+      label: 'Custom job',
+      status: 'running',
+      plan: { steps: [{ id: 's1', label: 'Step 1' }] },
+      progress: { stepId: 's1', stepIndex: 1, stepTotal: 1 },
+    },
+  };
+  const a = extractActivity(payload);
+  assert.equal(a.plan.steps[0].id, 's1');
+  assert.equal(a.progress.stepId, 's1');
+  assert.equal(a.progress.stepIndex, 1);
+  assert.equal(a.progress.stepTotal, 1);
+});
+
+test('extractActivity: documents conversion activity carries plan and percent', () => {
+  const payload = {
+    _activity: {
+      id: 'documents:schema.png',
+      source: 'documents',
+      kind: 'conversion',
+      label: 'Documents: conversion schema.png',
+      status: 'done',
+      progress: { percent: 100, stepId: 'write', stepIndex: 3, stepTotal: 3 },
+      plan: {
+        steps: [
+          { id: 'resolve', label: 'Résoudre le fichier source' },
+          { id: 'convert', label: 'Convertir en Markdown' },
+          { id: 'write', label: 'Écrire le Markdown converti' },
+        ],
+      },
+      terminal: true,
+    },
+  };
+  const activity = extractActivity(payload, { server: 'documents' });
+  assert.equal(activity.source, 'documents');
+  assert.equal(activity.progress.percent, 100);
+  assert.equal(activity.terminal, true);
+  assert.deepEqual(activity.plan.steps.map((step) => step.id), ['resolve', 'convert', 'write']);
+});
+
+test('rememberActivity: returns normalized activity on success', () => {
+  const session = {};
+  const result = rememberActivity(session, { id: '1', status: 'running', source: 'x', kind: 'job' });
+  assert.ok(result);
+  assert.equal(typeof result, 'object');
+  assert.equal(result.status, 'running');
+});
+
+test('rememberActivity: returns null for invalid input', () => {
+  const session = {};
+  assert.equal(rememberActivity(session, null), null);
+  assert.equal(rememberActivity(session, 'bad'), null);
+});
+
+test('rememberActivityFromPayload: returns activity for _activity payload', () => {
+  const session = {};
+  const payload = { _activity: { id: '1', source: 'x', status: 'running' } };
+  const result = rememberActivityFromPayload(session, payload);
+  assert.ok(result);
+  assert.equal(result.source, 'x');
+});
+
+test('rememberActivityFromPayload: returns null for irrelevant payload', () => {
+  const session = {};
+  assert.equal(rememberActivityFromPayload(session, { message: 'ok' }), null);
+});

package/src/core/agentEvents.js

@@ -0,0 +1,238 @@
+import { normalizeActivity } from './activity.js';
+import { syncActivitiesToPlan } from './plan.js';
+
+const SESSION_PROJECTION_EVENTS = new Set([
+  'run_started',
+  'plan_set',
+  'plan_step_updated',
+  'activity_upserted',
+  'run_error',
+]);
+
+export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
+  return {
+    id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+    ts: new Date().toISOString(),
+    type,
+    origin,
+    runId,
+    turnId,
+    payload,
+  };
+}
+
+export function dispatchAgentEvent(session, event) {
+  const normalized = event.id && event.ts ? event : createAgentEvent(event.type, event);
+  const previousPlan = JSON.stringify(session.headlessPlan ?? null);
+  session.agentEvents ??= [];
+  session.agentEvents.push(normalized);
+  session._agentProjectionState ??= createProjectionState();
+  applyEvent(session._agentProjectionState, normalized);
+  session.agentProjection = publicProjection(session._agentProjectionState);
+  if (SESSION_PROJECTION_EVENTS.has(normalized.type)) {
+    applyAgentProjectionToSession(session, session.agentProjection);
+    if (JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
+      session._onPlanUpdate?.();
+    }
+  }
+  return normalized;
+}
+
+export function reduceAgentEvents(events = []) {
+  const state = createProjectionState();
+
+  for (const event of events) {
+    applyEvent(state, event);
+  }
+
+  return publicProjection(state);
+}
+
+function createProjectionState() {
+  return {
+    conversation: [],
+    chain: [],
+    plan: null,
+    activities: {},
+    logs: [],
+    summary: null,
+    status: 'idle',
+  };
+}
+
+function publicProjection(state) {
+  return {
+    conversation: state.conversation.map((message) => ({ ...message })),
+    chain: state.chain.map((step) => ({ ...step })),
+    plan: state.plan ? state.plan.map((step) => ({ ...step })) : null,
+    activities: sortedActivities(state.activities).map((activity) => ({ ...activity })),
+    logs: [...state.logs],
+    summary: state.summary,
+    status: state.status,
+  };
+}
+
+export function applyAgentProjectionToSession(session, projection) {
+  session.headlessPlan = projection.plan ? projection.plan.map((step) => ({ ...step })) : null;
+  session.activities = Object.fromEntries((projection.activities ?? []).map((activity) => [activity.key, { ...activity }]));
+  const production = (projection.activities ?? []).filter((activity) => activity.source === 'production').at(-1);
+  session.productionActivity = production ? {
+    jobId: production.id,
+    status: production.status,
+    label: production.label,
+    terminal: production.terminal,
+    updatedAt: production.updatedAt,
+  } : session.productionActivity ?? null;
+}
+
+function applyEvent(state, event) {
+  switch (event.type) {
+    case 'run_started':
+      state.status = 'running';
+      state.plan = null;
+      state.chain = [];
+      state.activities = {};
+      state.logs = [];
+      state.summary = null;
+      return;
+    case 'user_message':
+      state.conversation.push({ role: 'user', content: String(event.payload?.content ?? '') });
+      return;
+    case 'assistant_message':
+      finalizeAssistantMessage(state, String(event.payload?.content ?? ''));
+      return;
+    case 'assistant_delta':
+      appendAssistantDelta(state, String(event.payload?.delta ?? ''));
+      return;
+    case 'tool_call_started':
+      state.chain.push({
+        type: 'tool',
+        status: 'running',
+        callId: event.payload?.callId ?? null,
+        name: event.payload?.name ?? null,
+        args: event.payload?.args ?? null,
+        summary: event.payload?.summary ?? 'calling...',
+      });
+      return;
+    case 'tool_call_result':
+      finishToolCall(state, event.payload);
+      return;
+    case 'activity_upserted':
+      upsertActivity(state, event.payload?.activity);
+      return;
+    case 'plan_set':
+      state.plan = normalizePlan(event.payload?.steps, event.payload ?? {});
+      return;
+    case 'plan_step_updated':
+      updatePlanStep(state.plan, event.payload ?? {});
+      return;
+    case 'run_summary':
+      state.summary = String(event.payload?.content ?? '');
+      if (state.summary) state.conversation.push({ role: 'assistant', content: state.summary });
+      return;
+    case 'run_done':
+      state.status = 'done';
+      return;
+    case 'run_error':
+      state.status = 'error';
+      state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
+      return;
+    default:
+      return;
+  }
+}
+
+function appendAssistantDelta(state, delta) {
+  if (!delta) return;
+  const last = state.conversation.at(-1);
+  if (last?.role === 'assistant' && last.streaming) {
+    last.content += delta;
+  } else {
+    state.conversation.push({ role: 'assistant', content: delta, streaming: true });
+  }
+}
+
+function finalizeAssistantMessage(state, content) {
+  const last = state.conversation.at(-1);
+  if (last?.role === 'assistant' && last.streaming) {
+    last.content = content || last.content;
+    delete last.streaming;
+    return;
+  }
+  if (content) state.conversation.push({ role: 'assistant', content });
+}
+
+function finishToolCall(state, payload = {}) {
+  const callId = payload.callId ?? null;
+  const existing = callId ? state.chain.find((step) => step.callId === callId) : null;
+  const step = existing ?? {
+    type: 'tool',
+    callId,
+    name: payload.name ?? null,
+  };
+  step.status = payload.ok === false ? 'failed' : 'done';
+  step.result = payload.result ?? null;
+  step.summary = payload.summary ?? step.summary ?? step.status;
+  if (!existing) state.chain.push(step);
+}
+
+function upsertActivity(state, rawActivity) {
+  const activity = normalizeActivity(rawActivity);
+  if (!activity) return;
+  state.activities[activity.key] = {
+    ...(state.activities[activity.key] ?? {}),
+    ...activity,
+  };
+  ensurePlanFromActivityProjection(state, activity);
+  syncActivitiesToPlan(state.plan, sortedActivities(state.activities));
+}
+
+function ensurePlanFromActivityProjection(state, activity) {
+  const actKey = activity.key ?? null;
+  if (state.plan && actKey !== null && state.plan[0]?._activityKey === actKey) return;
+  const steps = activity.plan?.steps;
+  if (Array.isArray(steps) && steps.length > 0) {
+    state.plan = steps.map((step, i) => ({
+      step: i + 1,
+      id: step.id ?? null,
+      description: step.label,
+      status: 'pending',
+      _activityKey: activity.key,
+    }));
+    return;
+  }
+  state.plan = [{
+    step: 1,
+    id: null,
+    description: activity.label,
+    status: 'pending',
+    _activityKey: activity.key,
+  }];
+}
+
+function normalizePlan(steps, payload = {}) {
+  if (!Array.isArray(steps)) return null;
+  return steps.map((raw, i) => {
+    const item = typeof raw === 'string' ? { description: raw } : (raw ?? {});
+    return {
+      step: Number(item.step ?? i + 1),
+      id: item.id ?? null,
+      description: String(item.description ?? item.label ?? item.name ?? `Step ${i + 1}`),
+      status: item.status ?? 'pending',
+      _activityKey: item._activityKey ?? payload.activityKey ?? null,
+    };
+  });
+}
+
+function updatePlanStep(plan, payload) {
+  if (!plan) return;
+  const step = plan.find((item) => item.step === Number(payload.step));
+  if (!step) return;
+  step.status = payload.status === 'failed' ? 'failed' : payload.status === 'running' ? 'running' : 'done';
+  if (payload.activityKey) step.activityKey = payload.activityKey;
+}
+
+function sortedActivities(activities) {
+  return Object.values(activities ?? {})
+    .sort((a, b) => String(a.updatedAt ?? '').localeCompare(String(b.updatedAt ?? '')));
+}