@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/library/migrate.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { createLibraryStore } from './store.js';
+
+export function importLibraryDirectory(store: ReturnType<typeof createLibraryStore>, directory: string, kind: 'skill' | 'agent', followLinks = true) {
+  if (!fs.existsSync(directory)) return [];
+  if (!followLinks && fs.lstatSync(directory).isSymbolicLink()) return [];
+  const imported: Array<{ source: string; id: string; linked: boolean }> = [];
+  for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (item.name.startsWith('.')) continue;
+    const source = path.join(directory, item.name);
+    const file = kind === 'skill' ? path.join(source, 'SKILL.md') : source;
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile() || (kind === 'agent' && !file.endsWith('.md'))) continue;
+    if (!followLinks && (item.isSymbolicLink() || fs.lstatSync(file).isSymbolicLink())) continue;
+    const id = store.importFile(file, kind);
+    if (store.document(id).content !== fs.readFileSync(file, 'utf8')) throw new Error(`Import non vérifié : ${source}`);
+    imported.push({ source, id, linked: item.isSymbolicLink() });
+  }
+  return imported;
+}
+
+export function migratePersonalLibrary(store: ReturnType<typeof createLibraryStore>, userHome: string, applicationRoot: string, withdraw = false) {
+  const imported = [];
+  for (const folder of ['assistant-workflows', 'tabular-review-workflows']) {
+    imported.push(...importLibraryDirectory(store, path.join(applicationRoot, 'server/piecemaker/vendor/mike-defaults-fr', folder), 'skill'));
+  }
+  for (const [directory, kind] of [
+    [path.join(userHome, '.claude', 'skills'), 'skill'],
+    [path.join(userHome, '.codex', 'skills'), 'skill'],
+    [path.join(userHome, '.agents', 'skills'), 'skill'],
+    [path.join(userHome, '.claude', 'agents'), 'agent'],
+    [path.join(userHome, '.piecemaker', 'library', 'skills'), 'skill'],
+    [path.join(userHome, '.piecemaker', 'library', 'agents'), 'agent'],
+  ] as const) imported.push(...importLibraryDirectory(store, directory, kind));
+  if (withdraw) {
+    const candidates = imported.filter((entry) => ['.claude', '.codex', '.agents'].some((provider) => entry.source.startsWith(path.join(userHome, provider) + path.sep)));
+    const backup = path.join(store.directory, `migration-${Date.now()}`);
+    fs.mkdirSync(backup, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(backup, 'manifest.json'), JSON.stringify(candidates, null, 2), { mode: 0o600 });
+    for (const entry of candidates.sort((a, b) => Number(b.linked) - Number(a.linked))) {
+      const destination = path.join(backup, path.relative(userHome, entry.source));
+      fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+      fs.renameSync(entry.source, destination);
+    }
+    fs.writeFileSync(path.join(store.directory, 'centralized.json'), JSON.stringify({ migratedAt: new Date().toISOString(), count: candidates.length }), { mode: 0o600 });
+  }
+  return imported;
+}

package/server/piecemaker/library/policy.cjs

@@ -0,0 +1,9 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function libraryIsCentralized(userHome) {
+  const home = process.env.PIECEMAKER_HOME || path.join(userHome, '.piecemaker');
+  return fs.existsSync(path.join(home, 'library-backend', 'centralized.json'));
+}
+
+module.exports = { libraryIsCentralized };

package/server/piecemaker/library/provider-skills.ts

@@ -0,0 +1,48 @@
+import { providerSkillsService } from '@/modules/providers/index.js';
+import type { LLMProvider, ProviderSkillListOptions } from '@/shared/types.js';
+
+import type { createLibraryStore } from './store.js';
+
+const LIBRARY_SKILL_PROVIDERS: LLMProvider[] = ['claude', 'codex', 'cursor', 'mistral', 'opencode'];
+
+type ProviderSkillsReader = {
+  listProviderSkills(provider: string, options?: ProviderSkillListOptions): ReturnType<typeof providerSkillsService.listProviderSkills>;
+};
+
+export async function listLibraryProviderSkills(
+  workspacePath: string | undefined,
+  reader: ProviderSkillsReader = providerSkillsService,
+) {
+  const results = await Promise.all(LIBRARY_SKILL_PROVIDERS.map(async (provider) => {
+    try {
+      return {
+        provider,
+        skills: await reader.listProviderSkills(provider, { workspacePath }),
+      };
+    } catch (error) {
+      return {
+        provider,
+        skills: [],
+        error: error instanceof Error ? error.message : 'Chargement impossible.',
+      };
+    }
+  }));
+
+  return { providers: results };
+}
+
+export async function scanAndPersistLibraryProviderSkills(
+  store: ReturnType<typeof createLibraryStore>,
+  workspacePath: string | undefined,
+  reader: ProviderSkillsReader = providerSkillsService,
+) {
+  const result = await listLibraryProviderSkills(workspacePath, reader);
+  for (const provider of result.providers) {
+    for (const skill of provider.skills) {
+      if (!skill.sourcePath) continue;
+      try { store.importFile(skill.sourcePath, 'skill'); }
+      catch { try { store.importFile(skill.sourcePath, 'skill', false); } catch {} }
+    }
+  }
+  return result;
+}

package/server/piecemaker/library/routes.ts

@@ -0,0 +1,51 @@
+import express from 'express';
+
+import type { createLibraryStore } from './store.js';
+import { listLibraryProviderSkills, scanAndPersistLibraryProviderSkills } from './provider-skills.js';
+
+export function createLibraryRouter(store: ReturnType<typeof createLibraryStore>) {
+  const router = express.Router();
+  router.get('/catalog', (req, res) => {
+    try { res.json({ entries: store.list(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/catalog', (req, res) => {
+    const kind = req.body?.kind;
+    const name = req.body?.name;
+    if (kind !== 'skill' && kind !== 'agent') { res.status(400).json({ error: 'Type invalide.' }); return; }
+    if (typeof name !== 'string' || !name.trim()) { res.status(400).json({ error: 'Nom requis.' }); return; }
+    const description = typeof req.body?.description === 'string' ? req.body.description : '';
+    try { res.json(store.createEntry(kind, name, description)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/provider-skills', async (req, res) => {
+    const workspacePath = typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined;
+    res.json(await listLibraryProviderSkills(workspacePath));
+  });
+  router.post('/provider-skills/scan', async (req, res) => {
+    const workspacePath = typeof req.body?.workspacePath === 'string' ? req.body.workspacePath : undefined;
+    try { res.json(await scanAndPersistLibraryProviderSkills(store, workspacePath)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/catalog/:id', (req, res) => {
+    try { res.json(store.document(String(req.params.id))); }
+    catch (error) { res.status(404).json({ error: (error as Error).message }); }
+  });
+  router.put('/catalog/:id', (req, res) => {
+    if (typeof req.body?.content !== 'string' || typeof req.body?.previousContent !== 'string') {
+      res.status(400).json({ error: 'Contenu et version précédente requis.' });
+      return;
+    }
+    try { res.json(store.updateDocument(String(req.params.id), req.body.content, req.body.previousContent)); }
+    catch (error) { res.status(409).json({ error: (error as Error).message }); }
+  });
+  router.delete('/catalog/:id', (req, res) => {
+    try { res.json(store.deleteEntry(String(req.params.id))); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.put('/catalog/:id/activation', (req, res) => {
+    try { res.json(store.setEnabled(req.body?.workspacePath, String(req.params.id), req.body?.enabled)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  return router;
+}

package/server/piecemaker/library/runtime.ts

@@ -0,0 +1,39 @@
+import type { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
+import type { NormalizedMessage } from '@/shared/types.js';
+
+import type { createLibraryStore } from './store.js';
+
+const OPEN = '<PIECEMAKER_LIBRARY_INSTRUCTIONS>';
+const CLOSE = '</PIECEMAKER_LIBRARY_INSTRUCTIONS>';
+
+export function stripLibraryInstructions(text: string) {
+  const start = text.lastIndexOf(`\n\n${OPEN}\n`);
+  return start >= 0 && text.endsWith(CLOSE) ? text.slice(0, start) : text;
+}
+
+export function installLibraryRuntime(runtime: Pick<typeof providerRuntimeService, 'run' | 'getRunner'>, sessions: Pick<typeof sessionsService, 'fetchHistory'>, store: ReturnType<typeof createLibraryStore>) {
+  const run = runtime.run.bind(runtime);
+  const history = sessions.fetchHistory.bind(sessions);
+  runtime.run = async (provider, command, options, writer) => {
+    const cwd = String(options.cwd ?? options.projectPath ?? '');
+    const instructions = cwd ? store.instructions(cwd) : '';
+    const wrapped = new Proxy(writer, {
+      get(target, key) {
+        if (key === 'send') return (value: unknown) => {
+          const message = value as NormalizedMessage;
+          target.send(message?.kind === 'text' && message.role === 'user'
+            ? { ...message, content: stripLibraryInstructions(message.content ?? '') } : value);
+        };
+        const value = Reflect.get(target, key, target);
+        return typeof value === 'function' ? value.bind(target) : value;
+      },
+    });
+    return run(provider, instructions ? `${command}\n\n${OPEN}\nInstructions activées pour ce dossier, à appliquer lorsqu’elles concernent la demande.\n${instructions}\n${CLOSE}` : command, options, wrapped);
+  };
+  runtime.getRunner = (provider) => (command, options, writer) => runtime.run(provider, command, options, writer);
+  sessions.fetchHistory = async (...args) => {
+    const result = await history(...args);
+    return { ...result, messages: result.messages.map((message) => message.kind === 'text' && message.role === 'user'
+      ? { ...message, content: stripLibraryInstructions(message.content ?? '') } : message) };
+  };
+}

package/server/piecemaker/library/store.ts

@@ -0,0 +1,456 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+
+import Database from 'better-sqlite3';
+
+import { parseFrontMatter } from '@/shared/frontmatter.js';
+
+import { prepareWorkspaceInstallation } from './workspace-installation.js';
+
+type StoredLibraryEntry = {
+  id: string;
+  kind: 'skill' | 'agent';
+  name: string;
+  description: string;
+  content: string;
+  assets: string;
+};
+
+type LibraryEntry = Omit<StoredLibraryEntry, 'assets'> & { assets: Record<string, string> };
+
+type LibraryCollectionEntry = {
+  entryId: string;
+  rootPath: string;
+};
+
+type LibraryCollectionInput = {
+  id: string;
+  name: string;
+  description: string;
+  source: string;
+  entries: LibraryCollectionEntry[];
+  files: Array<{ path: string; content: Buffer }>;
+};
+
+const MAX_EDITABLE_FILE_BYTES = 1024 * 1024;
+
+function normalizedCollectionPath(value: string) {
+  const normalized = value.trim().replace(/\\/g, '/');
+  const segments = normalized.split('/');
+  if (!normalized || path.isAbsolute(normalized) || segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+    throw new Error('Chemin de fichier invalide.');
+  }
+  return segments.join('/');
+}
+
+function decodeUtf8File(bytes: Buffer) {
+  if (bytes.includes(0)) throw new Error('Ce fichier ne peut pas être modifié.');
+  try { return new TextDecoder('utf-8', { fatal: true }).decode(bytes); }
+  catch { throw new Error('Ce fichier ne peut pas être modifié.'); }
+}
+
+function decodeEditableFile(bytes: Buffer) {
+  if (bytes.length > MAX_EDITABLE_FILE_BYTES) throw new Error('Ce fichier ne peut pas être modifié.');
+  return decodeUtf8File(bytes);
+}
+
+function collectionMainPath(entry: LibraryEntry, rootPath: string) {
+  return entry.kind === 'skill' && !rootPath.toLowerCase().endsWith('.md') ? `${rootPath}/SKILL.md` : rootPath;
+}
+
+export function createLibraryStore(home: string) {
+  const directory = path.join(home, 'library-backend');
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const filename = path.join(directory, 'catalog.sqlite');
+  const db = new Database(filename);
+  fs.chmodSync(filename, 0o600);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries (
+      id TEXT PRIMARY KEY, kind TEXT NOT NULL, name TEXT NOT NULL,
+      description TEXT NOT NULL, content TEXT NOT NULL, assets TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS origins (
+      source TEXT PRIMARY KEY, entry_id TEXT NOT NULL REFERENCES entries(id), source_hash TEXT
+    );
+    CREATE TABLE IF NOT EXISTS activation (
+      workspace TEXT NOT NULL, entry_id TEXT NOT NULL REFERENCES entries(id),
+      PRIMARY KEY(workspace, entry_id)
+    );
+    CREATE TABLE IF NOT EXISTS collections (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL, description TEXT NOT NULL, source TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS collection_entries (
+      collection_id TEXT NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
+      entry_id TEXT NOT NULL REFERENCES entries(id), root_path TEXT NOT NULL,
+      PRIMARY KEY(collection_id, entry_id, root_path)
+    );
+    CREATE TABLE IF NOT EXISTS collection_files (
+      collection_id TEXT NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
+      path TEXT NOT NULL, content BLOB NOT NULL,
+      PRIMARY KEY(collection_id, path)
+    );
+  `);
+  const originColumns = db.prepare('PRAGMA table_info(origins)').all() as Array<{ name: string }>;
+  if (!originColumns.some((column) => column.name === 'source_hash')) db.exec('ALTER TABLE origins ADD COLUMN source_hash TEXT');
+
+  function workspace(value: unknown) {
+    if (typeof value !== 'string' || !path.isAbsolute(value)) throw new Error('Dossier absolu requis.');
+    const resolved = fs.realpathSync(value);
+    if (!fs.statSync(resolved).isDirectory()) throw new Error('Dossier introuvable.');
+    return resolved;
+  }
+
+  function document(id: string) {
+    const entry = db.prepare('SELECT * FROM entries WHERE id = ?').get(id) as StoredLibraryEntry | undefined;
+    if (!entry) throw new Error('Élément introuvable.');
+    return { ...entry, assets: JSON.parse(entry.assets) as Record<string, string> };
+  }
+
+  function list(workspacePath?: string) {
+    const selected = workspacePath ? workspace(workspacePath) : '';
+    return db.prepare(`SELECT e.id, e.kind, e.name, e.description,
+      EXISTS(SELECT 1 FROM activation a WHERE a.entry_id = e.id AND a.workspace = ?) AS enabled
+      FROM entries e ORDER BY e.name COLLATE NOCASE`).all(selected).map((row) => {
+        const entry = row as Omit<StoredLibraryEntry, 'content' | 'assets'> & { enabled: number };
+        return { ...entry, enabled: Boolean(entry.enabled) };
+      });
+  }
+
+  function importFile(source: string, kind: StoredLibraryEntry['kind'], includeAssets = true) {
+    const resolved = fs.realpathSync(source);
+    const content = decodeUtf8File(fs.readFileSync(resolved));
+    const parsed = parseFrontMatter(content);
+    const data = parsed.data;
+    const sourceName = path.basename(source).toLowerCase() === 'skill.md'
+      ? path.basename(path.dirname(source))
+      : path.basename(source, path.extname(source));
+    const name = String(data.metadata?.title || data.name || sourceName);
+    const description = typeof data.description === 'string' ? data.description : '';
+    const assets: Record<string, string> = {};
+    let total = Buffer.byteLength(content);
+    function collect(root: string, relative = '') {
+      for (const child of fs.readdirSync(path.join(root, relative), { withFileTypes: true })) {
+        if (child.name === '.git' || child.name === 'node_modules' || child.name === '__pycache__') continue;
+        const key = path.posix.join(relative.split(path.sep).join('/'), child.name);
+        const file = path.join(root, key);
+        if (child.isSymbolicLink()) throw new Error(`Fichier associé lié non importé : ${file}`);
+        if (child.isDirectory()) collect(root, key);
+        else if (child.isFile() && fs.realpathSync(file) !== resolved) {
+          const bytes = fs.readFileSync(file);
+          total += bytes.length;
+          if (total > 30 * 1024 * 1024) throw new Error(`Skill trop volumineuse : ${name}`);
+          assets[key] = bytes.toString('base64');
+        }
+      }
+    }
+    if (kind === 'skill' && includeAssets) collect(path.dirname(resolved));
+    const serialized = JSON.stringify(Object.fromEntries(Object.entries(assets).sort(([a], [b]) => a.localeCompare(b))));
+    const id = createHash('sha256').update(`${kind}\0${content}\0${serialized}`).digest('hex');
+    const sourceHash = id;
+    const existingOrigin = db.prepare('SELECT entry_id AS entryId, source_hash AS sourceHash FROM origins WHERE source = ?').get(path.resolve(source)) as { entryId: string; sourceHash: string | null } | undefined;
+    if (existingOrigin) {
+      if (existingOrigin.sourceHash === null || existingOrigin.sourceHash === sourceHash) return existingOrigin.entryId;
+      const existingEntry = document(existingOrigin.entryId);
+      const existingAssets = JSON.stringify(Object.fromEntries(Object.entries(existingEntry.assets).sort(([a], [b]) => a.localeCompare(b))));
+      const existingHash = createHash('sha256').update(`${existingEntry.kind}\0${existingEntry.content}\0${existingAssets}`).digest('hex');
+      if (existingHash !== existingOrigin.sourceHash) return existingOrigin.entryId;
+      db.transaction(() => {
+        db.prepare('UPDATE entries SET name = ?, description = ?, content = ?, assets = ? WHERE id = ?').run(name, description, content, serialized, existingOrigin.entryId);
+        db.prepare('UPDATE origins SET source_hash = ? WHERE source = ?').run(sourceHash, path.resolve(source));
+      })();
+      return existingOrigin.entryId;
+    }
+    db.transaction(() => {
+      db.prepare('INSERT OR IGNORE INTO entries VALUES (?, ?, ?, ?, ?, ?)').run(id, kind, name, description, content, serialized);
+      db.prepare('INSERT INTO origins (source, entry_id, source_hash) VALUES (?, ?, ?)').run(path.resolve(source), id, sourceHash);
+    })();
+    return id;
+  }
+
+  function createEntry(kind: StoredLibraryEntry['kind'], name: string, description: string) {
+    const trimmedName = name.trim();
+    if (!trimmedName) throw new Error('Nom requis.');
+    const trimmedDescription = description.trim();
+    const id = randomBytes(32).toString('hex');
+    const body = kind === 'agent' ? 'Rôle et instructions de l’agent à rédiger ici.' : 'Instructions du skill à rédiger ici.';
+    const content = `---\nname: ${trimmedName}\ndescription: ${trimmedDescription}\n---\n${body}\n`;
+    db.prepare('INSERT INTO entries VALUES (?, ?, ?, ?, ?, ?)').run(id, kind, trimmedName, trimmedDescription, content, '{}');
+    return document(id);
+  }
+
+  function updateDocument(id: string, content: string, previousContent: string) {
+    return db.transaction(() => {
+      const entry = document(id);
+      if (entry.content !== previousContent) throw new Error('Le document a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
+      const { data } = parseFrontMatter(content);
+      const name = String(data.metadata?.title || data.name || entry.name);
+      const description = typeof data.description === 'string' ? data.description : '';
+      db.prepare('UPDATE entries SET name = ?, description = ?, content = ? WHERE id = ?').run(name, description, content, id);
+      const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
+      for (const { workspace: selected } of active) setEnabled(selected, id, true);
+      return document(id);
+    })();
+  }
+
+  function deleteEntry(id: string) {
+    const entry = document(id);
+    if (entry.kind !== 'skill') throw new Error('Seuls les skills peuvent être supprimés.');
+    const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
+    for (const { workspace: selected } of active) setEnabled(selected, id, false);
+    db.transaction(() => {
+      db.prepare('DELETE FROM collection_entries WHERE entry_id = ?').run(id);
+      db.prepare('DELETE FROM origins WHERE entry_id = ?').run(id);
+      db.prepare('DELETE FROM activation WHERE entry_id = ?').run(id);
+      db.prepare('DELETE FROM entries WHERE id = ?').run(id);
+    })();
+    return { ok: true };
+  }
+
+  function updateAsset(id: string, assetPath: string, content: string, previousContent: string) {
+    return db.transaction(() => {
+      const entry = document(id);
+      const normalized = normalizedCollectionPath(assetPath);
+      const encoded = entry.assets[normalized];
+      if (typeof encoded !== 'string') throw new Error('Fichier introuvable.');
+      const currentContent = decodeEditableFile(Buffer.from(encoded, 'base64'));
+      if (currentContent !== previousContent) throw new Error('Le fichier a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
+      const bytes = Buffer.from(content, 'utf8');
+      if (bytes.length > MAX_EDITABLE_FILE_BYTES || content.includes('\0')) throw new Error('Ce fichier ne peut pas être modifié.');
+      const assets = { ...entry.assets, [normalized]: bytes.toString('base64') };
+      db.prepare('UPDATE entries SET assets = ? WHERE id = ?').run(JSON.stringify(assets), id);
+      const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
+      for (const { workspace: selected } of active) setEnabled(selected, id, true);
+      return { path: normalized, content };
+    })();
+  }
+
+  function upsertCollection(input: LibraryCollectionInput) {
+    if (!input.id || (!input.entries.length && !input.files.length)) return null;
+    return db.transaction(() => {
+      db.prepare(`INSERT INTO collections (id, name, description, source) VALUES (?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description, source = excluded.source`)
+        .run(input.id, input.name, input.description, input.source);
+      db.prepare('DELETE FROM collection_entries WHERE collection_id = ?').run(input.id);
+      const insert = db.prepare('INSERT INTO collection_entries (collection_id, entry_id, root_path) VALUES (?, ?, ?)');
+      for (const entry of input.entries) insert.run(input.id, entry.entryId, normalizedCollectionPath(entry.rootPath));
+      db.prepare('DELETE FROM collection_files WHERE collection_id = ?').run(input.id);
+      const insertFile = db.prepare('INSERT INTO collection_files (collection_id, path, content) VALUES (?, ?, ?)');
+      for (const file of input.files) insertFile.run(input.id, normalizedCollectionPath(file.path), file.content);
+      return input.id;
+    })();
+  }
+
+  function hasCollection(id: string) {
+    return Boolean(db.prepare('SELECT 1 FROM collections WHERE id = ?').get(id));
+  }
+
+  function collectionEntries(id: string) {
+    return db.prepare(`SELECT ce.entry_id AS entryId, ce.root_path AS rootPath
+      FROM collection_entries ce WHERE ce.collection_id = ? ORDER BY ce.root_path COLLATE NOCASE`)
+      .all(id) as LibraryCollectionEntry[];
+  }
+
+  function listCollections(workspacePath?: string) {
+    const selected = workspacePath ? workspace(workspacePath) : '';
+    return db.prepare(`SELECT c.id, c.name, c.description, c.source,
+      COUNT(ce.entry_id) AS entryCount,
+      SUM(CASE WHEN a.entry_id IS NOT NULL THEN 1 ELSE 0 END) AS enabledCount
+      FROM collections c
+      LEFT JOIN collection_entries ce ON ce.collection_id = c.id
+      LEFT JOIN activation a ON a.entry_id = ce.entry_id AND a.workspace = ?
+      GROUP BY c.id ORDER BY c.name COLLATE NOCASE`).all(selected).map((row) => {
+        const collection = row as { id: string; name: string; description: string; source: string; entryCount: number; enabledCount: number };
+        return {
+          id: collection.id,
+          name: collection.name,
+          description: collection.description,
+          source: collection.source,
+          enabled: collection.entryCount > 0 && collection.enabledCount === collection.entryCount,
+          partial: collection.enabledCount > 0 && collection.enabledCount < collection.entryCount,
+          componentCount: collection.entryCount,
+        };
+      });
+  }
+
+  function collectionFiles(id: string) {
+    const files = new Map<string, { path: string; size: number; editable: boolean }>();
+    const storedFiles = db.prepare('SELECT path, content FROM collection_files WHERE collection_id = ?').all(id) as Array<{ path: string; content: Buffer }>;
+    for (const file of storedFiles) {
+      let editable = false;
+      try { decodeEditableFile(file.content); editable = true; } catch {}
+      files.set(file.path, { path: file.path, size: file.content.length, editable });
+    }
+    for (const mapping of collectionEntries(id)) {
+      const entry = document(mapping.entryId);
+      const mainPath = collectionMainPath(entry, mapping.rootPath);
+      const mainBytes = Buffer.from(entry.content, 'utf8');
+      let mainEditable = false;
+      try { decodeEditableFile(mainBytes); mainEditable = true; } catch {}
+      files.set(mainPath, { path: mainPath, size: mainBytes.length, editable: mainEditable });
+      if (entry.kind === 'skill') {
+        for (const [assetPath, encoded] of Object.entries(entry.assets)) {
+          const bytes = Buffer.from(encoded, 'base64');
+          let editable = false;
+          try { decodeEditableFile(bytes); editable = true; } catch {}
+          const filePath = `${mapping.rootPath}/${assetPath}`;
+          files.set(filePath, { path: filePath, size: bytes.length, editable });
+        }
+      }
+    }
+    return [...files.values()].sort((left, right) => left.path.localeCompare(right.path));
+  }
+
+  function collectionFile(id: string, filePath: string) {
+    const normalized = normalizedCollectionPath(filePath);
+    for (const mapping of collectionEntries(id)) {
+      const entry = document(mapping.entryId);
+      const mainPath = collectionMainPath(entry, mapping.rootPath);
+      if (normalized === mainPath) return { name: path.basename(normalized), path: normalized, content: decodeEditableFile(Buffer.from(entry.content, 'utf8')) };
+      const prefix = `${mapping.rootPath}/`;
+      if (entry.kind === 'skill' && normalized.startsWith(prefix)) {
+        const assetPath = normalized.slice(prefix.length);
+        const encoded = entry.assets[assetPath];
+        if (typeof encoded === 'string') return { name: path.basename(normalized), path: normalized, content: decodeEditableFile(Buffer.from(encoded, 'base64')) };
+      }
+    }
+    const stored = db.prepare('SELECT content FROM collection_files WHERE collection_id = ? AND path = ?').get(id, normalized) as { content: Buffer } | undefined;
+    if (stored) return { name: path.basename(normalized), path: normalized, content: decodeEditableFile(stored.content) };
+    throw new Error('Fichier introuvable.');
+  }
+
+  function updateCollectionFile(id: string, filePath: string, content: string, previousContent: string) {
+    if (typeof content !== 'string' || typeof previousContent !== 'string') throw new Error('Contenu et version précédente requis.');
+    const normalized = normalizedCollectionPath(filePath);
+    for (const mapping of collectionEntries(id)) {
+      const entry = document(mapping.entryId);
+      const mainPath = collectionMainPath(entry, mapping.rootPath);
+      if (normalized === mainPath) {
+        decodeEditableFile(Buffer.from(entry.content, 'utf8'));
+        decodeEditableFile(Buffer.from(content, 'utf8'));
+        return updateDocument(mapping.entryId, content, previousContent);
+      }
+      const prefix = `${mapping.rootPath}/`;
+      if (entry.kind === 'skill' && normalized.startsWith(prefix)) {
+        return updateAsset(mapping.entryId, normalized.slice(prefix.length), content, previousContent);
+      }
+    }
+    const stored = db.prepare('SELECT content FROM collection_files WHERE collection_id = ? AND path = ?').get(id, normalized) as { content: Buffer } | undefined;
+    if (stored) {
+      const currentContent = decodeEditableFile(stored.content);
+      if (currentContent !== previousContent) throw new Error('Le fichier a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
+      const bytes = Buffer.from(content, 'utf8');
+      if (bytes.length > MAX_EDITABLE_FILE_BYTES || content.includes('\0')) throw new Error('Ce fichier ne peut pas être modifié.');
+      db.prepare('UPDATE collection_files SET content = ? WHERE collection_id = ? AND path = ?').run(bytes, id, normalized);
+      return { path: normalized, content };
+    }
+    throw new Error('Fichier introuvable.');
+  }
+
+  function setCollectionEnabled(workspacePath: unknown, id: string, enabled: unknown) {
+    if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
+    const selected = workspace(workspacePath);
+    const mappings = collectionEntries(id);
+    if (!mappings.length) throw new Error('Plugin introuvable.');
+    const active = new Set((db.prepare('SELECT entry_id AS entryId FROM activation WHERE workspace = ?').all(selected) as Array<{ entryId: string }>).map((entry) => entry.entryId));
+    const changed: string[] = [];
+    try {
+      for (const mapping of mappings) {
+        if (active.has(mapping.entryId) === enabled) continue;
+        setEnabled(selected, mapping.entryId, enabled);
+        changed.push(mapping.entryId);
+      }
+    } catch (error) {
+      for (const entryId of changed.reverse()) setEnabled(selected, entryId, !enabled);
+      throw error;
+    }
+    return listCollections(selected).find((collection) => collection.id === id);
+  }
+
+  function setEnabled(workspacePath: unknown, id: string, enabled: unknown) {
+    if (typeof enabled !== 'boolean') throw new Error('Activation booléenne requise.');
+    const selected = workspace(workspacePath);
+    const entry = document(id);
+    const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), id);
+    const install = prepareWorkspaceInstallation(selected, id, packageRoot, entry.kind, enabled);
+    if (enabled) {
+      fs.mkdirSync(path.dirname(packageRoot), { recursive: true, mode: 0o700 });
+      if (!fs.realpathSync(path.dirname(packageRoot)).startsWith(fs.realpathSync(directory) + path.sep)) throw new Error('Répertoire d’activation non autorisé.');
+      const staging = fs.mkdtempSync(path.join(directory, '.activation-'));
+      const backup = `${staging}.previous`;
+      try {
+        for (const [relative, bytes] of Object.entries(entry.assets)) {
+          const target = path.resolve(staging, relative);
+          if (!target.startsWith(staging + path.sep)) throw new Error('Chemin associé invalide.');
+          fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+          fs.writeFileSync(target, Buffer.from(bytes, 'base64'), { mode: 0o600 });
+        }
+        if (entry.kind === 'skill') fs.writeFileSync(path.join(staging, 'SKILL.md'), entry.content, { mode: 0o600 });
+        else {
+          fs.writeFileSync(path.join(staging, 'agent.md'), entry.content, { mode: 0o600 });
+          const { data, content } = parseFrontMatter(entry.content);
+          const toml = Object.entries({ name: String(data.name || entry.name), description: entry.description || entry.name, developer_instructions: content })
+            .map(([key, value]) => `${key} = ${JSON.stringify(value)}`).join('\n');
+          fs.writeFileSync(path.join(staging, 'agent.toml'), `${toml}\n`, { mode: 0o600 });
+        }
+        if (fs.existsSync(packageRoot)) fs.renameSync(packageRoot, backup);
+        try {
+          fs.renameSync(staging, packageRoot);
+          install();
+        }
+        catch (error) {
+          fs.rmSync(packageRoot, { recursive: true, force: true });
+          if (fs.existsSync(backup)) fs.renameSync(backup, packageRoot);
+          throw error;
+        }
+      } finally {
+        fs.rmSync(staging, { recursive: true, force: true });
+        fs.rmSync(backup, { recursive: true, force: true });
+      }
+    } else if (fs.existsSync(path.dirname(packageRoot))) {
+      if (!fs.realpathSync(path.dirname(packageRoot)).startsWith(fs.realpathSync(directory) + path.sep)) throw new Error('Répertoire d’activation non autorisé.');
+      install();
+      fs.rmSync(packageRoot, { recursive: true, force: true });
+    } else {
+      install();
+    }
+    if (enabled) db.prepare('INSERT OR IGNORE INTO activation VALUES (?, ?)').run(selected, id);
+    else db.prepare('DELETE FROM activation WHERE workspace = ? AND entry_id = ?').run(selected, id);
+    return { ok: true, enabled };
+  }
+
+  function instructions(workspacePath: string) {
+    const selected = workspace(workspacePath);
+    const entries = db.prepare(`SELECT e.* FROM entries e JOIN activation a ON a.entry_id = e.id
+      WHERE a.workspace = ? ORDER BY e.name`).all(selected) as StoredLibraryEntry[];
+    return entries.map((entry) => {
+      const assets = JSON.parse(entry.assets) as Record<string, string>;
+      const references = Object.entries(assets).filter(([name]) => name === 'table-columns.yaml')
+        .map(([name, bytes]) => `### ${name}\n${Buffer.from(bytes, 'base64').toString('utf8')}`);
+      const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), entry.id);
+      return `## ${entry.kind === 'agent' ? 'Instructions de rôle' : 'Skill'} : ${entry.name}\n${entry.content}\n${references.join('\n\n')}\nFichiers associés disponibles dans : ${packageRoot}\n${Object.keys(assets).join('\n')}`;
+    }).join('\n\n');
+  }
+
+  return {
+    directory,
+    list,
+    document,
+    createEntry,
+    deleteEntry,
+    updateDocument,
+    importFile,
+    setEnabled,
+    instructions,
+    upsertCollection,
+    hasCollection,
+    listCollections,
+    collectionFiles,
+    collectionFile,
+    updateCollectionFile,
+    setCollectionEnabled,
+    close: () => db.close(),
+  };
+}