create-agdf 0.20.2 → 0.30.0

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

@@ -0,0 +1,89 @@
+// Localization (SDD-05, AC-005) with the existing AGDF data: the chat language from config.json,
+// gate titles and next-step values from meta/agdf-interaction-locales.json (the registry), and the
+// companion's own labels from companion/locales.json. Mirrors resolveConfiguredChatLanguage
+// (packages/core/lib/resources/context.js) and localizedOperationalValue
+// (packages/core/lib/interaction-presentation.js); parity tests keep them equal.
+
+const TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/u;
+
+export function canonicalLanguageTag(value) {
+  if (typeof value !== 'string' || !TAG.test(value)) return '';
+  try {
+    return Intl.getCanonicalLocales(value)[0]?.toLowerCase() ?? '';
+  } catch {
+    return '';
+  }
+}
+
+// Exact locale, else its base language, else the registry's fallback locale.
+export function resolveLocale(registry, requested) {
+  const tag = canonicalLanguageTag(requested);
+  if (tag && registry.locales[tag]) return tag;
+  const language = tag.split('-')[0];
+  if (language && registry.locales[language]) return language;
+  return registry.fallbackLocale;
+}
+
+// Claude's own `language` setting is free text: a supported language tag (exact or base language)
+// or one of a locale's `languageNames` in the companion's locales.json, compared without case;
+// anything else names no locale (null).
+export function settingLocale(registry, labels, value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) return null;
+  const tag = canonicalLanguageTag(text);
+  if (tag && (registry.locales[tag] || registry.locales[tag.split('-')[0]])) return resolveLocale(registry, tag);
+  const name = text.toLowerCase();
+  const match = Object.entries(labels?.locales ?? {})
+    .find(([locale, pack]) => registry.locales[locale] && (pack.languageNames ?? []).some(entry => entry.toLowerCase() === name));
+  return match?.[0] ?? null;
+}
+
+// configText: content of .agdf/control/config.json, or null when absent. Only without it, Claude's
+// `language` setting (follow-up SDD-11) chooses the locale before the registry's fallback.
+export function chatLocale(registry, configText, { setting = null, labels = null } = {}) {
+  if (typeof configText !== 'string') return settingLocale(registry, labels, setting) ?? registry.fallbackLocale;
+  try {
+    return resolveLocale(registry, JSON.parse(configText).chat_language);
+  } catch {
+    return registry.fallbackLocale;
+  }
+}
+
+export function gateTitle(registry, locale, gate) {
+  return registry.locales[locale]?.gateTitles?.[gate] ?? registry.locales[registry.fallbackLocale]?.gateTitles?.[gate] ?? gate;
+}
+
+// The localized status-card value for a next-step source text, or the source text itself
+// ({ text, isLocalized }); an empty or "none" value becomes the pack's "none".
+export function localizeNextStep(registry, locale, value) {
+  const source = String(value ?? '').trim();
+  const pack = registry.locales[locale];
+  const fallback = registry.locales[registry.fallbackLocale];
+  if (!source || source === 'none') return { text: pack.primary.none, isLocalized: true };
+  if (locale === registry.fallbackLocale) return { text: source, isLocalized: true };
+  const groups = [
+    [fallback.operationalValues, pack.operationalValues],
+    [fallback.primary.actions, pack.primary.actions],
+    [fallback.primary.afterApproval, pack.primary.afterApproval],
+  ];
+  for (const [sources, targets] of groups) {
+    for (const [key, text] of Object.entries(sources ?? {})) {
+      if (text === source) {
+        const localized = String(targets?.[key] ?? '').trim();
+        return localized ? { text: localized, isLocalized: true } : { text: source, isLocalized: false };
+      }
+    }
+  }
+  if (fallback.primary.quality === source && String(pack.primary.quality ?? '').trim()) {
+    return { text: pack.primary.quality.trim(), isLocalized: true };
+  }
+  return { text: source, isLocalized: false };
+}
+
+// A companion label by dotted path with {name} parameters; missing keys fall back to the
+// fallback locale and finally to the path, so a gap stays visible instead of throwing.
+export function label(labels, locale, path, params = {}) {
+  const lookup = pack => path.split('.').reduce((node, key) => (node && typeof node === 'object' ? node[key] : undefined), pack);
+  const template = lookup(labels.locales[locale]) ?? lookup(labels.locales[labels.fallbackLocale]) ?? path;
+  return String(template).replace(/\{(\w+)\}/gu, (match, name) => (Object.hasOwn(params, name) ? String(params[name]) : match));
+}

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

@@ -0,0 +1,90 @@
+// 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') 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 state = runState(run);
+  return state.mood === null ? { kind: 'unreadable' } : { kind: 'run', runId: run.id, state };
+}
+
+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. "<run> wartet auf Freigabe: Qualitätssicherung".
+export function noticeText(runId, state, { registry, labels, locale }) {
+  const t = (path, params) => label(labels, locale, path, params);
+  const params = { run: runId, gate: gateTitle(registry, locale, state.reason.gate) };
+  if (state.reason.decision) params.decision = t(`decisions.${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.neutral')}`;
+  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: {} });