@piecemaker-legal/piecemaker 1.0.6

package/server/piecemaker/index.ts

@@ -0,0 +1,62 @@
+import { createRequire } from 'module';
+import path from 'path';
+
+import type { Router } from 'express';
+
+import { providerRuntimeService, sessionsService } from '@/modules/providers/index.js';
+import { findApplicationRoot, getModuleDirectory } from '@/shared/utils.js';
+
+import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
+import { createCitationStore } from './harness/citation-store.js';
+import { installChatCitationHarness } from './harness/chat-harness.js';
+import { createCitationsRouter } from './harness/citations.routes.js';
+import { startLibraryBackend, installLibraryRuntime } from './library/index.js';
+import { createKnowledgeBackend } from './knowledge/index.js';
+import { createTimesheetBackend } from './timesheet/index.js';
+
+/**
+ * Point d'entrée PieceMaker. Les modules de `server/piecemaker/vendor/` sont du
+ * CommonJS : `createRequire` les charge tels quels, sans les convertir ni les
+ * faire passer par `tsc`.
+ *
+ * Le chemin est résolu depuis la racine applicative, pas depuis `__dirname` :
+ * compilé, ce fichier vit sous `dist-server/server/piecemaker/`, alors que le
+ * `vendor/` (CommonJS, Python, gabarits Markdown) reste dans l'arbre source.
+ */
+const applicationRoot = findApplicationRoot(getModuleDirectory(import.meta.url));
+const routerPath = path.join(applicationRoot, 'server', 'piecemaker', 'router.cjs');
+
+type PieceMakerRuntimeStatus = {
+  port?: number | string;
+  host?: string;
+  libreOffice?: boolean;
+};
+
+type PieceMakerVendorModule = {
+  createPieceMakerRouter(options?: { getRuntimeStatus?: () => PieceMakerRuntimeStatus; anonymizer?: unknown }): Router;
+  piecemakerHome(): string;
+};
+
+const vendor = createRequire(import.meta.url)(routerPath) as PieceMakerVendorModule;
+
+export const { piecemakerHome } = vendor;
+const { createAnonymizerService } = createRequire(import.meta.url)(path.join(applicationRoot, 'server/piecemaker/anonymizer/service.cjs'));
+const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required: true });
+const ensureProxy = await startRequiredAnonymizer(anonymizer);
+const citations = createCitationStore(piecemakerHome());
+installChatCitationHarness({ runtime: providerRuntimeService, sessions: sessionsService, store: citations, ensureProxy });
+const library = await startLibraryBackend(piecemakerHome(), applicationRoot);
+installLibraryRuntime(providerRuntimeService, sessionsService, library);
+const timesheet = createTimesheetBackend(piecemakerHome());
+const knowledge = createKnowledgeBackend(applicationRoot);
+
+export function createPieceMakerRouter(options: { getRuntimeStatus?: () => PieceMakerRuntimeStatus } = {}) {
+  const router = vendor.createPieceMakerRouter({ ...options, anonymizer });
+  router.use(createCitationsRouter(citations, (id) => {
+    try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
+  }));
+  router.use(timesheet);
+  router.use(knowledge);
+  return router;
+}
+export type { PieceMakerRuntimeStatus };

package/server/piecemaker/knowledge/index.ts

@@ -0,0 +1,22 @@
+import express from 'express';
+
+import { getConnection, projectsDb } from '@/modules/database/index.js';
+
+import { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
+import { createKnowledgePipeline } from './pipeline.js';
+import { createKnowledgeRouter } from './routes.js';
+import { createKnowledgeService } from './service.js';
+
+export function createKnowledgeBackend(applicationRoot: string) {
+  const router = express.Router();
+  let knowledgeRouter: express.Router | null = null;
+  router.use((request, response, next) => {
+    if (!knowledgeRouter) {
+      const store = new KnowledgeStore(getConnection());
+      const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store });
+      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(store, projectsDb, pipeline));
+    }
+    knowledgeRouter(request, response, next);
+  });
+  return router;
+}

package/server/piecemaker/knowledge/pipeline.ts

@@ -0,0 +1,173 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
+import type { GlinerDocument, GlinerMappingDocument, JsonData } from '../../../plugins/piecemaker-dossier/src/types.js';
+import { persistScanResult, scanResultOperations } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
+
+type ProjectLookup = {
+  getProjectById(projectId: string): { project_id: string; project_path: string } | null;
+};
+
+type PipelineOptions = {
+  applicationRoot: string;
+  projects: ProjectLookup;
+  store: KnowledgeStore;
+  pythonPath?: string;
+};
+
+const SUPPORTED_EXTENSIONS = new Set(['.pdf', '.docx', '.doc', '.odt', '.rtf', '.txt', '.md', '.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp']);
+
+function relativeKey(projectPath: string, filePath: string): string {
+  const relative = path.relative(projectPath, filePath).split(path.sep).join('/').normalize('NFC');
+  return crypto.createHash('sha256').update(relative).digest('hex');
+}
+
+function listedFiles(projectPath: string): string[] {
+  return fs.readdirSync(projectPath, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && SUPPORTED_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
+    .map((entry) => path.join(projectPath, entry.name));
+}
+
+function safeFiles(projectPath: string, requested: unknown): string[] {
+  const root = fs.realpathSync(projectPath);
+  const candidates = Array.isArray(requested) && requested.length ? requested : listedFiles(root);
+  return [...new Set(candidates.map((candidate) => {
+    const raw = String(candidate || '');
+    const resolved = path.resolve(root, raw);
+    const real = fs.realpathSync(resolved);
+    if (real !== root && !real.startsWith(`${root}${path.sep}`)) throw new Error('File outside project.');
+    if (!fs.statSync(real).isFile() || !SUPPORTED_EXTENSIONS.has(path.extname(real).toLowerCase())) throw new Error('Unsupported file.');
+    return real;
+  }))];
+}
+
+function runProcess(executable: string, args: string[], cwd: string): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, { cwd, env: process.env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('close', (code) => {
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(stderr.trim() || stdout.trim() || `Pipeline failed with code ${code ?? 1}.`));
+    });
+  });
+}
+
+function parseObject(filePath: string): JsonData {
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8').replace(/^/, '')) as unknown;
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('Invalid pipeline output.');
+  return parsed as JsonData;
+}
+
+function documentsFromIndex(projectPath: string, files: string[], documentIndex: JsonData): GlinerDocument[] {
+  const entries = documentIndex.documents && typeof documentIndex.documents === 'object' && !Array.isArray(documentIndex.documents)
+    ? documentIndex.documents as Record<string, JsonData>
+    : {};
+  return files.map((filePath) => {
+    const id = relativeKey(projectPath, filePath);
+    const metadata = entries[id] && typeof entries[id] === 'object' ? entries[id] : {};
+    const entityCodes = Array.isArray(metadata.personnes_visees)
+      ? metadata.personnes_visees.filter((value): value is string => typeof value === 'string')
+      : [];
+    return { id, name: path.basename(filePath), path: filePath, metadata, entityCodes };
+  });
+}
+
+function pythonExecutable(explicit: string | undefined): string {
+  if (explicit) return explicit;
+  if (process.env.PYTHON_PATH) return process.env.PYTHON_PATH;
+  const home = process.env.PIECEMAKER_HOME || path.join(os.homedir(), '.piecemaker');
+  const candidate = process.platform === 'win32'
+    ? path.join(home, 'venv', 'Scripts', 'python.exe')
+    : path.join(home, 'venv', 'bin', 'python');
+  return fs.existsSync(candidate) ? candidate : 'python3';
+}
+
+export function legacyExclusions(projectPath: string): string[] {
+  const candidate = path.join(projectPath, 'Fichiers convertis PieceMaker', 'mapping_default.json');
+  if (!fs.existsSync(candidate)) return [];
+  try {
+    const document = parseObject(candidate);
+    return Array.isArray(document.ignored) ? document.ignored.map(textValue).filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function mappingSeed(projectId: string, projectPath: string, store: KnowledgeStore): GlinerMappingDocument {
+  const snapshot = store.snapshot(projectId);
+  const mapping: Record<string, string> = {};
+  const reverseMapping: Record<string, string[]> = {};
+  const extractedData: Record<string, Record<string, JsonData>> = {};
+  for (const entry of snapshot.mappings) {
+    mapping[entry.real] = entry.masked;
+    reverseMapping[entry.masked] = [...new Set([...(reverseMapping[entry.masked] || []), entry.real])];
+  }
+  for (const node of snapshot.nodes) {
+    if (node.kind === 'document') continue;
+    const code = textValue(node.data.code);
+    const category = textValue(node.data.category) || 'autres';
+    if (!code) continue;
+    extractedData[category] ||= {};
+    extractedData[category][code] = node.data;
+  }
+  const ignored = snapshot.exclusionsInitialized ? snapshot.exclusions || [] : legacyExclusions(projectPath);
+  return { mapping, reverse_mapping: reverseMapping, extracted_data: extractedData, ignored };
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function createKnowledgePipeline(options: PipelineOptions) {
+  const script = path.join(options.applicationRoot, 'server', 'piecemaker', 'vendor', 'websocket-server', 'scripts', 'convert_and_scan_pipeline.py');
+  return {
+    async scan(projectId: string, requestedFiles?: unknown) {
+      const project = options.projects.getProjectById(projectId);
+      if (!project) throw new Error('Project not found.');
+      const projectPath = fs.realpathSync(project.project_path);
+      const files = safeFiles(projectPath, requestedFiles);
+      if (!files.length) throw new Error('No supported file to scan.');
+      const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'piecemaker-knowledge-'));
+      const mappingFile = path.join(temporaryRoot, 'mapping.json');
+      const stateFile = path.join(temporaryRoot, 'state.json');
+      const outputDirectory = path.join(projectPath, 'Fichiers convertis PieceMaker');
+      fs.mkdirSync(outputDirectory, { recursive: true });
+      try {
+        fs.writeFileSync(mappingFile, JSON.stringify(mappingSeed(projectId, projectPath, options.store)), { mode: 0o600 });
+        const args = [
+          script,
+          ...files,
+          '-o',
+          outputDirectory,
+          '--mapping-file',
+          mappingFile,
+          '--case-root',
+          projectPath,
+          '--state-file',
+          stateFile,
+        ];
+        const processResult = await runProcess(pythonExecutable(options.pythonPath), args, projectPath);
+        const mapping = parseObject(mappingFile) as GlinerMappingDocument;
+        const documentIndex = parseObject(path.join(temporaryRoot, 'document-index.json'));
+        const documents = documentsFromIndex(projectPath, files, documentIndex);
+        const scanResult = { projectId, mapping, documents };
+        const result = Array.isArray(requestedFiles) && requestedFiles.length
+          ? options.store.update({ projectId, operations: scanResultOperations(scanResult) })
+          : persistScanResult(scanResult, options.store);
+        return { ...result, documents: documents.length, stdout: processResult.stdout.trim(), stderr: processResult.stderr.trim() };
+      } finally {
+        fs.rmSync(temporaryRoot, { recursive: true, force: true });
+      }
+    },
+  };
+}

package/server/piecemaker/knowledge/routes.ts

@@ -0,0 +1,29 @@
+import express from 'express';
+
+import type { createKnowledgeService } from './service.js';
+
+type KnowledgeService = ReturnType<typeof createKnowledgeService>;
+
+function statusFor(error: unknown): number {
+  if (error instanceof TypeError) return 400;
+  if (error instanceof Error && error.message === 'Project not found.') return 404;
+  return 500;
+}
+
+export function createKnowledgeRouter(service: KnowledgeService) {
+  const router = express.Router();
+  const respond = (operation: () => unknown | Promise<unknown>, response: express.Response) => {
+    Promise.resolve().then(operation).then((result) => response.json(result)).catch((error: unknown) => {
+      response.status(statusFor(error)).json({ error: error instanceof Error ? error.message : 'Knowledge operation failed.' });
+    });
+  };
+  router.get('/knowledge/overview', (request, response) => respond(() => service.overview(request.query.projectId), response));
+  router.get('/knowledge/mapping', (request, response) => respond(() => service.mapping(request.query.projectId), response));
+  router.get('/knowledge/chronology', (request, response) => respond(() => service.chronology(request.query.projectId), response));
+  router.get('/knowledge/graph', (request, response) => respond(() => service.graph(request.query.projectId), response));
+  router.get('/knowledge/agents', (request, response) => respond(() => service.agents(request.query.projectId), response));
+  router.post('/knowledge/query', (request, response) => respond(() => service.query(request.body), response));
+  router.post('/knowledge/update', (request, response) => respond(() => service.update(request.body), response));
+  router.post('/knowledge/scan', (request, response) => respond(() => service.scan(request.body?.projectId, request.body?.files), response));
+  return router;
+}

package/server/piecemaker/knowledge/service.ts

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
+import { exclusionNodeOperation } from '../../../plugins/piecemaker-dossier/src/scan-result.js';
+import type { KnowledgeQueryInput, KnowledgeUpdateInput } from '../../../plugins/piecemaker-dossier/src/types.js';
+import { legacyExclusions } from './pipeline.js';
+import type { createKnowledgePipeline } from './pipeline.js';
+
+type ProjectLookup = {
+  getProjectById(projectId: string): { project_id: string; project_path: string } | null;
+};
+
+function projectId(value: unknown): string {
+  if (typeof value !== 'string' || !value.trim()) throw new TypeError('projectId is required.');
+  return value.trim();
+}
+
+export function createKnowledgeService(store: KnowledgeStore, projects: ProjectLookup, pipeline: ReturnType<typeof createKnowledgePipeline>) {
+  const ensureProject = (value: unknown): string => {
+    const id = projectId(value);
+    if (!projects.getProjectById(id)) throw new Error('Project not found.');
+    return id;
+  };
+  const snapshot = (id: string) => {
+    const current = store.snapshot(id);
+    if (current.exclusionsInitialized) return current;
+    const project = projects.getProjectById(id);
+    const values = project ? legacyExclusions(project.project_path) : [];
+    if (!values.length) return current;
+    const operation = exclusionNodeOperation(values);
+    store.update({ projectId: id, operations: [operation] });
+    return store.snapshot(id);
+  };
+  return {
+    query(input: KnowledgeQueryInput) {
+      return store.query({ ...input, projectId: ensureProject(input.projectId), projectPath: undefined });
+    },
+    update(input: KnowledgeUpdateInput) {
+      return store.update({ ...input, projectId: ensureProject(input.projectId) });
+    },
+    overview(value: unknown) {
+      const id = ensureProject(value);
+      const nodes = snapshot(id).nodes;
+      const counts = nodes.reduce<Record<string, number>>((result, node) => {
+        result[node.kind] = (result[node.kind] || 0) + 1;
+        return result;
+      }, {});
+      return { projectId: id, counts, total: nodes.length };
+    },
+    mapping(value: unknown) {
+      const id = ensureProject(value);
+      const current = snapshot(id);
+      return { projectId: id, nodes: current.nodes.filter((node) => node.kind !== 'document'), mappings: current.mappings, exclusions: current.exclusions || [] };
+    },
+    chronology(value: unknown) {
+      const id = ensureProject(value);
+      const current = snapshot(id);
+      return { projectId: id, documents: current.nodes.filter((node) => node.kind === 'document'), links: current.links.filter((link) => link.relation === 'mentions') };
+    },
+    graph(value: unknown) {
+      const id = ensureProject(value);
+      return snapshot(id);
+    },
+    agents(value: unknown) {
+      const id = ensureProject(value);
+      const project = projects.getProjectById(id);
+      if (!project) throw new Error('Project not found.');
+      const root = fs.realpathSync(project.project_path);
+      const candidate = path.join(root, 'AGENTS.md');
+      if (!fs.existsSync(candidate)) return { projectId: id, content: '', exists: false };
+      const real = fs.realpathSync(candidate);
+      if (real !== root && !real.startsWith(`${root}${path.sep}`)) throw new Error('Invalid AGENTS.md path.');
+      return { projectId: id, content: fs.readFileSync(real, 'utf8').slice(0, 2_000_000), exists: true };
+    },
+    scan(value: unknown, files?: unknown) {
+      return pipeline.scan(ensureProject(value), files);
+    },
+  };
+}

package/server/piecemaker/library/index.ts

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { createRequire } from 'node:module';
+
+import express from 'express';
+
+import { createLibraryStore } from './store.js';
+import { createLibraryRouter } from './routes.js';
+import { createLibraryMarketplaceRouter, scanInstalledLibraryCollections } from './marketplace.js';
+import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
+
+export { installLibraryRuntime } from './runtime.js';
+
+export async function startLibraryBackend(home: string, applicationRoot: string) {
+  const store = createLibraryStore(home);
+  try { await scanAndPersistLibraryProviderSkills(store, undefined); } catch {}
+  try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
+  const require = createRequire(import.meta.url);
+  const { createActivationRouter } = require(path.join(applicationRoot, 'server/piecemaker/activation/index.cjs'));
+  const options = { repoRoot: path.join(applicationRoot, 'server/piecemaker/vendor'), piecemakerHome: home, homeDir: home, userHome: os.homedir(), isOriginAllowed: () => true };
+  const token = randomBytes(32).toString('hex');
+  const app = express();
+  app.use((req, res, next) => {
+    if (req.headers.authorization !== `Bearer ${token}`) { res.sendStatus(401); return; }
+    res.setHeader('Cache-Control', 'no-store');
+    next();
+  });
+  app.use(express.json({ limit: '1mb' }));
+  app.use(createLibraryRouter(store));
+  app.use(createLibraryMarketplaceRouter(store, applicationRoot, os.homedir()));
+  app.use((req, res, next) => {
+    if ((req.method === 'GET' && req.path === '/activation')
+      || (req.method === 'POST' && req.path === '/activation/toggle')) { next(); return; }
+    res.sendStatus(404);
+  });
+  app.use(createActivationRouter(options));
+  const server = app.listen(0, '127.0.0.1');
+  await new Promise<void>((resolve, reject) => { server.once('listening', resolve); server.once('error', reject); });
+  const address = server.address();
+  if (!address || typeof address === 'string') throw new Error('Bibliothèque indisponible.');
+  const connection = path.join(store.directory, 'connection.json');
+  const temporary = `${connection}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify({ port: address.port, token }), { mode: 0o600 });
+  fs.renameSync(temporary, connection);
+  server.unref();
+  process.once('exit', () => {
+    try {
+      if (JSON.parse(fs.readFileSync(connection, 'utf8')).token === token) fs.unlinkSync(connection);
+    } catch {}
+  });
+  return store;
+}

package/server/piecemaker/library/marketplace.ts

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+
+import express from 'express';
+
+import type { createLibraryStore } from './store.js';
+import { importLibraryDirectory } from './migrate.js';
+
+type MarketplaceKind = 'connector' | 'skill' | 'plugin' | 'agent';
+
+function marketplaceManifest(userHome: string, marketplaceName: string) {
+  const root = path.join(userHome, '.claude', 'plugins', 'marketplaces', marketplaceName);
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(root, '.claude-plugin', 'marketplace.json'), 'utf8'));
+    return { root, plugins: Array.isArray(manifest.plugins) ? manifest.plugins : [] };
+  } catch {
+    return { root, plugins: [] };
+  }
+}
+
+function marketplacePackageKinds(userHome: string, marketplaceName: string, plugin: { id: string; name: string; description?: string }, registry: Record<string, unknown>) {
+  const kinds = new Set<MarketplaceKind>(['plugin']);
+  const pluginName = plugin.id.split('@')[0];
+  const marketplace = marketplaceManifest(userHome, marketplaceName);
+  const entry = marketplace.plugins.find((candidate: { name?: string }) => candidate?.name === pluginName);
+  const installs = Array.isArray(registry[plugin.id]) ? registry[plugin.id] as Array<{ installPath?: string }> : [];
+  const installedRoot = installs.find((install) => typeof install?.installPath === 'string')?.installPath;
+  const sourceRoot = typeof entry?.source === 'string' && entry.source.startsWith('.')
+    ? path.resolve(marketplace.root, entry.source)
+    : undefined;
+  const root = installedRoot || sourceRoot;
+  if (root && fs.existsSync(root)) {
+    if (fs.existsSync(path.join(root, '.mcp.json'))) kinds.add('connector');
+    if (fs.existsSync(path.join(root, 'skills')) || fs.existsSync(path.join(root, 'commands'))) kinds.add('skill');
+    if (fs.existsSync(path.join(root, 'agents'))) kinds.add('agent');
+  }
+  if (Array.isArray(entry?.skills) && entry.skills.length) kinds.add('skill');
+  const searchable = `${plugin.name} ${plugin.description || ''}`.toLowerCase();
+  if (/\bmcp\b|\bconnect(?:or|eur|s|ed|ion)?\b|\bintegration\b/.test(searchable)) kinds.add('connector');
+  if (/\bskills?\b|\btoolkit\b|\bworkflow\b/.test(searchable)) kinds.add('skill');
+  if (/\bagents?\b/.test(searchable)) kinds.add('agent');
+  return [...kinds];
+}
+
+export function scanInstalledLibraryCollections(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+  const registry = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
+  const pluginsDirectory = path.join(userHome, '.claude', 'plugins');
+  if (!fs.existsSync(pluginsDirectory) || fs.lstatSync(pluginsDirectory).isSymbolicLink()) return;
+  const pluginsRoot = fs.realpathSync(pluginsDirectory);
+  for (const [id, installs] of Object.entries(registry)) {
+    if (store.hasCollection(id)) continue;
+    if (!Array.isArray(installs)) continue;
+    const install = installs.find((entry) => entry && typeof entry.installPath === 'string') as { installPath: string } | undefined;
+    if (!install || !fs.existsSync(install.installPath)) continue;
+    const installRoot = fs.realpathSync(install.installPath);
+    if (!installRoot.startsWith(`${pluginsRoot}${path.sep}`)) continue;
+    let manifest: { name?: string; displayName?: string; description?: string } = {};
+    const manifestPath = path.join(installRoot, '.claude-plugin', 'plugin.json');
+    try { manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); } catch {}
+    const imported = [
+      ...importLibraryDirectory(store, path.join(installRoot, 'skills'), 'skill', false),
+      ...importLibraryDirectory(store, path.join(installRoot, 'agents'), 'agent', false),
+    ];
+    const commandsDirectory = path.join(installRoot, 'commands');
+    if (fs.existsSync(commandsDirectory) && !fs.lstatSync(commandsDirectory).isSymbolicLink()) {
+      for (const command of fs.readdirSync(commandsDirectory, { withFileTypes: true })) {
+        if (!command.isFile() || !command.name.toLowerCase().endsWith('.md')) continue;
+        const source = path.join(commandsDirectory, command.name);
+        imported.push({ source, id: store.importFile(source, 'skill', false), linked: false });
+      }
+    }
+    const files: Array<{ path: string; content: Buffer }> = [];
+    let totalSize = 0;
+    const collect = (directory: string, relative = '') => {
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === '__pycache__' || entry.isSymbolicLink()) continue;
+        const relativePath = path.posix.join(relative.split(path.sep).join('/'), entry.name);
+        const absolutePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) collect(absolutePath, relativePath);
+        else if (entry.isFile()) {
+          const content = fs.readFileSync(absolutePath);
+          totalSize += content.length;
+          if (totalSize > 30 * 1024 * 1024 || files.length >= 5000) throw new Error(`Plugin trop volumineux : ${id}`);
+          files.push({ path: relativePath, content });
+        }
+      }
+    };
+    collect(installRoot);
+    const fallbackEntryName = imported.length ? store.document(imported[0].id).name : null;
+    store.upsertCollection({
+      id,
+      name: manifest.displayName || manifest.name || fallbackEntryName || 'Plugin sans nom',
+      description: manifest.description || '',
+      source: installRoot,
+      entries: imported.map((entry) => ({
+        entryId: entry.id,
+        rootPath: path.relative(installRoot, entry.source).split(path.sep).join('/'),
+      })),
+      files,
+    });
+  }
+}
+
+export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLibraryStore>, applicationRoot: string, userHome: string) {
+  const require = createRequire(import.meta.url);
+  const { listMarketplaceConnectors, registerOfficialMarketplace } = require(path.join(applicationRoot, 'server/piecemaker/vendor/websocket-server/admin-routes.cjs'));
+  const router = express.Router();
+  const run = (command: string, args: string[], timeout = 60000) => {
+    const result = spawnSync(command, args, { encoding: 'utf8', timeout, maxBuffer: 8 * 1024 * 1024, windowsHide: true });
+    return { ok: result.status === 0, output: `${result.stdout || ''}${result.stderr || ''}`, status: result.status };
+  };
+  const scope = (value: unknown) => {
+    if (value === 'piecemaker') return { name: 'mcp-legifrance', slug: 'PieceMaker-Legal/mcp-legifrance' };
+    if (value === 'legal') return { name: 'claude-for-legal', slug: 'anthropics/claude-for-legal' };
+    if (value === 'official') return { name: 'claude-plugins-official', slug: 'anthropics/claude-plugins-official' };
+    throw new Error('Marketplace inconnue.');
+  };
+  const installed = () => {
+    const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+    return fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
+  };
+  const importInstalledCollections = () => scanInstalledLibraryCollections(store, userHome);
+  const disable = (id: string) => {
+    const filename = path.join(userHome, '.claude/settings.json');
+    const settings = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')) : {};
+    settings.enabledPlugins = { ...settings.enabledPlugins, [id]: false };
+    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
+    const temporary = `${filename}.library.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(temporary, filename);
+  };
+  router.get('/plugin/marketplace', (req, res) => {
+    try {
+      const marketplace = scope(req.query.scope);
+      const kind = req.query.kind;
+      if (!['connector', 'skill', 'plugin', 'agent'].includes(String(kind))) throw new Error('Type de catalogue inconnu.');
+      const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
+      const registry = installed();
+      const plugins = catalog.plugins
+        .map((plugin: { id: string; name: string; description?: string }) => ({
+          ...plugin,
+          name: plugin.id === 'piecemaker@mcp-legifrance' ? 'MCP Légifrance' : plugin.name,
+          installed: Boolean(registry[plugin.id]),
+          kinds: marketplacePackageKinds(userHome, marketplace.name, plugin, registry),
+        }))
+        .filter((plugin: { kinds: MarketplaceKind[] }) => plugin.kinds.includes(kind as MarketplaceKind));
+      res.json({ ...catalog, kind, plugins });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins', (req, res) => {
+    try {
+      res.json({ plugins: store.listCollections(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugins/scan', (_req, res) => {
+    try { importInstalledCollections(); res.json({ ok: true }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins/:id/files', (req, res) => {
+    try { res.json({ files: store.collectionFiles(String(req.params.id)) }); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.get('/plugins/:id/file', (req, res) => {
+    try { res.json(store.collectionFile(String(req.params.id), String(req.query.path || ''))); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.put('/plugins/:id/file', (req, res) => {
+    try { res.json(store.updateCollectionFile(String(req.params.id), req.body?.path, req.body?.content, req.body?.previousContent)); }
+    catch (error) { res.status(409).json({ error: (error as Error).message }); }
+  });
+  router.put('/plugins/:id/activation', (req, res) => {
+    try { res.json(store.setCollectionEnabled(req.body?.workspacePath, String(req.params.id), req.body?.enabled)); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugin/marketplace/register', (req, res) => {
+    try { res.json(registerOfficialMarketplace(run, scope(req.body?.scope))); }
+    catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugin/marketplace/acquire', (req, res) => {
+    try {
+      const marketplace = scope(req.body?.scope);
+      const id = req.body?.id;
+      if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+$/.test(id) || !id.endsWith(`@${marketplace.name}`)) throw new Error('Connecteur invalide.');
+      if (installed()[id]) throw new Error('Connecteur déjà installé. Son activation se règle par dossier.');
+      const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
+      if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Connecteur absent du catalogue.');
+      disable(id);
+      let result;
+      try { result = run('claude', ['plugin', 'install', id, '--scope', 'user']); }
+      finally { disable(id); }
+      if (!result.ok) throw new Error(result.output || 'Installation impossible.');
+      importInstalledCollections();
+      res.json({ ok: true, enabled: false });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  return router;
+}

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

@@ -0,0 +1,11 @@
+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(); }