synabun 2.0.9 → 2.1.0

package/neural-interface/public/shared/skills/studio/sx-snippets.js

@@ -0,0 +1,96 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio 2.0: snippets
+// ═══════════════════════════════════════════
+//
+// Pieces the editor inserts for you. A body snippet goes in at the caret, on lines of its own (never inside the
+// frontmatter: a caret there inserts at the start of the body). A frontmatter snippet is keys, merged into the
+// frontmatter through the same one-key patch as the form (ss-frontmatter.js patch): the keys already there, their
+// comments and order stay. The words follow the runtimes as they are (SK-067, Q14): pre-approved tools run without
+// asking and do not restrict other tools; a skill names its files by a path relative to its folder, or
+// ${CLAUDE_SKILL_DIR} in Claude Code; nothing claims "five trigger phrases" make a skill fire. Names and
+// descriptions are i18n keys (`skillsStudio.snippets.<id>`); the inserted text is the skill's own words, English.
+// The user's own snippets (the presets of P0, ss-presets.js) are body snippets. No DOM and no imports.
+
+/** @typedef {{ id: string, kind: 'body'|'frontmatter', types: string[], text?: string, patch?: object, group: string }} Snippet */
+
+/** @type {Snippet[]} */
+export const SNIPPETS = Object.freeze([
+  { id: 'role', kind: 'body', group: 'structure', types: ['skill', 'agent'], text: '## Role\n\nYou are [who]. Your job is to [what], for [whom].\n' },
+  { id: 'steps', kind: 'body', group: 'structure', types: ['skill', 'command', 'agent'], text: '## Steps\n\n1. Read what the user gave and check it is complete.\n2. Do the task.\n3. Check the result.\n4. Report what changed, briefly.\n' },
+  { id: 'constraints', kind: 'body', group: 'structure', types: [], text: '## Rules\n\n- Never change files outside the project.\n- Ask before deleting anything.\n- Say what you are about to do before you do it.\n' },
+  { id: 'output', kind: 'body', group: 'structure', types: [], text: '## Output\n\nAnswer with:\n\n1. A one-line summary.\n2. What you found, most important first.\n3. What to do next.\n' },
+  { id: 'examples', kind: 'body', group: 'structure', types: ['skill', 'agent'], text: '## Examples\n\n<example>\nuser: "[a request this skill should handle]"\nassistant: "[what a good answer does]"\n</example>\n' },
+  { id: 'context', kind: 'body', group: 'workflow', types: ['skill', 'command'], text: '## First, gather context\n\nBefore you change anything, read the files involved and look for how the project already does it.\n' },
+  { id: 'errors', kind: 'body', group: 'workflow', types: ['skill', 'command'], text: '## When something fails\n\nSay what failed and why, suggest the next step, and do not repeat the same attempt unchanged.\n' },
+  { id: 'input-check', kind: 'body', group: 'workflow', types: ['skill', 'command'], text: '## Input\n\nThe user\'s words are in $ARGUMENTS. If they are empty or unclear, ask before you start.\n' },
+  { id: 'confirm', kind: 'body', group: 'workflow', types: ['skill', 'command'], text: '## Before anything destructive\n\nList exactly what will be changed or removed and wait for a clear yes.\n' },
+  { id: 'scope', kind: 'body', group: 'workflow', types: ['skill', 'agent'], text: '## Scope\n\nThis covers: [what].\nIt does not cover: [what not]; say so and suggest the right tool.\n' },
+  { id: 'references', kind: 'body', group: 'files', types: ['skill'], text: '## References\n\nRead these only when the task needs them:\n\n- [references/guide.md](references/guide.md): [what it holds]\n' },
+  { id: 'variables', kind: 'body', group: 'files', types: ['skill', 'command'], text: '## Variables\n\n- $ARGUMENTS: what the user typed after the name.\n- ${CLAUDE_SKILL_DIR}: this skill\'s folder in Claude Code (elsewhere, use paths relative to this file).\n' },
+  { id: 'dynamic', kind: 'body', group: 'files', types: ['skill', 'command'], text: '## Current state\n\n- Branch: !`git branch --show-current`\n' },
+  { id: 'fm-tools-readonly', kind: 'frontmatter', group: 'frontmatter', types: ['skill'], patch: { 'allowed-tools': ['Read', 'Grep', 'Glob'] } },
+  { id: 'fm-agent-tools', kind: 'frontmatter', group: 'frontmatter', types: ['agent'], patch: { tools: 'Read, Grep, Glob' } },
+  { id: 'fm-manual', kind: 'frontmatter', group: 'frontmatter', types: ['skill'], patch: { 'disable-model-invocation': true } },
+  { id: 'fm-hint', kind: 'frontmatter', group: 'frontmatter', types: ['skill', 'command'], patch: { 'argument-hint': '[target]' } },
+  { id: 'fm-when', kind: 'frontmatter', group: 'frontmatter', types: ['skill'], patch: { when_to_use: 'Use when [the situation]. For example: "[a request]".' } },
+  { id: 'fm-fork', kind: 'frontmatter', group: 'frontmatter', types: ['skill'], patch: { context: 'fork', agent: 'Explore' } },
+  { id: 'fm-model', kind: 'frontmatter', group: 'frontmatter', types: ['agent'], patch: { model: 'sonnet' } },
+]);
+
+export const SNIPPET_GROUPS = Object.freeze(['structure', 'workflow', 'files', 'frontmatter', 'custom']);
+
+/** The snippets for a kind of artifact: the built-in ones that fit it, then the user's own. */
+export function snippetsFor(type, custom = []) {
+  const builtIn = SNIPPETS.filter((s) => !s.types.length || s.types.includes(type));
+  // A preset comes from the synced UI state (or a file someone handed over): every field is taken as text.
+  const typesOf = (p) => (Array.isArray(p.types) ? p.types.filter((x) => typeof x === 'string') : []);
+  const own = (Array.isArray(custom) ? custom : []).filter((p) => p && typeof p.snippet === 'string' && p.id != null && (!typesOf(p).length || typesOf(p).includes(type)))
+    .map((p) => ({ id: `custom:${String(p.id)}`, kind: 'body', group: 'custom', types: typesOf(p), text: p.snippet, name: String(p.name ?? ''), description: typeof p.description === 'string' ? p.description : '', custom: true }));
+  // One snippet once: a preset that is a built-in's exact text is not listed twice.
+  const texts = new Set(builtIn.map((s) => s.text).filter(Boolean));
+  return [...builtIn, ...own.filter((s) => !texts.has(s.text))];
+}
+
+/** Where the body of a text starts (after its frontmatter), as an index. */
+export function bodyStart(text) {
+  const s = String(text ?? '');
+  const bom = s.charCodeAt(0) === 0xFEFF ? 1 : 0;
+  const m = /^---[ \t]*\n[\s\S]*?\n---[ \t]*(?:\n|$)/.exec(s.slice(bom));
+  return m ? bom + m[0].length : bom;
+}
+
+/**
+ * Insert a snippet.
+ * @param {string} text the document ("\n" line breaks)
+ * @param {Snippet} snippet
+ * @param {{ caret?: number, fm?: { patch: (text: string, changes: object) => object } }} [o] `fm`: ss-frontmatter.js (frontmatter snippets)
+ * @returns {{ ok: true, text: string, caret: number, at: number } | { ok: false, reason: string }}
+ */
+export function applySnippet(text, snippet, { caret = null, fm = null } = {}) {
+  const s = String(text ?? '');
+  if (snippet?.kind === 'frontmatter') {
+    if (!fm || typeof fm.patch !== 'function') return { ok: false, reason: 'no-parser' };
+    const result = fm.patch(s, snippet.patch || {});
+    if (!result.ok) return { ok: false, reason: result.reason || 'invalid' };
+    return { ok: true, text: result.text, caret: Math.min(caret ?? 0, result.text.length), at: 0, changed: result.changed !== false };
+  }
+  const piece = String(snippet?.text ?? '');
+  if (!piece.trim()) return { ok: false, reason: 'empty' };
+  const start = bodyStart(s);
+  let at = Number.isInteger(caret) ? Math.max(0, Math.min(caret, s.length)) : s.length;
+  if (at < start) at = start;   // never inside the frontmatter
+  const before = s.slice(0, at);
+  const after = s.slice(at);
+  const pad = before.length > start && !before.endsWith('\n\n') ? (before.endsWith('\n') ? '\n' : '\n\n') : '';
+  const body = piece.endsWith('\n') ? piece : `${piece}\n`;
+  const trail = after.length && !after.startsWith('\n') ? '\n' : '';
+  const next = before + pad + body + trail + after;
+  return { ok: true, text: next, caret: before.length + pad.length + body.length, at: before.length + pad.length, changed: true };
+}
+
+/** Whether a snippet matches a search, through the words the view shows for it. */
+export function snippetMatches(snippet, query, words = (s) => `${s.name || ''} ${s.description || ''}`) {
+  const q = String(query ?? '').trim().toLowerCase();
+  if (!q) return true;
+  return `${snippet.id} ${words(snippet)} ${snippet.kind === 'frontmatter' ? Object.keys(snippet.patch || {}).join(' ') : ''}`.toLowerCase().includes(q);
+}

package/neural-interface/public/shared/skills/studio/sx-subject.js

@@ -0,0 +1,248 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio 2.0: what a Library row opens as
+// ═══════════════════════════════════════════
+//
+// A row of the Library (sx-library.js) opens in one workspace, in one of four modes:
+//   library   a skill in SynaBun's managed library: edits go to its draft (PATCH /v2/drafts), Versions lists its
+//             revisions, Publish installs one of them into the runtimes' folders (owner decision 2026-10-22:
+//             runtime folders are destinations, not edited in place);
+//   adopt     a skill folder of the owner's that is not in the library yet: it opens as it is on disk, and the
+//             first save takes the folder into the library (POST /v2/skills { artifactId }) with the edit as its
+//             draft, so it reaches the folder again only through Publish;
+//   inplace   an agent or a command (one file): the library holds skill folders only, so it is saved where it is,
+//             over the revision it was opened at (the P0 routes: PUT /api/skills-studio/artifact/:id);
+//   readonly  what SynaBun does not write: a skill it ships, a plugin's, a Claude account's, a runtime's own
+//             (Codex system skills, managed settings), a folder no route can reach. A skill can be copied into the
+//             library ("Customize a copy").
+// Also here: the P0 artifact id of an entry (when those routes can reach it), and the install targets a skill can
+// be published to, read from the catalog's roots. No DOM; imports only ss-ids.js.
+
+import { encodeArtifactId } from '../ss-ids.js';
+
+const READ_ONLY_REASON = { synabun: 'bundled', plugin: 'plugin', account: 'account', system: 'system', shared: 'shared' };
+
+/**
+ * The artifact id the P0 routes (/api/skills-studio/artifact/:id) take for an entry, encoded, or null when they
+ * cannot reach it: they read Claude Code's own folders only (~/.claude/skills|commands|agents of the default
+ * account, a registered project's .claude/…), and the bundled source.
+ */
+export function v1IdFor(entry) {
+  if (!entry || typeof entry.path !== 'string' || !entry.path) return null;
+  const kind = entry.kind;
+  if (!['skill', 'command', 'agent'].includes(kind)) return null;
+  const bundled = entry.sourceKind === 'bundled' || entry.family === 'synabun';
+  const claudeOwn = entry.family === 'claude' && entry.sourceKind === 'native'
+    && (entry.scope === 'project' || (entry.scope === 'user' && (!entry.accountId || entry.accountId === 'default')));
+  if (!bundled && !claudeOwn) return null;
+  if (bundled && kind !== 'skill') return null;
+  return encodeArtifactId(`${kind}:${entry.path}`);
+}
+
+/** The entry of a row the P0 routes reach, when one of its locations is such (an account's link, a project's own). */
+function addressableEntry(row) {
+  for (const e of [row.primary, ...(row.entries || [])]) if (e && v1IdFor(e)) return e;
+  return null;
+}
+
+/**
+ * What a row opens as.
+ * @param {object} row a row of sx-library.js buildRows()
+ * @param {{ guest?: boolean, caps?: Set<string> }} [o] caps: the service's capabilities (GET /v2/capabilities)
+ * @returns {{ mode: 'library'|'adopt'|'inplace'|'readonly', editable: boolean, reason: string|null,
+ *   canCustomize: boolean, canAdopt: boolean, canPublish: boolean, hasVersions: boolean, v1Id: string|null,
+ *   artifactId: string|null, skillId: string|null, readsFiles: 'library'|'v1'|'catalog'|'head' }}
+ */
+export function subjectOf(row, { guest = false, caps = new Set() } = {}) {
+  const entry = row?.primary || null;
+  const skill = row?.skill || null;
+  const v1Entry = addressableEntry(row || {});
+  const v1Id = v1Entry ? v1IdFor(v1Entry) : null;
+  const catalogFiles = caps.has('catalog-file');
+  const out = {
+    mode: 'readonly', editable: false, reason: null, canCustomize: false, canAdopt: false, canPublish: false, hasVersions: false,
+    v1Id, artifactId: entry?.id || null, skillId: skill?.skillId || null,
+    readsFiles: v1Id ? 'v1' : catalogFiles ? 'catalog' : 'head',
+  };
+  if (!row) return out;
+  if (skill && row.source !== 'synabun') {
+    out.mode = 'library';
+    out.readsFiles = 'library';
+    out.hasVersions = true;
+    out.canPublish = !guest;
+    out.editable = !guest;
+    if (guest) out.reason = 'guest';
+    return out;
+  }
+  if (row.source === 'synabun') {
+    // What SynaBun ships: its library copy holds the versions (`upstream`); it is installed, never edited.
+    out.mode = 'readonly';
+    out.reason = 'bundled';
+    out.readsFiles = skill ? 'library' : out.readsFiles;
+    out.hasVersions = !!skill;
+    out.canPublish = !!skill && !guest;
+    out.canCustomize = !guest && row.kind === 'skill';
+    return out;
+  }
+  if (row.binary) {
+    out.reason = 'not-text';
+    out.canAdopt = false;
+    return out;
+  }
+  if (row.kind === 'skill') {
+    if (!row.readOnly && entry && (entry.scope === 'user' || entry.scope === 'project')) {
+      out.mode = 'adopt';
+      out.editable = !guest;
+      out.canAdopt = !guest;
+      out.reason = guest ? 'guest' : null;
+      return out;
+    }
+    out.reason = guest ? 'guest' : (READ_ONLY_REASON[row.source] || 'not-writable');
+    out.canCustomize = !guest && (out.readsFiles !== 'head');
+    return out;
+  }
+  // An agent or a command: saved where it is, through the routes that reach it.
+  if (!row.readOnly && v1Id) {
+    out.mode = 'inplace';
+    out.editable = !guest;
+    out.reason = guest ? 'guest' : null;
+    return out;
+  }
+  out.reason = guest ? 'guest' : (READ_ONLY_REASON[row.source] || (row.readOnly ? 'not-writable' : 'not-addressable'));
+  return out;
+}
+
+// ── Install targets ──
+
+/** The key an install plan gives a target (lib/skills/deploy.js normalizeTarget). */
+export function targetKey(t) {
+  const scope = t?.scope === 'project' ? 'project' : 'user';
+  return scope === 'project' ? `${t.runtime}:project:${t.projectPath}` : `${t.runtime}:user:${t?.accountId || 'default'}`;
+}
+
+/** A target as a request names it: only the fields a target has. */
+export function wholeTarget(t) {
+  const out = { runtime: t.runtime };
+  if (t.scope === 'project') { out.scope = 'project'; out.projectPath = t.projectPath; } else out.scope = 'user';
+  if (t.accountId && t.accountId !== 'default') out.accountId = t.accountId;
+  return out;
+}
+
+/** The keys of a list of targets, each once, sorted: a selection as it can be compared with another. */
+export const selectionKeys = (targets) => [...new Set((Array.isArray(targets) ? targets : []).map(targetKey))].sort();
+
+/**
+ * Whether two asks of Publish are the same: one revision and exactly the same targets. A plan answers only what it
+ * was asked for: shown or installed for anything else (another version picked, a target ticked meanwhile), it would
+ * install what the owner no longer sees.
+ * @param {{ revisionId: string|null, targets: object[] }|null} a @param {{ revisionId: string|null, targets: object[] }|null} b
+ */
+export function sameAsk(a, b) {
+  if (!a || !b || !a.revisionId || a.revisionId !== b.revisionId) return false;
+  const x = selectionKeys(a.targets); const y = selectionKeys(b.targets);
+  return x.length > 0 && x.length === y.length && x.every((k, i) => k === y[i]);
+}
+
+const RUNTIME_OF_FAMILY = { claude: 'claude', codex: 'codex', opencode: 'opencode', shared: 'agents' };
+
+/**
+ * The targets a skill can be installed into: each runtime's own skills folder for each account, the shared
+ * ~/.agents/skills (only while the owner turned it on), and the folders of the projects asked for.
+ * @param {object} o
+ * @param {object[]} [o.roots] the catalog's roots (GET /catalog `roots`)
+ * @param {{ sharedAgentsRoot?: boolean }} [o.config]
+ * @param {{ path: string, label: string }[]} [o.projects] projects to offer targets for
+ * @returns {{ key, target, runtime, scope, accountId, projectPath, projectLabel, path, status, policy, shared, runtimes }[]}
+ *   `runtimes`: every runtime that reads that folder (OpenCode reads Claude Code's; Codex's project folder is shared)
+ */
+export function installTargets({ roots = [], config = {}, projects = [] } = {}) {
+  const out = [];
+  const seen = new Set();
+  const push = (t) => { if (seen.has(t.key)) return; seen.add(t.key); out.push(t); };
+  for (const root of Array.isArray(roots) ? roots : []) {
+    if (root?.kind !== 'skills' || !RUNTIME_OF_FAMILY[root.family]) continue;
+    if (root.sourceKind !== 'native' && root.sourceKind !== 'shared') continue;
+    const write = root.policy?.write;
+    if (write !== 'owner' && write !== 'owner-opt-in') continue;
+    const runtime = RUNTIME_OF_FAMILY[root.family];
+    if (root.scope === 'project') continue;   // projects come from `projects`, one row per runtime
+    const accountId = root.accountId || 'default';
+    const target = { runtime, scope: 'user', ...(accountId !== 'default' ? { accountId } : {}) };
+    const readers = Array.isArray(root.runtimes) && root.runtimes.length ? root.runtimes.filter((r) => typeof r === 'string') : [runtime === 'agents' ? 'codex' : runtime, ...(runtime === 'agents' ? ['opencode'] : [])];
+    push({ key: targetKey(target), target, runtime, scope: 'user', accountId, projectPath: null, projectLabel: null, path: root.path, status: root.status, policy: root.policy || null, shared: runtime === 'agents', off: runtime === 'agents' && !config.sharedAgentsRoot, runtimes: readers });
+  }
+  for (const p of Array.isArray(projects) ? projects : []) {
+    if (!p?.path) continue;
+    for (const runtime of ['claude', 'codex', 'opencode']) {
+      const target = { runtime, scope: 'project', projectPath: p.path };
+      const sub = runtime === 'claude' ? '.claude/skills' : runtime === 'codex' ? '.agents/skills' : '.opencode/skills';
+      // Who reads a project's folders (lib/skills/roots.js): .claude/skills and .agents/skills are read by OpenCode too.
+      const readers = runtime === 'opencode' ? ['opencode'] : [runtime, 'opencode'];
+      push({ key: targetKey(target), target, runtime, scope: 'project', accountId: 'default', projectPath: p.path, projectLabel: p.label || p.path, path: `${p.path.replace(/[\\/]+$/, '')}/${sub}`, status: null, policy: null, shared: false, off: false, runtimes: readers });
+    }
+  }
+  const order = { claude: 0, codex: 1, opencode: 2, agents: 3 };
+  return out.sort((a, b) => (a.scope === b.scope ? 0 : a.scope === 'user' ? -1 : 1) || (a.projectLabel || '').localeCompare(b.projectLabel || '') || (order[a.runtime] - order[b.runtime]) || a.accountId.localeCompare(b.accountId));
+}
+
+/**
+ * What a target has of a skill now: an installation of the library (current or older than the revision shown), a
+ * folder of its name SynaBun did not install, an old bridge, or nothing.
+ * @param {object} t a target of installTargets()
+ * @param {object} o
+ * @param {object|null} o.skill the library skill (GET /skills summary)
+ * @param {object|null} o.row its Library row
+ * @param {string|null} [o.revisionId] the revision the Publish tab shows
+ */
+export function targetState(t, { skill = null, row = null, revisionId = null } = {}) {
+  const install = (skill?.installations || []).find((i) => i.runtime === t.runtime && (i.scope || 'user') === t.scope
+    && (t.scope === 'project' ? i.projectPath === t.projectPath : (i.accountId || 'default') === t.accountId));
+  if (install) {
+    const current = revisionId ? install.sourceRevisionId === revisionId : !install.updateAvailable;
+    return { state: current ? 'installed' : 'outdated', installation: install, path: install.destination };
+  }
+  const name = row?.folderName || skill?.name || '';
+  const inFolder = (row?.entries || []).find((e) => e.kind === 'skill' && e.path && t.path && e.path.startsWith(`${t.path.replace(/[\\/]+$/, '')}/`) && e.path.slice(t.path.replace(/[\\/]+$/, '').length + 1) === name);
+  if (inFolder) return { state: 'present', installation: null, path: inFolder.path };
+  const bridge = (row?.bridges || []).find((b) => b.runtime === t.runtime && t.scope === 'user');
+  if (bridge) return { state: 'bridge', installation: null, path: bridge.entry?.path || null };
+  return { state: 'none', installation: null, path: null };
+}
+
+/**
+ * Targets checked to start with: where the skill is already, else the owner's assistants (Settings → Skills → My
+ * assistants; detected from what is installed and used when none were chosen), each in its own user folder for the
+ * default account: never everything. A folder another assistant reads too is counted for it: OpenCode reads Claude
+ * Code's skills folder, so with both among the assistants only Claude Code's is ticked (no second copy unless asked;
+ * `seenThrough` says which). Without any list: Claude Code.
+ * @param {object[]} targets installTargets()
+ * @param {{ skill?: object|null, row?: object|null, assistants?: string[]|null }} [o]
+ */
+export function defaultTargets(targets, { skill = null, row = null, assistants = null } = {}) {
+  const there = targets.filter((t) => !t.off && ['installed', 'outdated', 'present'].includes(targetState(t, { skill, row }).state));
+  if (there.length) return new Set(there.map((t) => t.key));
+  const own = (runtime) => targets.find((t) => t.runtime === runtime && t.scope === 'user' && t.accountId === 'default' && !t.off) || null;
+  const wanted = Array.isArray(assistants) && assistants.length ? assistants.filter((r) => ['claude', 'codex', 'opencode'].includes(r)) : ['claude'];
+  // Every assistant gets its own folder: a terminal OpenCode reads Claude Code's folder, but SynaBun's own OpenCode
+  // serves (the panel, an Assistant brain) start with OPENCODE_DISABLE_CLAUDE_CODE=1 and never see it (checked with
+  // opencode 2.1.4), so an OpenCode among the assistants is ticked for a real copy.
+  const picked = ['claude', 'codex', 'opencode'].filter((runtime) => wanted.includes(runtime)).map(own).filter(Boolean);
+  if (!picked.length) { const claude = own('claude'); return new Set(claude ? [claude.key] : []); }
+  return new Set(picked.map((t) => t.key));
+}
+
+/**
+ * The runtime whose ticked (or installed) folder a terminal copy of this runtime reads too, in this scope: 'claude'
+ * for an OpenCode tile when Claude Code's folder is ticked or holds the skill (a terminal OpenCode reads it; SynaBun's
+ * own OpenCode serves do not, so this is a hint, never a reason to leave OpenCode out); else null.
+ * @param {string} runtime @param {object[]} targets @param {Set<string>} checked
+ * @param {{ scope?: string, skill?: object|null, row?: object|null }} [o]
+ */
+export function seenThrough(runtime, targets, checked, { scope = 'user', skill = null, row = null } = {}) {
+  for (const t of targets) {
+    if (t.runtime === runtime || t.off || !(t.runtimes || []).includes(runtime)) continue;
+    const inScope = scope.startsWith('project:') ? t.scope === 'project' && t.projectPath === scope.slice(8) : t.scope === 'user' && t.accountId === 'default';
+    if (!inScope) continue;
+    if (checked?.has?.(t.key) || ['installed', 'outdated', 'present'].includes(targetState(t, { skill, row }).state)) return t.runtime;
+  }
+  return null;
+}