create-agdf 0.20.2 → 0.31.0

package/generated/plugins/agdf/companion/notice.mjs

@@ -0,0 +1,92 @@
+// Feedback outside the pane (SDD-05 to SDD-07, AC-004 to AC-006): the shown run as the toast and the
+// status line see it, the transition detector, their texts and the generated chime. Judged on the
+// run-derived state, never on the turn overlay, so a turn neither flips the status line nor raises a
+// toast. Host-independent; the adapter shows the results.
+
+import { assignRun } from './assignment.mjs';
+import { gateTitle, label } from './localization.mjs';
+import { runState } from './state.mjs';
+
+const NOTICE_MOODS = new Set(['wartet', 'blockiert']);
+
+// What the status line and the detector observe: { kind: 'run', runId, state } with the run-derived
+// state, { kind: 'unreadable' } or { kind: 'idle' } (nothing read yet, no control, no shown run).
+// mention: the chat's named run (chat-run navigation SDD-06); browsing never changes what is observed.
+export function observedRun({ snapshot, sessionStartedAt, selection = null, mention = null }) {
+  if (!snapshot) return { kind: 'idle' };
+  if (snapshot.status === 'failed' || snapshot.status === 'unavailable') return { kind: 'unreadable' };
+  if (snapshot.status !== 'ok') return { kind: 'idle' };
+  const { run } = assignRun({ runs: snapshot.runs, sessionStartedAt, selection, mention });
+  if (!run) return selection && snapshot.unreadable.some(item => item.id === selection) ? { kind: 'unreadable' } : { kind: 'idle' };
+  const figure = runState(run);
+  // The blocking text arrives localized in the run view; the signature keeps the code.
+  return { kind: 'run', runId: run.id, state: { ...figure, reason: { ...figure.reason, decisionText: run.blockingText || undefined } } };
+}
+
+const signature = ({ mood, reason }) => [mood, reason.key, reason.gate ?? '', reason.decision ?? ''].join('|');
+
+// previous: the last observation { runId, signature } or null. A notice is due only when the same
+// run's state changed and is now wartet or blockiert; the first observation of a run is a baseline.
+// An unreadable state keeps the last observation, so a read in between announces nothing twice.
+export function observeNotice(previous, observed) {
+  if (observed.kind === 'unreadable') return { observation: previous, notice: null };
+  if (observed.kind !== 'run') return { observation: null, notice: null };
+  const observation = { runId: observed.runId, signature: signature(observed.state) };
+  const changed = previous?.runId === observed.runId && previous.signature !== observation.signature;
+  return { observation, notice: changed && NOTICE_MOODS.has(observed.state.mood) ? observed.state : null };
+}
+
+// The toast for a notice, e.g. "Wartet auf Freigabe: Qualitätssicherung". A notice always concerns
+// the run the status line follows, so it names no run (owner request of 2026-11-06, T-013).
+export function noticeText(state, { registry, labels, locale }) {
+  const t = (path, params) => label(labels, locale, path, params);
+  const params = { gate: gateTitle(registry, locale, state.reason.gate) };
+  if (state.reason.decision) params.decision = state.reason.decisionText ?? state.reason.decision;
+  return t(`notices.${state.reason.key}`, params);
+}
+
+// The status line, e.g. "AGDF · QA · wartet"; a completed run names no gate.
+export function statusText(observed, { labels, locale }) {
+  const t = path => label(labels, locale, path);
+  if (observed.kind === 'unreadable') return `AGDF · ${t('statusStates.unreadable')}`;
+  if (observed.kind !== 'run') return `AGDF · ${t('statusStates.bereit')}`;
+  const { mood, reason } = observed.state;
+  return mood === 'fertig' || !reason.gate ? `AGDF · ${t(`statusStates.${mood}`)}` : `AGDF · ${reason.gate} · ${t(`statusStates.${mood}`)}`;
+}
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function base64(bytes) {
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const n = (bytes[i] << 16) | ((bytes[i + 1] ?? 0) << 8) | (bytes[i + 2] ?? 0);
+    out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63]
+      + (i + 1 < bytes.length ? ALPHABET[(n >> 6) & 63] : '=') + (i + 2 < bytes.length ? ALPHABET[n & 63] : '=');
+  }
+  return out;
+}
+
+// A soft two-note chime (0.3 s) as 8 kHz, 8-bit unsigned mono PCM in a RIFF/WAVE container, so no
+// audio file ships in the plugin. Hosts without a player skip it (SDD-06).
+export const CHIME = Object.freeze({ rate: 8000, notes: Object.freeze([[880, 0.12], [1320, 0.18]]), gain: 0.35 });
+let chime = null;
+export function chimeClip() {
+  if (chime) return chime;
+  const samples = [];
+  for (const [frequency, seconds] of CHIME.notes) {
+    const count = Math.round(CHIME.rate * seconds);
+    for (let i = 0; i < count; i += 1) {
+      const envelope = Math.min(1, i / 80, (count - i) / 400);
+      samples.push(Math.round(128 + 60 * envelope * Math.sin((2 * Math.PI * frequency * i) / CHIME.rate)));
+    }
+  }
+  const bytes = new Uint8Array(44 + samples.length);
+  const view = new DataView(bytes.buffer);
+  const ascii = (offset, text) => { for (let i = 0; i < text.length; i += 1) bytes[offset + i] = text.charCodeAt(i); };
+  ascii(0, 'RIFF'); view.setUint32(4, 36 + samples.length, true); ascii(8, 'WAVE');
+  ascii(12, 'fmt '); view.setUint32(16, 16, true); view.setUint16(20, 1, true); view.setUint16(22, 1, true);
+  view.setUint32(24, CHIME.rate, true); view.setUint32(28, CHIME.rate, true); view.setUint16(32, 1, true); view.setUint16(34, 8, true);
+  ascii(36, 'data'); view.setUint32(40, samples.length, true);
+  bytes.set(samples, 44);
+  chime = Object.freeze({ base64: base64(bytes), mime: 'audio/wav' });
+  return chime;
+}

package/generated/plugins/agdf/companion/persistence.mjs

@@ -0,0 +1,36 @@
+// The persisted user choices (SDD-07; follow-up SDD-09): one JSON file in the AGDF plugin data
+// directory, which `claude plugin uninstall` removes; never `$.store`, which Claude keeps after
+// uninstall (T-001). Toasts default on and their sound off; a state file without these fields, as
+// the first companion version wrote it, reads with those defaults. Host-independent: the adapter
+// supplies the environment values and file access.
+
+export const STATE_FILE = 'companion-state.json';
+const PLUGIN_ID = 'agdf@agdf';
+const DEFAULT_STATE = Object.freeze({ enabled: false, still: false, notice: true, sound: false, selections: Object.freeze({}) });
+
+// Mirrors claudePluginDataRoot (packages/cli/lib/mcp-lifecycle/plugin-runtime.js): the plugin id with
+// every character outside [A-Za-z0-9_-] replaced by "-" below <config dir>/plugins/data.
+export function pluginDataDir({ configDir, userProfile, home }, pluginId = PLUGIN_ID) {
+  const base = configDir || (userProfile || home ? `${userProfile || home}/.claude` : '');
+  return base ? `${base.replace(/[\\/]+$/u, '')}/plugins/data/${pluginId.replace(/[^A-Za-z0-9_-]/gu, '-')}` : null;
+}
+
+// Invalid or foreign content reads as fresh, mutable defaults; selections map project roots to run ids.
+export function parseCompanionState(text) {
+  try {
+    const value = JSON.parse(text);
+    if (!value || value.schema_version !== 1) return defaultCompanionState();
+    const selections = {};
+    for (const [root, runId] of Object.entries(value.selections ?? {})) {
+      if (typeof root === 'string' && typeof runId === 'string' && /^[A-Za-z0-9._-]{1,200}$/u.test(runId)) selections[root] = runId;
+    }
+    return { enabled: value.enabled === true, still: value.still === true, notice: value.notice !== false, sound: value.sound === true, selections };
+  } catch {
+    return defaultCompanionState();
+  }
+}
+
+export const serializeCompanionState = ({ enabled, still, notice, sound, selections }) =>
+  `${JSON.stringify({ schema_version: 1, enabled: Boolean(enabled), still: Boolean(still), notice: notice !== false, sound: Boolean(sound), selections: { ...selections } }, null, 2)}\n`;
+
+export const defaultCompanionState = () => ({ ...DEFAULT_STATE, selections: {} });