@piecemaker-legal/piecemaker 2.0.18 → 2.0.19

package/server/piecemaker/library/workspace-installation.ts

@@ -1,103 +1,206 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 
-const SKILL_PROVIDERS = ['.claude', '.agents', '.cursor', '.opencode', '.grok'];
+const SKILL_LINK_PROVIDERS = ['.claude', '.cursor', '.opencode', '.grok'];
 
 const AGENT_TARGETS = [
-  { provider: '.claude', folder: 'agents', extension: '.md', sourceFile: 'agent.md' },
-  { provider: '.codex', folder: 'agents', extension: '.toml', sourceFile: 'agent.toml' },
-  { provider: '.opencode', folder: 'agent', extension: '.md', sourceFile: 'agent.md' },
-  { provider: '.grok', folder: 'agents', extension: '.md', sourceFile: 'agent.md' },
+  { provider: '.claude', folder: 'agents', extension: '.md', format: 'markdown' },
+  { provider: '.codex', folder: 'agents', extension: '.toml', format: 'codex' },
+  { provider: '.vibe', folder: 'agents', extension: '.toml', format: 'vibe' },
+  { provider: '.opencode', folder: 'agent', extension: '.md', format: 'markdown' },
+  { provider: '.grok', folder: 'agents', extension: '.md', format: 'markdown' },
 ] as const;
 
+const MANIFEST_PATH = '.piecemaker/library.json';
+
+export type LibraryManifestEntry = {
+  id: string;
+  kind: 'skill' | 'agent' | 'connector';
+  name: string;
+  slug: string;
+  files: Record<string, string>;
+  skipClaude: boolean;
+};
+
+export type LibraryComponent =
+  | { kind: 'skill'; slug: string; files: Record<string, Buffer> }
+  | { kind: 'agent'; slug: string; markdown: string; codex: string; vibe: string };
+
 export function componentFolderName(name: string) {
   const slug = String(name).normalize('NFKD').replace(/[^\p{Letter}\p{Number}._-]+/gu, '-').replace(/^[-._]+|[-._]+$/g, '');
   if (!slug) throw new Error(`Nom de composant inutilisable : ${name}`);
   return slug;
 }
 
-function assertWorkspaceDirectory(workspace: string, directory: string, enabled: boolean) {
-  if (!fs.existsSync(directory)) {
-    if (enabled) fs.mkdirSync(directory);
-    return;
+function digest(bytes: Buffer) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+function assertWorkspaceParents(workspace: string, relative: string, create: boolean) {
+  let directory = workspace;
+  for (const segment of path.posix.dirname(relative).split('/')) {
+    directory = path.join(directory, segment);
+    if (!fs.existsSync(directory)) {
+      if (!create) return;
+      fs.mkdirSync(directory);
+    } else if (!fs.statSync(directory).isDirectory() || !fs.realpathSync(directory).startsWith(workspace + path.sep)) {
+      throw new Error(`Répertoire de composants hors du dossier : ${directory}`);
+    }
+  }
+}
+
+export function readLibraryManifest(workspace: string): LibraryManifestEntry[] | null {
+  const filename = path.join(workspace, MANIFEST_PATH);
+  if (!fs.existsSync(filename)) return null;
+  try {
+    const entries = JSON.parse(fs.readFileSync(filename, 'utf8')).entries;
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
   }
-  if (!fs.statSync(directory).isDirectory() || !fs.realpathSync(directory).startsWith(workspace + path.sep)) {
-    throw new Error(`Répertoire de composants hors du dossier : ${directory}`);
+}
+
+export function writeLibraryManifest(workspace: string, entries: LibraryManifestEntry[]) {
+  assertWorkspaceParents(workspace, MANIFEST_PATH, true);
+  const filename = path.join(workspace, MANIFEST_PATH);
+  const temporary = `${filename}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify({ version: 1, entries }, null, 2)}\n`);
+  fs.renameSync(temporary, filename);
+}
+
+function skillRoot(slug: string) {
+  return path.posix.join('.agents', 'skills', slug);
+}
+
+function componentShape(kind: LibraryManifestEntry['kind'], slug: string, skipClaude: boolean) {
+  if (kind !== 'skill') return { root: null, links: [] as string[] };
+  return {
+    root: skillRoot(slug),
+    links: SKILL_LINK_PROVIDERS.filter((provider) => !(skipClaude && provider === '.claude')).map((provider) => path.posix.join(provider, 'skills', slug)),
+  };
+}
+
+function componentFiles(workspace: string, component: LibraryComponent, skipClaude: boolean) {
+  if (component.kind === 'agent') {
+    return Object.fromEntries(AGENT_TARGETS.filter((target) => !(skipClaude && target.provider === '.claude')).map((target) => [
+      path.posix.join(target.provider, target.folder, `${component.slug}${target.extension}`),
+      Buffer.from(component[target.format], 'utf8'),
+    ]));
+  }
+  const root = skillRoot(component.slug);
+  return Object.fromEntries(Object.entries(component.files).map(([name, bytes]) => {
+    const relative = path.posix.join(root, name);
+    if (!path.resolve(workspace, relative).startsWith(path.join(workspace, root) + path.sep)) throw new Error('Chemin associé invalide.');
+    return [relative, bytes];
+  }));
+}
+
+export function componentFileHashes(workspace: string, component: LibraryComponent, skipClaude: boolean) {
+  return Object.fromEntries(Object.entries(componentFiles(workspace, component, skipClaude)).map(([relative, bytes]) => [relative, digest(bytes)]));
+}
+
+function walkFiles(workspace: string, relative: string, visit: (relative: string) => void) {
+  for (const child of fs.readdirSync(path.join(workspace, relative), { withFileTypes: true })) {
+    const childPath = path.posix.join(relative, child.name);
+    if (child.isDirectory()) walkFiles(workspace, childPath, visit);
+    else visit(childPath);
   }
 }
 
-export function prepareWorkspaceInstallation(workspace: string, id: string, name: string, packageRoot: string, kind: 'skill' | 'agent', enabled: boolean) {
-  const slug = componentFolderName(name);
-  const targets = kind === 'skill'
-    ? SKILL_PROVIDERS.map((provider) => {
-      const parent = path.join(workspace, provider, 'skills');
-      for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
-      return {
-        parent,
-        target: path.join(parent, slug),
-        legacy: path.join(parent, `piecemaker-${id}`),
-        source: packageRoot,
-        kind: 'skill' as const,
-      };
-    })
-    : AGENT_TARGETS.map((entry) => {
-      const parent = path.join(workspace, entry.provider, entry.folder);
-      for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
-      return {
-        parent,
-        target: path.join(parent, `${slug}${entry.extension}`),
-        legacy: path.join(parent, `piecemaker-${id}${entry.extension}`),
-        source: path.join(packageRoot, entry.sourceFile),
-        kind: 'agent' as const,
-      };
-    });
-
-  const prepared = targets.map((entry) => {
+export function removeLegacyLinks(workspace: string, legacyDirectory: string) {
+  for (const provider of ['.agents', ...SKILL_LINK_PROVIDERS]) {
+    const parent = path.join(workspace, provider, 'skills');
+    if (!fs.existsSync(parent) || !fs.realpathSync(parent).startsWith(workspace + path.sep)) continue;
+    for (const child of fs.readdirSync(parent, { withFileTypes: true })) {
+      if (!child.isSymbolicLink()) continue;
+      const link = path.join(parent, child.name);
+      if (path.resolve(parent, fs.readlinkSync(link)).startsWith(legacyDirectory + path.sep)) fs.unlinkSync(link);
+    }
+  }
+}
+
+export function prepareWorkspaceInstallation(
+  workspace: string,
+  previous: LibraryManifestEntry | undefined,
+  next: { component: LibraryComponent; skipClaude: boolean } | null,
+) {
+  const before = previous ? componentShape(previous.kind, previous.slug, previous.skipClaude) : null;
+  const after = next ? componentShape(next.component.kind, next.component.slug, next.skipClaude) : null;
+  const nextFiles = next ? componentFiles(workspace, next.component, next.skipClaude) : {};
+  const owned = previous?.files ?? {};
+
+  for (const relative of [...Object.keys(nextFiles), ...(after?.links ?? [])]) assertWorkspaceParents(workspace, relative, true);
+  for (const relative of [...Object.keys(owned), ...(before?.links ?? [])]) assertWorkspaceParents(workspace, relative, false);
+
+  const snapshots = new Map<string, Buffer>();
+  const inspect = (relative: string) => {
+    const absolute = path.join(workspace, relative);
     let existing: fs.Stats;
-    try { existing = fs.lstatSync(entry.target); }
+    try { existing = fs.lstatSync(absolute); }
     catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { ...entry, installed: false, content: null };
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
       throw error;
     }
-    const content = entry.kind === 'agent' && existing.isFile() ? fs.readFileSync(entry.target) : null;
-    const owned = entry.kind === 'skill'
-      ? existing.isSymbolicLink() && path.resolve(entry.parent, fs.readlinkSync(entry.target)) === entry.source
-      : content && fs.existsSync(entry.source) && content.equals(fs.readFileSync(entry.source));
-    if (!owned) throw new Error(`Composant personnel préservé : ${entry.target}`);
-    return { ...entry, installed: true, content };
-  });
-
-  return () => {
-    const changed: typeof prepared = [];
-    try {
-      for (const entry of prepared) {
-        const { target, source, installed, kind: targetKind } = entry;
-        if (enabled && targetKind === 'agent') {
-          fs.copyFileSync(source, target);
-          changed.push(entry);
-        } else if (enabled && !installed) {
-          fs.symlinkSync(source, target, process.platform === 'win32' ? 'junction' : 'dir');
-          changed.push(entry);
-        } else if (!enabled && installed) {
-          fs.unlinkSync(target);
-          changed.push(entry);
-        }
+    const bytes = existing.isFile() ? fs.readFileSync(absolute) : null;
+    if (!bytes || owned[relative] !== digest(bytes)) throw new Error(`Composant personnel préservé : ${absolute}`);
+    snapshots.set(relative, bytes);
+  };
+  for (const relative of new Set([...Object.keys(owned), ...Object.keys(nextFiles)])) inspect(relative);
+  for (const root of new Set([before?.root, after?.root])) {
+    if (!root || !fs.existsSync(path.join(workspace, root))) continue;
+    if (!fs.lstatSync(path.join(workspace, root)).isDirectory()) throw new Error(`Composant personnel préservé : ${path.join(workspace, root)}`);
+    walkFiles(workspace, root, inspect);
+  }
+
+  const existingLinks = new Map<string, string>();
+  for (const shape of [before, after]) {
+    for (const link of shape?.links ?? []) {
+      const absolute = path.join(workspace, link);
+      let existing: fs.Stats;
+      try { existing = fs.lstatSync(absolute); }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw error;
       }
-    } catch (error) {
-      for (const { target, source, content, installed } of changed.reverse()) {
-        if (content) fs.writeFileSync(target, content);
-        else if (!installed) fs.unlinkSync(target);
-        else fs.symlinkSync(source, target, process.platform === 'win32' ? 'junction' : 'dir');
+      const target = path.join(workspace, shape!.root!);
+      if (!existing.isSymbolicLink() || path.resolve(path.dirname(absolute), fs.readlinkSync(absolute)) !== target) {
+        throw new Error(`Composant personnel préservé : ${absolute}`);
       }
-      throw error;
-    }
-    for (const { legacy, source, kind: targetKind } of prepared) {
-      let existing: fs.Stats;
-      try { existing = fs.lstatSync(legacy); } catch { continue; }
-      const owned = targetKind === 'skill'
-        ? existing.isSymbolicLink() && fs.existsSync(source) && fs.realpathSync(legacy) === fs.realpathSync(source)
-        : existing.isFile() && fs.existsSync(source) && fs.readFileSync(legacy).equals(fs.readFileSync(source));
-      if (owned) fs.unlinkSync(legacy);
+      existingLinks.set(link, target);
     }
+  }
+
+  const link = (relative: string, target: string) => {
+    const absolute = path.join(workspace, relative);
+    if (process.platform === 'win32') fs.symlinkSync(target, absolute, 'junction');
+    else fs.symlinkSync(path.relative(path.dirname(absolute), target), absolute, 'dir');
+  };
+  const clear = (links: Iterable<string>, files: Iterable<string>, root: string | null | undefined) => {
+    for (const relative of links) fs.rmSync(path.join(workspace, relative), { force: true });
+    for (const relative of files) fs.rmSync(path.join(workspace, relative), { force: true });
+    if (root) fs.rmSync(path.join(workspace, root), { recursive: true, force: true });
+  };
+
+  return {
+    files: Object.fromEntries(Object.entries(nextFiles).map(([relative, bytes]) => [relative, digest(bytes)])),
+    commit() {
+      try {
+        clear(existingLinks.keys(), snapshots.keys(), before?.root);
+        for (const [relative, bytes] of Object.entries(nextFiles)) {
+          fs.mkdirSync(path.dirname(path.join(workspace, relative)), { recursive: true });
+          fs.writeFileSync(path.join(workspace, relative), bytes);
+        }
+        for (const relative of after?.links ?? []) link(relative, path.join(workspace, after!.root!));
+      } catch (error) {
+        clear(after?.links ?? [], Object.keys(nextFiles), after?.root);
+        for (const [relative, bytes] of snapshots) {
+          fs.mkdirSync(path.dirname(path.join(workspace, relative)), { recursive: true });
+          fs.writeFileSync(path.join(workspace, relative), bytes);
+        }
+        for (const [relative, target] of existingLinks) link(relative, target);
+        throw error;
+      }
+    },
   };
 }

package/dist/assets/channel-D3azUhJc.js

@@ -1 +0,0 @@
-import{U as a,Q as n}from"./mermaid.core-D8tIoFkX.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/classDiagram-ZZMXUADV-D21ZjmLK.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K-Dz1p6b2C.js";import{_ as i}from"./mermaid.core-D8tIoFkX.js";import"./chunk-5VM5RSS4-ivUrz7aY.js";import"./chunk-XXDRQBXY-D-WMIjOd.js";import"./chunk-POPQ4Y6H-CsWglKL-.js";import"./chunk-F27PBJKO-F9_wuwt8.js";import"./index-DN3QXejg.js";import"./vendor-codemirror-CN-sJePf.js";import"./vendor-react-B22wqN3J.js";import"./vendor-xterm-BWUgpGtR.js";var c={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{c as diagram};

package/dist/assets/classDiagram-v2-VYDZK3BY-D21ZjmLK.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-TICWLB2K-Dz1p6b2C.js";import{_ as i}from"./mermaid.core-D8tIoFkX.js";import"./chunk-5VM5RSS4-ivUrz7aY.js";import"./chunk-XXDRQBXY-D-WMIjOd.js";import"./chunk-POPQ4Y6H-CsWglKL-.js";import"./chunk-F27PBJKO-F9_wuwt8.js";import"./index-DN3QXejg.js";import"./vendor-codemirror-CN-sJePf.js";import"./vendor-react-B22wqN3J.js";import"./vendor-xterm-BWUgpGtR.js";var c={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{c as diagram};

package/dist/assets/swimlanesDiagram-VR7AAH4N-CYL9hbZV.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-HODETNUW-DtxPis5B.js";import{_ as a}from"./mermaid.core-D8tIoFkX.js";import"./chunk-5VM5RSS4-ivUrz7aY.js";import"./chunk-XXDRQBXY-D-WMIjOd.js";import"./chunk-POPQ4Y6H-CsWglKL-.js";import"./chunk-F27PBJKO-F9_wuwt8.js";import"./index-DN3QXejg.js";import"./vendor-codemirror-CN-sJePf.js";import"./vendor-react-B22wqN3J.js";import"./vendor-xterm-BWUgpGtR.js";import"./channel-D3azUhJc.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),m=o,g=r({defaultLayout:"swimlane",styles:m});export{g as diagram};

package/dist-server/server/piecemaker/library/migrate-cli.js

@@ -1,13 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { createLibraryStore } from './store.js';
-import { migratePersonalLibrary } from './migrate.js';
-const store = createLibraryStore(process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker'));
-try {
-    const imported = migratePersonalLibrary(store, os.homedir(), process.cwd(), process.argv.includes('--withdraw'));
-    process.stdout.write(`${JSON.stringify({ imported: imported.map(({ id, source }) => ({ id, source })), catalog: store.list() }, null, 2)}\n`);
-}
-finally {
-    store.close();
-}
-//# sourceMappingURL=migrate-cli.js.map

package/dist-server/server/piecemaker/library/migrate-cli.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrate-cli.js","sourceRoot":"","sources":["../../../../server/piecemaker/library/migrate-cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,KAAK,GAAG,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC;AACxG,IAAI,CAAC;IACH,MAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;IACjH,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;AAChJ,CAAC;QAAS,CAAC;IAAC,KAAK,CAAC,KAAK,EAAE,CAAC;AAAC,CAAC"}

package/server/piecemaker/library/migrate-cli.ts

@@ -1,11 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-import { createLibraryStore } from './store.js';
-import { migratePersonalLibrary } from './migrate.js';
-
-const store = createLibraryStore(process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker'));
-try {
-  const imported = migratePersonalLibrary(store, os.homedir(), process.cwd(), process.argv.includes('--withdraw'));
-  process.stdout.write(`${JSON.stringify({ imported: imported.map(({ id, source }) => ({ id, source })), catalog: store.list() }, null, 2)}\n`);
-} finally { store.close(); }