@piecemaker-legal/piecemaker 1.0.6 → 1.0.7

package/server/piecemaker/library/index.ts

@@ -9,13 +9,17 @@ import express from 'express';
 import { createLibraryStore } from './store.js';
 import { createLibraryRouter } from './routes.js';
 import { createLibraryMarketplaceRouter, scanInstalledLibraryCollections } from './marketplace.js';
+import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
+import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.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 { await scanAndPersistLibraryProviderSkills(store, undefined, undefined, os.homedir()); } catch {}
+  try { scanAndPersistLibraryProviderAgents(store, os.homedir()); } catch {}
+  try { scanAndPersistLibraryProviderConnectors(store, os.homedir()); } catch {}
   try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
   const require = createRequire(import.meta.url);
   const { createActivationRouter } = require(path.join(applicationRoot, 'server/piecemaker/activation/index.cjs'));

package/server/piecemaker/library/marketplace.ts

@@ -6,7 +6,11 @@ import { spawnSync } from 'node:child_process';
 import express from 'express';
 
 import type { createLibraryStore } from './store.js';
+import { normalizeProviderConnector } from './connector-installation.js';
 import { importLibraryDirectory } from './migrate.js';
+import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
+import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.js';
+import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
 
 type MarketplaceKind = 'connector' | 'skill' | 'plugin' | 'agent';
 
@@ -37,13 +41,26 @@ function marketplacePackageKinds(userHome: string, marketplaceName: string, plug
     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');
+  if (marketplaceName === 'mcp-legifrance') kinds.add('connector');
   return [...kinds];
 }
 
+function disableNativeClaudePlugin(userHome: string, id: string) {
+  const settingsFilename = path.join(userHome, '.claude/settings.json');
+  const settings = fs.existsSync(settingsFilename)
+    ? JSON.parse(fs.readFileSync(settingsFilename, 'utf8'))
+    : {};
+  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
+    ? settings.enabledPlugins
+    : {};
+  if (enabledPlugins[id] === false) return;
+  settings.enabledPlugins = { ...enabledPlugins, [id]: false };
+  fs.mkdirSync(path.dirname(settingsFilename), { recursive: true, mode: 0o700 });
+  const temporary = `${settingsFilename}.library.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  fs.renameSync(temporary, settingsFilename);
+}
+
 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 || {} : {};
@@ -51,7 +68,6 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
   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;
@@ -60,7 +76,7 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
     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 = [
+    const imported: Array<{ source: string; id: string; linked: boolean; rootPath?: string }> = [
       ...importLibraryDirectory(store, path.join(installRoot, 'skills'), 'skill', false),
       ...importLibraryDirectory(store, path.join(installRoot, 'agents'), 'agent', false),
     ];
@@ -72,23 +88,32 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
         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 });
+    const mcpPath = path.join(installRoot, '.mcp.json');
+    if (fs.existsSync(mcpPath) && !fs.lstatSync(mcpPath).isSymbolicLink()) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+        const servers = parsed?.mcpServers && typeof parsed.mcpServers === 'object' && !Array.isArray(parsed.mcpServers)
+          ? parsed.mcpServers as Record<string, unknown>
+          : {};
+        for (const [name, raw] of Object.entries(servers)) {
+          const config = normalizeProviderConnector(raw);
+          if (!config) continue;
+          const source = `${mcpPath}#${name}`;
+          imported.push({
+            source,
+            id: store.importConnector({
+              name,
+              description: config.url || config.command || name,
+              config,
+              source,
+              namespace: id,
+            }),
+            linked: false,
+            rootPath: `mcp/${name}.json`,
+          });
         }
-      }
-    };
-    collect(installRoot);
+      } catch {}
+    }
     const fallbackEntryName = imported.length ? store.document(imported[0].id).name : null;
     store.upsertCollection({
       id,
@@ -97,13 +122,46 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
       source: installRoot,
       entries: imported.map((entry) => ({
         entryId: entry.id,
-        rootPath: path.relative(installRoot, entry.source).split(path.sep).join('/'),
+        rootPath: entry.rootPath || path.relative(installRoot, entry.source).split(path.sep).join('/'),
       })),
-      files,
+      files: [],
     });
   }
 }
 
+function readInstalledClaudePlugins(userHome: string) {
+  const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+  if (!fs.existsSync(filename)) return {};
+  const config = JSON.parse(fs.readFileSync(filename, 'utf8'));
+  return config.plugins && typeof config.plugins === 'object' && !Array.isArray(config.plugins)
+    ? config.plugins as Record<string, unknown>
+    : {};
+}
+
+function synchronizeInstalledPluginActivation(
+  store: ReturnType<typeof createLibraryStore>,
+  userHome: string,
+  workspacePath: string,
+) {
+  const settingsFilename = path.join(userHome, '.claude/settings.json');
+  if (!fs.existsSync(settingsFilename)) return store.listCollections(workspacePath);
+  const settings = JSON.parse(fs.readFileSync(settingsFilename, 'utf8'));
+  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
+    ? settings.enabledPlugins as Record<string, unknown>
+    : {};
+  const installedPlugins = readInstalledClaudePlugins(userHome);
+  const collections = store.listCollections(workspacePath);
+
+  for (const id of Object.keys(installedPlugins)) {
+    const collection = collections.find((entry) => entry.id === id);
+    const enabled = enabledPlugins[id];
+    if (!collection || collection.componentCount === 0 || typeof enabled !== 'boolean' || collection.enabled === enabled) continue;
+    store.setCollectionEnabled(workspacePath, id, enabled);
+  }
+
+  return store.listCollections(workspacePath);
+}
+
 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'));
@@ -123,15 +181,6 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     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);
@@ -152,7 +201,23 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
   });
   router.get('/plugins', (req, res) => {
     try {
-      res.json({ plugins: store.listCollections(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) });
+      const workspacePath = typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined;
+      res.json({ plugins: store.listCollections(workspacePath) });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugins/sync', async (req, res) => {
+    try {
+      const workspacePath = typeof req.body?.workspacePath === 'string' ? req.body.workspacePath : undefined;
+      await scanAndPersistLibraryProviderSkills(store, workspacePath, undefined, userHome);
+      scanAndPersistLibraryProviderAgents(store, userHome);
+      scanAndPersistLibraryProviderConnectors(store, userHome);
+      scanInstalledLibraryCollections(store, userHome);
+      res.json({
+        ok: true,
+        plugins: workspacePath
+          ? synchronizeInstalledPluginActivation(store, userHome, workspacePath)
+          : store.listCollections(),
+      });
     } catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/plugins/scan', (_req, res) => {
@@ -183,14 +248,14 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     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.');
+      if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+$/.test(id) || !id.endsWith(`@${marketplace.name}`)) throw new Error('Élément invalide.');
+      if (installed()[id]) throw new Error('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);
+      if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Élément absent du catalogue.');
+      disableNativeClaudePlugin(userHome, id);
       let result;
       try { result = run('claude', ['plugin', 'install', id, '--scope', 'user']); }
-      finally { disable(id); }
+      finally { disableNativeClaudePlugin(userHome, id); }
       if (!result.ok) throw new Error(result.output || 'Installation impossible.');
       importInstalledCollections();
       res.json({ ok: true, enabled: false });

package/server/piecemaker/library/migrate.ts

@@ -29,12 +29,19 @@ export function migratePersonalLibrary(store: ReturnType<typeof createLibrarySto
     [path.join(userHome, '.claude', 'skills'), 'skill'],
     [path.join(userHome, '.codex', 'skills'), 'skill'],
     [path.join(userHome, '.agents', 'skills'), 'skill'],
+    [path.join(userHome, '.cursor', 'skills'), 'skill'],
+    [path.join(userHome, '.config', 'opencode', 'skills'), 'skill'],
+    [path.join(userHome, '.grok', 'skills'), 'skill'],
     [path.join(userHome, '.claude', 'agents'), 'agent'],
+    [path.join(userHome, '.cursor', 'agents'), 'agent'],
+    [path.join(userHome, '.grok', 'agents'), 'agent'],
+    [path.join(userHome, '.config', 'opencode', 'agents'), 'agent'],
+    [path.join(userHome, '.config', 'opencode', 'agent'), '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 candidates = imported.filter((entry) => ['.claude', '.codex', '.agents', '.cursor', '.grok', path.join('.config', 'opencode')].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 });

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

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { importLibraryDirectory } from './migrate.js';
+import type { createLibraryStore } from './store.js';
+
+const require = createRequire(import.meta.url);
+const TOML = require('@iarna/toml') as { parse(value: string): Record<string, unknown> };
+
+function importTomlAgents(store: ReturnType<typeof createLibraryStore>, directory: string) {
+  if (!fs.existsSync(directory) || fs.lstatSync(directory).isSymbolicLink()) return [];
+  const imported: string[] = [];
+  for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (!item.isFile() || !item.name.toLowerCase().endsWith('.toml')) continue;
+    const source = path.join(directory, item.name);
+    if (fs.lstatSync(source).isSymbolicLink()) continue;
+    try {
+      const parsed = TOML.parse(fs.readFileSync(source, 'utf8'));
+      const name = typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name : path.basename(item.name, '.toml');
+      const description = typeof parsed.description === 'string' ? parsed.description : '';
+      const body = typeof parsed.developer_instructions === 'string' ? parsed.developer_instructions : '';
+      imported.push(store.importContent(source, 'agent', `---\nname: ${name}\ndescription: ${description}\n---\n${body}\n`));
+    } catch {}
+  }
+  return imported;
+}
+
+export function scanAndPersistLibraryProviderAgents(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  const markdownDirectories = [
+    path.join(userHome, '.claude', 'agents'),
+    path.join(userHome, '.cursor', 'agents'),
+    path.join(userHome, '.config', 'opencode', 'agent'),
+    path.join(userHome, '.config', 'opencode', 'agents'),
+    path.join(userHome, '.grok', 'agents'),
+  ];
+  for (const directory of markdownDirectories) {
+    try { importLibraryDirectory(store, directory, 'agent', false); } catch {}
+  }
+  try { importTomlAgents(store, path.join(userHome, '.codex', 'agents')); } catch {}
+}
+
+export function scanAndPersistLibraryClaudeAgents(
+  store: ReturnType<typeof createLibraryStore>,
+  _workspacePath: string | undefined,
+  userHome: string,
+) {
+  scanAndPersistLibraryProviderAgents(store, userHome);
+}

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

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { normalizeProviderConnector, type LibraryConnectorConfig } from './connector-installation.js';
+import type { createLibraryStore } from './store.js';
+
+const require = createRequire(import.meta.url);
+const TOML = require('@iarna/toml') as { parse(value: string): Record<string, unknown> };
+
+export const REGISTRE_PUBLIC_CONNECTOR = Object.freeze({
+  name: 'registre-public',
+  url: 'https://registre-public.com/api/mcp',
+});
+
+type ImportedConnector = {
+  name: string;
+  description: string;
+  config: LibraryConnectorConfig;
+  source: string;
+};
+
+function readJson(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function readToml(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const value = TOML.parse(fs.readFileSync(filePath, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+function objectRecord(value: unknown) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function collectServers(source: string, servers: Record<string, unknown>, collected: ImportedConnector[]) {
+  for (const [name, raw] of Object.entries(servers)) {
+    const config = normalizeProviderConnector(raw);
+    if (!config) continue;
+    collected.push({
+      name,
+      description: config.url || config.command || name,
+      config,
+      source: `${source}#${name}`,
+    });
+  }
+}
+
+export function listUserProviderConnectors(userHome: string) {
+  const collected: ImportedConnector[] = [];
+  collectServers(path.join(userHome, '.claude.json'), objectRecord(readJson(path.join(userHome, '.claude.json')).mcpServers), collected);
+  collectServers(path.join(userHome, '.codex', 'config.toml'), objectRecord(readToml(path.join(userHome, '.codex', 'config.toml')).mcp_servers), collected);
+  collectServers(path.join(userHome, '.cursor', 'mcp.json'), objectRecord(readJson(path.join(userHome, '.cursor', 'mcp.json')).mcpServers), collected);
+  const opencodeJson = path.join(userHome, '.config', 'opencode', 'opencode.json');
+  const opencodeJsonc = path.join(userHome, '.config', 'opencode', 'opencode.jsonc');
+  const opencodePath = fs.existsSync(opencodeJson) ? opencodeJson : opencodeJsonc;
+  collectServers(opencodePath, objectRecord(readJson(opencodePath).mcp), collected);
+  collectServers(path.join(userHome, '.grok', 'config.toml'), objectRecord(readToml(path.join(userHome, '.grok', 'config.toml')).mcp_servers), collected);
+  return collected;
+}
+
+export function seedDefaultLibraryConnectors(store: ReturnType<typeof createLibraryStore>) {
+  return store.importConnector({
+    name: REGISTRE_PUBLIC_CONNECTOR.name,
+    description: REGISTRE_PUBLIC_CONNECTOR.url,
+    config: { transport: 'http', url: REGISTRE_PUBLIC_CONNECTOR.url },
+    source: 'piecemaker:default:registre-public',
+  });
+}
+
+export function scanAndPersistLibraryProviderConnectors(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  seedDefaultLibraryConnectors(store);
+  const imported: string[] = [];
+  for (const connector of listUserProviderConnectors(userHome)) {
+    try { imported.push(store.importConnector(connector)); } catch {}
+  }
+  return imported;
+}

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

@@ -1,6 +1,9 @@
+import path from 'node:path';
+
 import { providerSkillsService } from '@/modules/providers/index.js';
 import type { LLMProvider, ProviderSkillListOptions } from '@/shared/types.js';
 
+import { importLibraryDirectory } from './migrate.js';
 import type { createLibraryStore } from './store.js';
 
 const LIBRARY_SKILL_PROVIDERS: LLMProvider[] = ['claude', 'codex', 'cursor', 'mistral', 'opencode'];
@@ -35,14 +38,20 @@ export async function scanAndPersistLibraryProviderSkills(
   store: ReturnType<typeof createLibraryStore>,
   workspacePath: string | undefined,
   reader: ProviderSkillsReader = providerSkillsService,
+  userHome?: string,
 ) {
   const result = await listLibraryProviderSkills(workspacePath, reader);
   for (const provider of result.providers) {
     for (const skill of provider.skills) {
-      if (!skill.sourcePath) continue;
+      if (!skill.sourcePath || skill.scope !== 'user' || skill.pluginId || skill.pluginName) continue;
       try { store.importFile(skill.sourcePath, 'skill'); }
       catch { try { store.importFile(skill.sourcePath, 'skill', false); } catch {} }
     }
   }
+  if (userHome) {
+    try { importLibraryDirectory(store, path.join(userHome, '.grok', 'skills'), 'skill', false); } catch {}
+  }
   return result;
 }
+
+export { scanAndPersistLibraryClaudeAgents, scanAndPersistLibraryProviderAgents } from './provider-agents.js';