@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/installer/lib/ui.mjs

@@ -0,0 +1,159 @@
+/**
+ * Terminal UI primitives — zero dependencies, ANSI only.
+ *
+ * Colour is disabled automatically when stdout is not a TTY, when NO_COLOR is
+ * set, or when TERM is "dumb", so piping the installer into a log file yields
+ * clean text.
+ */
+
+import { renderBanner } from './banner.mjs';
+
+const COLOR_ENABLED =
+  process.stdout.isTTY &&
+  !process.env.NO_COLOR &&
+  process.env.TERM !== 'dumb';
+
+const CODES = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+};
+
+function wrap(code, text) {
+  return COLOR_ENABLED ? `${CODES[code]}${text}${CODES.reset}` : String(text);
+}
+
+export const c = Object.fromEntries(
+  Object.keys(CODES).map((k) => [k, (text) => wrap(k, text)])
+);
+
+/** Clickable OSC 8 link on compatible terminals; plain text everywhere else. */
+export function link(label, url) {
+  const text = String(label);
+  if (!process.stdout.isTTY || process.env.TERM === 'dumb') return text;
+  const safeUrl = String(url).replace(/[\x00-\x1f\x7f]/g, '');
+  return `\x1b]8;;${safeUrl}\x1b\\${text}\x1b]8;;\x1b\\`;
+}
+
+export function columns() {
+  return process.stdout.columns || 80;
+}
+
+/** Visible width, ignoring ANSI escapes. */
+export function visibleWidth(text) {
+  return String(text)
+    .replace(/\x1b]8;;[^\x1b]*\x1b\\/g, '')
+    .replace(/\x1b\[[0-9;]*m/g, '')
+    .length;
+}
+
+export function write(text = '') {
+  process.stdout.write(`${text}\n`);
+}
+
+export function blank() {
+  write('');
+}
+
+/** Full-width horizontal rule. */
+export function rule(char = '─') {
+  write(c.gray(char.repeat(Math.min(columns(), 78))));
+}
+
+/** The PIECEMAKER banner plus a tagline. */
+export function banner(subtitle = 'Installateur — anonymisation & assistance juridique') {
+  blank();
+  for (const line of renderBanner(columns())) write(c.white(line));
+  blank();
+  write(`  ${c.dim(subtitle)}`);
+  blank();
+}
+
+export function title(text) {
+  blank();
+  write(c.bold(text));
+  rule();
+}
+
+export const log = {
+  info: (m) => write(`  ${c.blue('·')} ${m}`),
+  step: (m) => write(`  ${c.cyan('▸')} ${m}`),
+  ok: (m) => write(`  ${c.green('✓')} ${m}`),
+  warn: (m) => write(`  ${c.yellow('!')} ${m}`),
+  error: (m) => write(`  ${c.red('✗')} ${m}`),
+  detail: (m) => write(`    ${c.gray(m)}`),
+};
+
+/**
+ * Indeterminate spinner. Degrades to a single static line when stdout is not a
+ * TTY, so CI logs do not fill with control characters.
+ */
+export function spinner(label) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let timer = null;
+  let current = label;
+
+  if (!process.stdout.isTTY) {
+    write(`  · ${label}`);
+    return {
+      update: () => {},
+      succeed: (m) => log.ok(m || current),
+      fail: (m) => log.error(m || current),
+      stop: () => {},
+    };
+  }
+
+  const paint = () => {
+    const frame = frames[(i = (i + 1) % frames.length)];
+    process.stdout.write(`\r\x1b[2K  ${c.cyan(frame)} ${current}`);
+  };
+  timer = setInterval(paint, 80);
+  paint();
+
+  const clear = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+    process.stdout.write('\r\x1b[2K');
+  };
+
+  return {
+    update: (m) => {
+      current = m;
+    },
+    succeed: (m) => {
+      clear();
+      log.ok(m || current);
+    },
+    fail: (m) => {
+      clear();
+      log.error(m || current);
+    },
+    stop: clear,
+  };
+}
+
+/** Render a summary table of [label, status] pairs. */
+export function summary(rows) {
+  const width = Math.max(...rows.map(([label]) => label.length));
+  for (const [label, status, note] of rows) {
+    const padded = label.padEnd(width);
+    write(`  ${padded}  ${status}${note ? `  ${c.gray(note)}` : ''}`);
+  }
+}
+
+export const badge = {
+  done: c.green('installé'),
+  partial: c.yellow('partiel'),
+  todo: c.gray('à faire'),
+  failed: c.red('échec'),
+  skipped: c.gray('ignoré'),
+};

package/server/piecemaker/vendor/installer/steps/00-identite.mjs

@@ -0,0 +1,71 @@
+/**
+ * Step 00 — identify the user responsible for PieceMaker tasks.
+ *
+ * The identity is stored in the global, permission-restricted .env and is
+ * written into every legal-case Git commit as both author and committer.
+ */
+
+import os from 'node:os';
+import { createRequire } from 'node:module';
+
+import { ask } from '../lib/prompt.mjs';
+import { runCapture } from '../lib/platform.mjs';
+import { writeEnv } from '../lib/state.mjs';
+import { log } from '../lib/ui.mjs';
+
+const require = createRequire(import.meta.url);
+const {
+  COMMIT_USER_NAME_KEY,
+  resolveCommitIdentity,
+} = require('../../piecemaker-plugin/scripts/lib/commits.cjs');
+
+export const meta = {
+  id: '00-identite',
+  label: 'Identification de l’utilisateur',
+  description: 'Signe chaque tâche enregistrée dans l’historique avec votre nom',
+};
+
+function gitConfig(key) {
+  const result = runCapture('git', ['config', '--global', '--get', key]);
+  return result.code === 0 ? result.stdout : '';
+}
+
+function defaults(ctx) {
+  const username = os.userInfo().username || 'utilisateur';
+  return ctx.env?.[COMMIT_USER_NAME_KEY]
+    || process.env[COMMIT_USER_NAME_KEY]
+    || gitConfig('user.name')
+    || username;
+}
+
+export async function install(ctx) {
+  const current = defaults(ctx);
+  const name = await ask('Votre nom (signature des tâches)', { def: current, required: true });
+  const identity = resolveCommitIdentity({ identity: { name } });
+
+  if (ctx.dryRun) {
+    log.info(`[simulation] identité des commits : ${identity.name}`);
+    return { status: 'skipped', note: identity.name };
+  }
+
+  writeEnv({
+    [COMMIT_USER_NAME_KEY]: identity.name,
+  });
+  log.ok(`Identité enregistrée : ${identity.name}`);
+  log.detail('Elle sera appliquée comme auteur et validateur de chaque commit PieceMaker.');
+  return { status: 'done', note: identity.name };
+}
+
+export async function check(ctx) {
+  try {
+    const identity = resolveCommitIdentity({ identity: {
+      name: ctx.env?.[COMMIT_USER_NAME_KEY],
+    } });
+    return { status: 'done', note: identity.name };
+  } catch {
+    return {
+      status: 'partial',
+      note: 'Identité absente ou invalide — relancez cette étape ou renseignez-la dans les paramètres administrateur.',
+    };
+  }
+}

package/server/piecemaker/vendor/installer/steps/01-prerequis.mjs

@@ -0,0 +1,119 @@
+/**
+ * Step 01 — system prerequisites.
+ *
+ * Read-only probe of the toolchain the rest of the installer depends on:
+ * Node >= 18 (this process already proves Node exists, only the version is
+ * checked), npm, git, Python >= 3.10 (via findPython()), LibreOffice
+ * (conversion des pièces Excel/Word en PDF avant tamponnage) et pandoc/typst
+ * (facultatifs, voie génération — chronologie/historique). Disk space is
+ * intentionally not checked — out of scope per the installer spec.
+ */
+
+import { createRequire } from 'node:module';
+import { log } from '../lib/ui.mjs';
+import { commandExists, compareVersions, npmBin, npmEnv, runCapture, IS_WINDOWS, REPO_ROOT } from '../lib/platform.mjs';
+
+const require = createRequire(import.meta.url);
+const { findSoffice } = require(`${REPO_ROOT}/websocket-server/lib/office-to-pdf.cjs`);
+const { findPandoc, findTypst } = require(`${REPO_ROOT}/websocket-server/lib/doc-generate.cjs`);
+
+export const meta = {
+  id: '01-prerequis',
+  label: 'Prérequis système',
+  description: 'Vérifie Node.js, npm, git et Python avant toute installation',
+};
+
+const MIN_NODE = '18.0.0';
+
+function probe(ctx) {
+  const nodeVersion = process.version;
+  const nodeOk = compareVersions(nodeVersion, MIN_NODE) >= 0;
+
+  const npmProbe = runCapture(npmBin('npm'), ['--version'], { env: npmEnv() });
+  const npmOk = npmProbe.code === 0 && !npmProbe.error;
+  const npmVersion = npmOk ? npmProbe.stdout : null;
+
+  const gitOk = commandExists('git');
+
+  const pythonOk = Boolean(ctx.python);
+
+  // node-pty (used by the PTY terminal bridge) needs a native build toolchain
+  // on Windows. Best-effort probe only — this never fails the step.
+  let winToolchainOk = true;
+  if (IS_WINDOWS) {
+    winToolchainOk = commandExists('cl', ['/?']) || commandExists('where', ['cl']);
+  }
+
+  // LibreOffice : indispensable pour tamponner une pièce Excel ou Word, qui
+  // doit être convertie en PDF au préalable (websocket-server/lib/office-to-pdf.cjs).
+  const soffice = findSoffice();
+
+  // pandoc/typst : facultatifs, améliorent la qualité des exports de la
+  // chronologie et de l'historique (voie génération) ; sans eux, repli
+  // intégral et fonctionnel sur LibreOffice (installer/steps/10-pandoc.mjs).
+  const pandoc = findPandoc();
+  const typst = findTypst();
+
+  return { nodeVersion, nodeOk, npmOk, npmVersion, gitOk, pythonOk, winToolchainOk, soffice, pandoc, typst };
+}
+
+function report(probeResult, ctx) {
+  const { nodeVersion, nodeOk, npmOk, npmVersion, gitOk, pythonOk, winToolchainOk, soffice, pandoc, typst } = probeResult;
+
+  if (nodeOk) log.ok(`Node.js ${nodeVersion} (>= ${MIN_NODE} requis)`);
+  else log.error(`Node.js ${nodeVersion} — version >= ${MIN_NODE} requise`);
+
+  if (npmOk) log.ok(`npm ${npmVersion}`);
+  else log.error('npm introuvable — installez-le avec Node.js (nodejs.org)');
+
+  if (gitOk) log.ok('git présent');
+  else log.warn('git introuvable — optionnel pour l\'installateur, mais recommandé pour les mises à jour');
+
+  if (pythonOk) log.ok(`Python ${ctx.python.version} (${ctx.python.command})`);
+  else log.error('Python >= 3.10 introuvable — requis pour l\'anonymisation GLiNER (étape 03)');
+
+  if (soffice) log.ok(`LibreOffice détecté (${soffice})`);
+  else log.warn('LibreOffice introuvable — l\'étape "10-libreoffice" l\'installera (requis pour tamponner les pièces Excel et Word)');
+
+  if (pandoc) log.ok(`pandoc détecté (${pandoc})`);
+  else log.warn('pandoc introuvable — facultatif, améliore la qualité des exports de la chronologie et de l\'historique (piecemaker --step 10-pandoc)');
+
+  if (typst) log.ok(`typst détecté (${typst})`);
+  else log.warn('typst introuvable — facultatif, sert de moteur PDF à pandoc pour ces exports (piecemaker --step 10-pandoc)');
+
+  if (IS_WINDOWS) {
+    if (winToolchainOk) log.ok('Outils de compilation C++ détectés (nécessaires à node-pty)');
+    else {
+      log.warn('Outils de compilation C++ non détectés (node-pty ne pourra pas se compiler)');
+      log.detail('Installez "Visual Studio Build Tools" (charge de travail "Développement Desktop en C++")');
+      log.detail('Voir : https://github.com/nodejs/node-gyp#on-windows');
+    }
+  }
+}
+
+function computeStatus({ nodeOk, npmOk, pythonOk, gitOk }) {
+  const missing = [];
+  if (!nodeOk) missing.push(`Node.js >= ${MIN_NODE}`);
+  if (!npmOk) missing.push('npm');
+  if (!pythonOk) missing.push('Python >= 3.10');
+
+  if (missing.length) {
+    return { status: 'failed', note: `Manquant : ${missing.join(', ')}. Installez-les puis relancez cette étape.` };
+  }
+  if (!gitOk) {
+    return { status: 'partial', note: 'git est absent — installez-le pour faciliter les futures mises à jour.' };
+  }
+  return { status: 'done', note: '' };
+}
+
+export async function install(ctx) {
+  log.step('Vérification des prérequis...');
+  const result = probe(ctx);
+  report(result, ctx);
+  return computeStatus(result);
+}
+
+export async function check(ctx) {
+  const result = probe(ctx);
+  return computeStatus(result);
+}

package/server/piecemaker/vendor/installer/steps/02-dependances-node.mjs

@@ -0,0 +1,127 @@
+/**
+ * Step 02 — Node.js dependencies.
+ *
+ * Runs `npm install` at the repo root. Electron is no longer part of the
+ * active dependency graph, so package lifecycle scripts can run normally
+ * (notably the native node-pty installation).
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { log, spinner, columns } from '../lib/ui.mjs';
+import { run, npmBin, npmEnv, REPO_ROOT } from '../lib/platform.mjs';
+
+export const meta = {
+  id: '02-dependances-node',
+  label: 'Dépendances Node.js',
+  description: 'Installe les modules npm de la racine',
+};
+
+function truncate(text) {
+  const width = Math.max(20, columns() - 6);
+  const s = String(text).replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 1)}…` : s;
+}
+
+function readPackageJson(dir) {
+  const file = path.join(dir, 'package.json');
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Certaines distributions npm conservent spawn-helper de node-pty en 0644.
+// Le module se charge alors normalement mais tout pty.spawn échoue avec
+// « posix_spawnp failed ». Réparer le bit exécutable est idempotent.
+export function repairNodePtySpawnHelpers(repoRoot = REPO_ROOT, { repair = true } = {}) {
+  if (process.platform === 'win32') return { found: 0, repaired: 0, ready: true };
+  const prebuilds = path.join(repoRoot, 'node_modules', 'node-pty', 'prebuilds');
+  if (!fs.existsSync(prebuilds)) return { found: 0, repaired: 0, ready: false };
+
+  let found = 0;
+  let repaired = 0;
+  for (const platformArch of fs.readdirSync(prebuilds)) {
+    const helper = path.join(prebuilds, platformArch, 'spawn-helper');
+    if (!fs.existsSync(helper)) continue;
+    found += 1;
+    const mode = fs.statSync(helper).mode;
+    if (repair && (mode & 0o111) === 0) {
+      fs.chmodSync(helper, mode | 0o111);
+      repaired += 1;
+    }
+  }
+  const currentArchHelper = path.join(prebuilds, `${process.platform}-${process.arch}`, 'spawn-helper');
+  const ready = fs.existsSync(currentArchHelper) && (fs.statSync(currentArchHelper).mode & 0o111) !== 0;
+  return { found, repaired, ready };
+}
+
+async function npmInstall(dir, label, ctx) {
+  const pkg = readPackageJson(dir);
+  if (!pkg) {
+    log.warn(`${label} : aucun package.json trouvé dans ${dir}, étape ignorée`);
+    return { code: 0, skipped: true };
+  }
+
+  if (ctx.dryRun) {
+    log.info(`[simulation] npm install dans ${dir}`);
+    return { code: 0, skipped: true };
+  }
+
+  const args = ['install'];
+
+  const spin = spinner(`${label} : npm install...`);
+  const code = await run(npmBin('npm'), args, {
+    cwd: dir,
+    env: npmEnv(),
+    onLine: (line) => spin.update(truncate(line)),
+  });
+
+  if (code === 0) spin.succeed(`${label} : dépendances installées`);
+  else spin.fail(`${label} : npm install a échoué (code ${code})`);
+
+  return { code, skipped: false };
+}
+
+export async function install(ctx) {
+  const results = [];
+
+  results.push(['racine du projet', await npmInstall(REPO_ROOT, 'Racine', ctx)]);
+
+  if (ctx.dryRun) {
+    return { status: 'skipped', note: 'Mode simulation — aucune installation effectuée.' };
+  }
+
+  const failed = results.filter(([, r]) => !r.skipped && r.code !== 0);
+  if (failed.length) {
+    const where = failed.map(([label]) => label).join(', ');
+    return {
+      status: 'failed',
+      note: `npm install a échoué pour : ${where}. Vérifiez votre connexion réseau et relancez cette étape.`,
+    };
+  }
+
+  const ptyHelpers = repairNodePtySpawnHelpers();
+  if (!ptyHelpers.ready) {
+    return {
+      status: 'failed',
+      note: 'node-pty est absent ou incomplet : le terminal intégré (Claude Code CLI) ne peut pas démarrer.',
+    };
+  }
+  if (ptyHelpers.repaired) log.ok(`node-pty : ${ptyHelpers.repaired} lanceur(s) PTY rendu(s) exécutable(s)`);
+
+  return { status: 'done', note: '' };
+}
+
+export async function check(ctx) {
+  const rootInstalled = fs.existsSync(path.join(REPO_ROOT, 'node_modules'));
+  const ptyReady = repairNodePtySpawnHelpers(REPO_ROOT, { repair: false }).ready;
+
+  if (rootInstalled && ptyReady) return { status: 'done', note: '' };
+  if (rootInstalled) {
+    return { status: 'partial', note: 'node-pty absent ou incomplet.' };
+  }
+  return { status: 'failed', note: 'node_modules absent — exécutez cette étape.' };
+}