pipcode 0.0.0-stage → 2.1.0

package/src/cli/dispatch.js

@@ -0,0 +1,36 @@
+// src/cli/dispatch.js — Aiguillage des sous-commandes de `pipcode` (setup, teardown, config,
+// auto, aide). Extrait de bin/setup.js : le point d'entrée reste un simple
+// réorienteur (< 50 lignes). Le CLI ne fait QUE configurer le serveur MCP (setup,
+// config) et exposer le Mode Auto : aucune surface interactive propre.
+
+import { main } from "./main.js";
+import { runAutoCli } from "./auto-cli.js";
+import { runMemoryCli } from "./memory-cli.js";
+import { runConfigCli } from "./config.js";
+import { runTrialCheck } from "./trial-check.js";
+import { runTeardown } from "../teardown/main.js";
+import { printAutoHelp, printTopHelp } from "./help.js";
+
+/** @param {string} name @returns {(err: Error) => void} */
+const failWith = (name) => (err) => { console.error(`\n  ✗ ${name} a échoué :`, err.message); process.exit(1); };
+
+/** @param {string[]} argv process.argv complet (argv[2] = sous-commande) @returns {void} */
+export function dispatch(argv) {
+  const sub = (argv[2] || "setup").toLowerCase().replace(/^--?/, "");
+  if (sub === "setup") main().catch(failWith("setup"));
+  else if (sub === "config") runConfigCli().catch(failWith("config"));
+  else if (sub === "trial") runTrialCheck().catch(failWith("trial"));
+  else if (sub === "teardown") runTeardown({ argv: argv.slice(3) }).catch(failWith("teardown"));
+  else if (argv[2] === "memory") runMemoryCli((argv[3] || "").toLowerCase(), argv.slice(4)).catch(failWith("memory"));
+  else if (argv[2] === "auto") {
+    const action = (argv[3] || "").toLowerCase();
+    if (!action || ["--help", "-h", "help"].includes(action)) { printAutoHelp(); process.exit(0); }
+    runAutoCli(action, argv.slice(4)).catch(failWith("auto"));
+  } else if (["--help", "-h", "help"].includes(argv[2] || "")) {
+    printTopHelp(); process.exit(0);
+  } else {
+    console.error(`Sous-commande inconnue : "${argv[2] || ""}". Essayez : npx pipcode setup`);
+    process.exit(1);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/env-file.js

@@ -0,0 +1,44 @@
+// src/cli/env-file.js — Fichier .env local du projet (racine = cwd) : lecture
+// fail-safe et écriture atomique 0600 (le fichier porte des secrets).
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { tmpNameFor } from "../fs/atomic-write.js";
+import { restrictSecretPerms } from "../fs/permissions.js";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+export const ENV_FILE_NAME = ".env";
+
+/** @param {string} [cwd] @returns {string} */
+export function localEnvPath(cwd = process.cwd()) {
+  return path.join(cwd, ENV_FILE_NAME);
+}
+
+// Lit le .env du projet (null si absent). Illisible → erreur explicite.
+/** @param {string} [cwd] @returns {Promise<string | null>} */
+export async function readLocalEnvText(cwd = process.cwd()) {
+  try {
+    return await fs.readFile(localEnvPath(cwd), "utf8");
+  } catch (e) {
+    const err = /** @type {NodeErr} */ (e);
+    if (err.code === "ENOENT") return null;
+    throw new Error(`Lecture de ${localEnvPath(cwd)} impossible : ${err.message}`);
+  }
+}
+
+// Écriture atomique (tmp à entropie + rename, fallback Windows) durcie 0600.
+/** @param {string} cwd @param {string} text @returns {Promise<void>} */
+export async function writeEnvText(cwd, text) {
+  const target = localEnvPath(cwd);
+  const tmp = tmpNameFor(target);
+  try {
+    await fs.writeFile(tmp, text, { encoding: "utf8", mode: 0o600 });
+    await fs.rename(tmp, target);
+  } catch {
+    await fs.writeFile(target, text, { encoding: "utf8", mode: 0o600 });
+    await fs.rm(tmp, { force: true });
+  }
+  await restrictSecretPerms(target);
+}
+// MODULE_COMPLETE

package/src/cli/env-load.js

@@ -0,0 +1,28 @@
+// src/cli/env-load.js — Chargement du .env local dans l'environnement du
+// processus : allowlist stricte (PLUGCTO_* + OLLAMA_HOST uniquement — jamais
+// PATH & co) et sans écrasement (le shell gagne toujours). Les clés ne servent
+// ensuite qu'aux en-têtes HTTP du provider, jamais au contexte IA.
+
+import { parseEnvFile } from "./env-parse.js";
+import { readLocalEnvText } from "./env-file.js";
+
+/** @typedef {Record<string, string | undefined>} EnvLike */
+
+// Allowlist Zero Trust : le .env PipCode n'injecte QUE ses variables + le
+// host Ollama (anti-détournement d'environnement).
+const ALLOWED = [/^PLUGCTO_/, /^OLLAMA_HOST$/];
+
+/**
+ * Charge le .env du projet (cwd) dans env. Fail-safe : fichier absent → no-op
+ * silencieux ; contenu malformé → lignes invalides ignorées par le parseur.
+ * @param {string} [cwd] @param {EnvLike} [env] @returns {Promise<void>}
+ */
+export async function loadLocalEnv(cwd = process.cwd(), env = process.env) {
+  const text = await readLocalEnvText(cwd);
+  if (text === null) return;
+  for (const [key, value] of Object.entries(parseEnvFile(text))) {
+    if (!ALLOWED.some((re) => re.test(key))) continue;
+    if (!env[key]) env[key] = value;
+  }
+}
+// MODULE_COMPLETE

package/src/cli/env-parse.js

@@ -0,0 +1,39 @@
+// src/cli/env-parse.js — Parseur .env local (pur, zéro dépendance) : lecture
+// KEY=VALUE stricte — identifiants valides uniquement, fail-safe sur lignes
+// malformées, BOM/CRLF/guillemets/commentaires tolérés.
+
+/** @typedef {Record<string, string>} EnvRecord */
+
+// Identifiant .env valide : strict caractère shell (anti-injection de noms).
+const KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+// Nettoie une valeur : retire guillemets encadrants et commentaire de fin.
+/** @param {string} raw @returns {string} */
+function cleanValue(raw) {
+  const v = raw.trim();
+  const quoted = /^"(.*?)"$/.exec(v) || /^'(.*?)'$/.exec(v);
+  if (quoted) return quoted[1];
+  const cut = v.indexOf(" #");
+  return (cut === -1 ? v : v.slice(0, cut)).trim();
+}
+
+/**
+ * Parse un contenu .env en enregistrement { clé: valeur }. Lignes vides,
+ * commentaires, noms invalides et lignes malformées sont ignorés.
+ * @param {string} text @returns {EnvRecord}
+ */
+export function parseEnvFile(text) {
+  /** @type {EnvRecord} */ const out = {};
+  for (const line of text.replace(/^/, "").split(/\r?\n/)) {
+    const l = line.trim();
+    if (!l || l.startsWith("#")) continue;
+    const eq = l.indexOf("=");
+    if (eq < 1) continue;
+    const key = l.slice(0, eq).replace(/^export\s+/, "").trim();
+    if (!KEY_RE.test(key)) continue;
+    const value = cleanValue(l.slice(eq + 1));
+    if (value) out[key] = value;
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/cli/env-rebuild.js

@@ -0,0 +1,33 @@
+// src/cli/env-rebuild.js — Reconstruction du .env : remplace SEULEMENT
+// l'espace de noms PLUGCTO_* par la nouvelle saisie (Entrée vide = choix
+// explicite essai/local) ; les lignes tierces et commentaires de
+// l'utilisateur sont préservées telles quelles, sans duplication de marqueur.
+
+/** @typedef {Record<string, string>} EnvRecord */
+
+// Marqueur du bloc généré par `config` (retiré à la reconstruction pour ne pas
+// s'accumuler à chaque exécution).
+const GEN_MARK = "# --- PipCode (npx pipcode config)";
+const OLD_MARK = "# --- Plug" + " CTO (npx plugcto config)"; // ancien bloc (extension 0.12.x) : retiré à la reconstruction
+
+// Vrai si la ligne porte une clé PLUGCTO_* remplaçable.
+/** @param {string} line @returns {boolean} */
+function isPlugctoKey(line) {
+  const l = line.trim();
+  const eq = l.indexOf("=");
+  if (eq < 1) return false;
+  const key = l.slice(0, eq).replace(/^export\s+/, "").trim();
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && key.startsWith("PLUGCTO_");
+}
+
+/**
+ * Reconstruit le contenu .env à partir de l'existant et des nouvelles paires.
+ * @param {string} existingText @param {EnvRecord} pairs @returns {string}
+ */
+export function rebuildEnvText(existingText, pairs) {
+  const kept = existingText.replace(/^/, "").split(/\r?\n/)
+    .filter((line) => !isPlugctoKey(line) && !line.includes(GEN_MARK) && !line.includes(OLD_MARK));
+  const block = Object.entries(pairs).map(([k, v]) => `${k}=${v}`);
+  return [...kept, GEN_MARK + " — ne jamais committer ---", ...block, ""].join("\n");
+}
+// MODULE_COMPLETE

package/src/cli/gitignore-env.js

@@ -0,0 +1,46 @@
+// src/cli/gitignore-env.js — Garde anti-commit : `.env` (secrets locaux) doit
+// toujours figurer dans le .gitignore du projet ; ajout automatique sinon.
+// Détection : toute ligne non-niée désignant `.env` ou `.env.*` suffit.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+const HEADER = "# PipCode — secrets locaux (.env) : ne jamais committer";
+
+// Vrai si le contenu ignore déjà `.env` (motif `.env` exact ou préfixe
+// `.env.*` ; les négations `!.env` ne comptent pas).
+/** @param {string} text @returns {boolean} */
+export function gitignoreHasEnv(text) {
+  return text.split(/\r?\n/).some((line) => {
+    const t = line.trim();
+    return !t.startsWith("!") && (t === ".env" || t.startsWith(".env."));
+  });
+}
+
+// Ajoute `.env` au .gitignore du projet (créé si absent, inchangé si déjà
+// présent). Best-effort : un .gitignore non lisible/inscriptible est signalé
+// sans faire échouer `config`.
+/** @param {string} [cwd] @returns {Promise<void>} */
+export async function ensureEnvIgnored(cwd = process.cwd()) {
+  const gi = path.join(cwd, ".gitignore");
+  /** @type {string} */ let text = "";
+  try {
+    text = await fs.readFile(gi, "utf8");
+  } catch (e) {
+    const err = /** @type {NodeErr} */ (e);
+    if (err.code !== "ENOENT") {
+      console.error(`  ⚠️  .gitignore illisible (${err.message}) : vérifiez que .env est ignoré manuellement.`);
+      return;
+    }
+  }
+  if (gitignoreHasEnv(text)) return;
+  const glue = text === "" || text.endsWith("\n") ? "" : "\n";
+  try {
+    await fs.writeFile(gi, text + glue + `${HEADER}\n.env\n`, "utf8");
+  } catch (e) {
+    console.error(`  ⚠️  Impossible d'ajouter .env au .gitignore (${/** @type {NodeErr} */ (e).message}) : faites-le manuellement.`);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/help.js

@@ -0,0 +1,28 @@
+// src/cli/help.js — Textes d'aide CLI du hub d'entrée (setup / auto / --help).
+// Extraits du dispatcher bin/setup.js pour garder l'entry point <50 lignes.
+
+// Aide du Mode Auto : plan / run / resume (orchestrateur d'autonomie, BYOK).
+export function printAutoHelp() {
+  console.log("PipCode — Mode Auto (orchestrateur d'autonomie, BYOK)\n");
+  console.log("Usage :");
+  console.log('  npx pipcode auto plan   --need "…" --project ./monrepo   Génère le roadmap + estimation (dry-run).');
+  console.log("  npx pipcode auto run    --project ./monrepo [--yes]        Exécute (consentement Y/n requis).");
+  console.log("  npx pipcode auto resume --project ./monrepo                Reprend après crash/arrêt.");
+  console.log('  npx pipcode auto ask    --need "…" --project ./monrepo   Conversation pure : posez votre question à votre IA (aucune exécution).');
+  console.log("  Option --require vision,tools,media_generation : vérifie AVANT l'appel que le modèle sait faire la tâche (sinon arrêt, 0 token).");
+}
+
+// Aide générale : setup / auto / --help.
+export function printTopHelp() {
+  console.log("PipCode — auto-configuration MCP (Zero-Click)\n");
+  console.log("Usage :");
+  console.log("  npx pipcode setup    Configure le serveur MCP PipCode dans les IDE détectés.");
+  console.log("  npx pipcode setup --key <CLÉ>  Enregistre la clé de licence Pro (Polar.sh) —");
+  console.log("                        utilisable par un agent IA, sans interaction.");
+  console.log("  npx pipcode teardown    Retire PipCode de vos outils (seule l'entrée PipCode est supprimée).");
+  console.log("  npx pipcode config   Saisie interactive des clés (licence + BYOK) → .env local du");
+  console.log("                        projet, hors Git (Entrée = essai 5 jours / mode local).");
+  console.log("  npx pipcode auto     Mode Auto : plan / run / resume / ask (orchestrateur d'autonomie + conversation).");
+  console.log("  npx pipcode --help   Affiche cette aide.");
+}
+// MODULE_COMPLETE

package/src/cli/ide-entries.js

@@ -0,0 +1,42 @@
+// src/cli/ide-entries.js — Candidats de config IDE (entrées brutes avant enrich).
+// coreIdeEntries : Cursor, Claude Desktop, Claude Code, Windsurf, Gemini CLI, Hermes,
+// OpenClaw (schéma mcpServers) + Codex (TOML, partagé avec l'app ChatGPT desktop).
+// uiIdeEntries : VS Code natif (servers), VS 2022 (Windows, servers), Continue
+// (mcpServers), Zed (context_servers). Chaque entrée = { id, name, path, schema? }.
+
+import path from "node:path";
+
+/** @typedef {{ id: string, name: string, path: string, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigCandidate */
+
+// Entrées cœur (toutes plateformes ; JSON mcpServers sauf Codex = TOML).
+/** @param {string} home @param {string} configRoot @returns {IdeConfigCandidate[]} */
+export function coreIdeEntries(home, configRoot) {
+  return [
+    { id: "cursor", name: "Cursor", path: path.join(home, ".cursor", "mcp.json") },
+    { id: "claude-desktop", name: "Claude Desktop", path: path.join(configRoot, "Claude", "claude_desktop_config.json") },
+    { id: "claude-code", name: "Claude Code", path: path.join(home, ".claude.json") },
+    { id: "windsurf", name: "Windsurf", path: path.join(home, ".codeium", "windsurf", "mcp_config.json") },
+    { id: "gemini-cli", name: "Gemini CLI", path: path.join(home, ".gemini", "settings.json") },
+    { id: "codex", name: "Codex / ChatGPT", path: path.join(home, ".codex", "config.toml"), schema: "toml" },
+    { id: "hermes", name: "Hermes (CLI)", path: path.join(home, ".hermes", "config.json") },
+    { id: "openclaw", name: "OpenClaw (CLI)", path: path.join(home, ".openclaw", "mcp.json") },
+  ];
+}
+
+// Entrées UI : VS Code natif (MCP natif 1.106+, schéma servers), VS 2022 (Windows
+// only, schéma servers avec type:stdio), Continue (VS Code + JetBrains, mcpServers),
+// Zed (context_servers ; %APPDATA%\Zed sous Windows, ~/.config/zed ailleurs).
+/** @param {string} osName @param {string} codeUser @param {string} home @param {string} [configRoot] @returns {IdeConfigCandidate[]} */
+export function uiIdeEntries(osName, codeUser, home, configRoot = path.join(home, ".config")) {
+  const zedDir = osName === "windows" ? path.join(configRoot, "Zed") : path.join(osName === "macos" ? path.join(home, ".config") : configRoot, "zed");
+  /** @type {IdeConfigCandidate[]} */ const entries = [
+    { id: "vscode", name: "VS Code (natif)", path: path.join(codeUser, "mcp.json"), schema: "servers" },
+    { id: "continue", name: "Continue (VS Code + JetBrains)", path: path.join(home, ".continue", "config.json") },
+    { id: "zed", name: "Zed", path: path.join(zedDir, "settings.json"), schema: "context_servers" },
+  ];
+  if (osName === "windows") {
+    entries.push({ id: "vs-2022", name: "Visual Studio 2022", path: path.join(home, ".mcp.json"), schema: "servers" });
+  }
+  return entries;
+}
+// MODULE_COMPLETE

package/src/cli/ide-paths.js

@@ -0,0 +1,37 @@
+// src/cli/ide-paths.js — Localisation des fichiers de config IDE (orchestrateur).
+// Combine les entrées cœur + UI + JetBrains, puis enrichit chaque candidat avec
+// parentExists (dossier parent présent = IDE probablement installé ; pour un fichier posé DIRECTEMENT dans le dossier personnel,
+// le dossier existe toujours : seul le fichier déjà présent prouve l'outil — PipCode ne crée pas ~/.claude.json ni ~/.mcp.json pour un outil absent) et configExists
+// (fichier JSON déjà présent). `osName`/`env`/`home` injectables pour les tests.
+
+import path from "node:path";
+import os from "node:os";
+import { existsSync } from "node:fs";
+import { detectOS } from "./detect-os.js";
+import { ideConfigRoot } from "./ide-roots.js";
+import { coreIdeEntries, uiIdeEntries } from "./ide-entries.js";
+import { jetbrainsCandidates } from "./jetbrains.js";
+
+/** @typedef {{ id: string, name: string, path: string, parentExists: boolean, configExists: boolean, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigEntry */
+
+/**
+ * @param {string} [osName]
+ * @param {Record<string, string | undefined>} [env]
+ * @param {string} [home]
+ * @returns {IdeConfigEntry[]}
+ */
+export function ideConfigPaths(osName = detectOS(), env = process.env, home = os.homedir()) {
+  const { configRoot, codeUser } = ideConfigRoot(osName, env || {}, home);
+  /** @type {Array<{ id: string, name: string, path: string, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }>} */
+  const entries = [
+    ...coreIdeEntries(home, configRoot),
+    ...uiIdeEntries(osName, codeUser, home, configRoot),
+    ...jetbrainsCandidates(osName, env || {}, home, configRoot),
+  ];
+  return entries.map((e) => ({
+    ...e,
+    parentExists: existsSync(path.dirname(e.path)) && (path.resolve(path.dirname(e.path)) !== path.resolve(home) || existsSync(e.path)),
+    configExists: existsSync(e.path),
+  }));
+}
+// MODULE_COMPLETE

package/src/cli/ide-roots.js

@@ -0,0 +1,25 @@
+// src/cli/ide-roots.js — Racines de config IDE par OS (bornées sous home).
+// Un override env (APPDATA / XDG_CONFIG_HOME) hors home est ignoré : empêche de
+// rediriger l'écriture des clés API hors du profil utilisateur.
+
+import path from "node:path";
+import { boundRoot, DEFAULT_XDG, DEFAULT_APPDATA } from "../fs/config-path.js";
+
+/** @typedef {{ configRoot: string, codeUser: string, defaultXdg: string }} IdeRoots */
+
+// Calcule les racines config par OS + le dossier User de VS Code (varie par OS).
+/** @param {string} osName @param {Record<string, string | undefined>} env @param {string} home @returns {IdeRoots} */
+export function ideConfigRoot(osName, env, home) {
+  const defaultXdg = DEFAULT_XDG(home);
+  const defaultAppData = DEFAULT_APPDATA(home);
+  const configRoot = osName === "macos"
+    ? path.join(home, "Library", "Application Support")
+    : osName === "windows"
+      ? boundRoot(env.APPDATA, home, defaultAppData)
+      : boundRoot(env.XDG_CONFIG_HOME, home, defaultXdg);
+  const codeUser = osName === "macos" || osName === "windows"
+    ? path.join(configRoot, "Code", "User")
+    : path.join(boundRoot(env.XDG_CONFIG_HOME, home, defaultXdg), "Code", "User");
+  return { configRoot, codeUser, defaultXdg };
+}
+// MODULE_COMPLETE

package/src/cli/interactive.js

@@ -0,0 +1,26 @@
+// src/cli/interactive.js — Flux interactif TTY (collectInteractive) : authentification seule (token + e-mail centralisés). Retourne { licenseKey, email }. Aucune clé d'IA
+// n'est demandée. Dépendances injectées pour les tests.
+
+import { makePrompts } from "./prompts.js";
+import { collectAuth } from "./auth-interactive.js";
+import { authViaBrowser } from "../net/auth-browser.js";
+import { authViaEmail } from "../auth/auth-email.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedInteractive */
+/** @typedef {{ installedAt?: string, clientId?: string, licenseKey?: string, email?: string, trialExpiredNotified?: boolean }} SharedConfig */
+/** @typedef {{ key: string, email: string, source: "browser", error?: string }} AuthBrowserResult */
+/** @typedef {{ found: boolean, tier: string | null, email: string, source: "email", error?: string }} AuthEmailResult */
+/** @typedef {{ browser?: () => Promise<AuthBrowserResult>, emailLookup?: (email: string) => Promise<AuthEmailResult>, existingConfig?: SharedConfig }} CollectInteractiveOpts */
+
+import { Interface } from "node:readline/promises";
+
+/**
+ * @param {Interface} rl
+ * @param {CollectInteractiveOpts} [opts]
+ * @returns {Promise<CollectedInteractive>}
+ */
+export async function collectInteractive(rl, { browser = authViaBrowser, emailLookup = authViaEmail, existingConfig = {} } = {}) {
+  const { licenseKey, email } = await collectAuth(makePrompts(rl), { browser, emailLookup, existingConfig });
+  return { licenseKey, email };
+}
+// MODULE_COMPLETE

package/src/cli/jetbrains.js

@@ -0,0 +1,40 @@
+// src/cli/jetbrains.js — Énumération des produits JetBrains installés.
+// Scanne le dossier JetBrains/<Produit>/ et émet une entrée mcp.json par sous-dossier
+// produit trouvé. Retourne [] si le dossier n'existe pas. Filtré : sous-dossiers
+// only, pas de hidden. id normalisé "jetbrains-<produit>".
+
+import path from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { boundRoot, DEFAULT_XDG, DEFAULT_APPDATA } from "../fs/config-path.js";
+
+/** @typedef {{ id: string, name: string, path: string, schema?: "mcpServers" | "servers" }} IdeConfigCandidate */
+
+/**
+ * @param {string} osName
+ * @param {Record<string, string | undefined>} env
+ * @param {string} home
+ * @param {string} _configRoot
+ * @returns {IdeConfigCandidate[]}
+ */
+export function jetbrainsCandidates(osName, env, home, _configRoot) {
+  const jbRoot = osName === "macos"
+    ? path.join(home, "Library", "Application Support", "JetBrains")
+    : osName === "windows"
+      ? path.join(boundRoot(env.APPDATA, home, DEFAULT_APPDATA(home)), "JetBrains")
+      : path.join(boundRoot(env.XDG_CONFIG_HOME, home, DEFAULT_XDG(home)), "JetBrains");
+  if (!existsSync(jbRoot)) return [];
+  /** @type {string[]} */ let dirs = [];
+  try {
+    dirs = readdirSync(jbRoot).filter((d) => {
+      if (d.startsWith(".")) return false;
+      try { return statSync(path.join(jbRoot, d)).isDirectory(); } catch { return false; }
+    });
+  } catch {
+    return [];
+  }
+  return dirs.map((d) => {
+    const slug = d.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return { id: `jetbrains-${slug}`, name: `JetBrains — ${d}`, path: path.join(jbRoot, d, "mcp.json") };
+  });
+}
+// MODULE_COMPLETE

package/src/cli/legacy-entry.js

@@ -0,0 +1,17 @@
+// src/cli/legacy-entry.js — Ancien nom de l'entrée MCP (« plugcto » puis « vcto », avant le passage à « pipcode ») : à la réinstallation il est remplacé, à la désinstallation il est retiré aussi.
+// Seule une entrée qui est bien la nôtre (variables PLUGCTO_* ou point d'entrée index.js) est touchée : un serveur d'un autre nom n'est jamais supprimé.
+
+export const LEGACY_SERVER_KEYS = ["plugcto", "vcto"];
+
+/** @param {unknown} entry @returns {boolean} */
+export function isOurLegacyEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const e = /** @type {{ env?: Record<string, unknown>, args?: unknown }} */ (entry);
+  return Object.keys(e.env || {}).some((k) => k.startsWith("PLUGCTO_")) || (Array.isArray(e.args) && String(e.args[0] || "").endsWith("index.js"));
+}
+
+/** @param {Record<string, unknown>} bucket @returns {void} retire l'ancienne entrée du dictionnaire de serveurs si elle est la nôtre */
+export function dropLegacyEntry(bucket) {
+  for (const k of LEGACY_SERVER_KEYS) if (isOurLegacyEntry(bucket[k])) delete bucket[k];
+}
+// MODULE_COMPLETE

package/src/cli/main.js

@@ -0,0 +1,42 @@
+// src/cli/main.js — Orchestrateur du setup (`npx pipcode setup`).
+// Détection OS → bannière → collecte → centralisation → sélection cibles → application.
+// Entry point : aucune logique métier, coordonne seulement les micro-modules.
+
+import path from "node:path";
+import { stdin } from "node:process";
+import { detectOS } from "./detect-os.js";
+import { ideConfigPaths } from "./ide-paths.js";
+import { printBanner } from "./banner.js";
+import { collectForSetup } from "./collect-step.js";
+import { centralizeConfig } from "./centralize.js";
+import { selectTargets } from "./target-select.js";
+import { applyToTargets } from "./apply-loop.js";
+import { WELCOME_MESSAGE } from "./welcome.js";
+import { detectPackageManager } from "../core/pkg-manager.js";
+import { applyKeyToEnv } from "./setup-args.js";
+
+// Chemin absolu vers index.js (racine projet).
+const INDEX_JS = path.resolve(import.meta.dirname, "..", "..", "index.js");
+
+// Entry point du setup : orchestration des 4 étapes.
+export async function main() {
+  // `--key <LICENSE_KEY>` : enregistrement direct par un agent IA (non-TTY).
+  // slice(2) tolère `setup --key K` comme `--key K` (sous-commande par défaut).
+  applyKeyToEnv(process.argv.slice(2), process.env);
+  const osName = detectOS();
+  const candidates = ideConfigPaths(osName);
+  const detected = candidates.filter((c) => c.parentExists);
+  printBanner(osName, candidates);
+  const pm = detectPackageManager();
+  console.log(`  📦 Gestionnaire détecté : ${pm.label} — routines 100 % Node.js pur, indépendantes de npm/pnpm/yarn/bun.`);
+  const isTTY = stdin.isTTY;
+  const collected = await collectForSetup(isTTY);
+  await centralizeConfig(collected);
+  const targets = await selectTargets(detected, candidates, isTTY);
+  if (!targets) { if (!isTTY) process.exit(0); return; }
+  await applyToTargets(targets, collected, INDEX_JS);
+  console.log("\n  ✅ Configuration terminée. Redémarrez l'IDE pour activer le serveur MCP PipCode.");
+  console.log(`\n  ${WELCOME_MESSAGE}`); // préenregistré : zéro token (exigence produit)
+  if (!isTTY) process.exit(0);
+}
+// MODULE_COMPLETE

package/src/cli/memory-cli.js

@@ -0,0 +1,15 @@
+// src/cli/memory-cli.js — `memory index --project <chemin>` : carte exacte du projet (gratuit, aucun LLM, aucun réseau, hors
+// ligne). Sortie : UNE ligne JSON. La mémoire rédigée se construit au fil des messages du chat (balises de la réponse).
+
+import { parseAutoFlags, resolveProjectPath } from "./auto-flags.js";
+import { indexProject } from "../project-memory/memory-build.js";
+
+/** @param {string} sub @param {string[]} argv @returns {Promise<void>} */
+export async function runMemoryCli(sub, argv) {
+  const project = resolveProjectPath(parseAutoFlags(argv));
+  if (sub !== "index") { console.error("Sous-action memory inconnue. Essayez : index"); process.exitCode = 2; return; }
+  const { index, diff } = await indexProject(project);
+  const bytes = Object.values(index.files).reduce((n, e) => n + e.bytes, 0); // taille des sources : sert à estimer le coût d'une analyse
+  console.log(JSON.stringify({ files: Object.keys(index.files).length, bytes, ...diff }));
+}
+// MODULE_COMPLETE

package/src/cli/prompts.js

@@ -0,0 +1,24 @@
+// src/cli/prompts.js — Helpers de saisie readline (flux interactif TTY).
+// ask : saisie simple trimée. askDefault : valeur par défaut si Entrée.
+// askRequired : boucle jusqu'à valeur non vide (valeur requise).
+
+/** @typedef {{ ask: (q: string) => Promise<string>, askDefault: (q: string, def: string | undefined) => Promise<string>, askRequired: (q: string) => Promise<string> }} Prompts */
+
+// Fabrique les helpers de saisie liés à une interface readline donnée.
+/** @param {import("node:readline/promises").Interface} rl @returns {Prompts} */
+export function makePrompts(rl) {
+  const ask = async (/** @type {string} */ q) => (await rl.question(q)).trim();
+  const askDefault = async (/** @type {string} */ q, /** @type {string | undefined} */ def) => {
+    const a = (await rl.question(q)).trim();
+    return /** @type {string} */ (a || def);
+  };
+  const askRequired = async (/** @type {string} */ q) => {
+    while (true) {
+      const a = (await rl.question(q)).trim();
+      if (a) return a;
+      console.error("  ⚠️  Valeur requise. Réessayez.");
+    }
+  };
+  return { ask, askDefault, askRequired };
+}
+// MODULE_COMPLETE

package/src/cli/server-entry.js

@@ -0,0 +1,42 @@
+// src/cli/server-entry.js — Construction de l'entrée serveur MCP PipCode + merge.
+// buildServerEntry : { command, args, env } pointant vers l'exécutable local
+// index.js. mergeConfig : injection idempotent (préservation STRICTE des autres
+// serveurs MCP et de toutes les autres clés du fichier). Retourne un NOUVEL objet.
+
+import { dropLegacyEntry } from "./legacy-entry.js";
+
+export const SERVER_KEY = "pipcode"; // nom sous lequel les agents voient PipCode : /mcp__pipcode__licence dans Claude Code
+
+/** @typedef {{ command: string, args: string[], env: Record<string, string> }} ServerEntry */
+
+// `envVars` = objet plat des variables BYOK injectées dans l'env du process MCP.
+/** @param {string} indexAbsPath @param {Record<string, string>} envVars @returns {ServerEntry} */
+export function buildServerEntry(indexAbsPath, envVars) {
+  return { command: "node", args: [indexAbsPath], env: { ...envVars } };
+}
+
+// `schema` : "mcpServers" (défaut, { command, args, env }), "servers" (VS Code natif /
+// VS 2022, entrée stdio avec "type": "stdio" requis en tête) ou "context_servers"
+// (Zed, même forme { command, args, env } sous une autre clé racine).
+/**
+ * @param {Record<string, unknown>} config
+ * @param {ServerEntry} serverEntry
+ * @param {string} [key]
+ * @param {"mcpServers" | "servers" | "context_servers"} [schema]
+ * @returns {Record<string, unknown>}
+ */
+export function mergeConfig(config, serverEntry, key = SERVER_KEY, schema = "mcpServers") {
+  const next = (config && typeof config === "object" && !Array.isArray(config))
+    ? { .../** @type {Record<string, unknown>} */ (config) }
+    : {};
+  const rootKey = schema === "servers" || schema === "context_servers" ? schema : "mcpServers";
+  const bucket = (next[rootKey] && typeof next[rootKey] === "object" && !Array.isArray(next[rootKey]))
+    ? { .../** @type {Record<string, unknown>} */ (next[rootKey]) }
+    : {};
+  if (key === SERVER_KEY) dropLegacyEntry(bucket); // les anciennes entrées « plugcto » / « vcto » sont remplacées, jamais doublées
+  // Schéma "servers" : "type": "stdio" requis en tête (on ne mute pas serverEntry).
+  bucket[key] = schema === "servers" ? { type: "stdio", ...serverEntry } : serverEntry;
+  next[rootKey] = bucket;
+  return next;
+}
+// MODULE_COMPLETE

package/src/cli/setup-args.js

@@ -0,0 +1,39 @@
+// src/cli/setup-args.js — Argument `--key <LICENSE_KEY>` de `npx pipcode setup`.
+// Objectif : un agent IA peut enregistrer la clé de licence directement lors de
+// l'installation CLI (non-TTY). Zero Trust : format strictement validé, rejet
+// propre si malformée ; l'injection env n'écrase JAMAIS une valeur existante.
+
+/** @typedef {Record<string, string | undefined>} EnvLike */
+
+// Format attendu d'une clé de licence Polar.sh (alphanum, tirets/underscores).
+// Exporté : partagé avec config-pairs.js (zéro duplication de la règle).
+export const KEY_RE = /^[A-Za-z0-9_-]{8,128}$/;
+
+/**
+ * Extrait la valeur de `--key <K>` ou `--key=<K>` (absent → null). Malformée → Error.
+ * @param {string[]} argv Arguments SANS le binaire (ex: ["setup", "--key", "X"]).
+ * @returns {string | null}
+ */
+export function extractKeyArg(argv) {
+  const i = argv.findIndex((a) => a === "--key" || a.startsWith("--key="));
+  if (i === -1) return null;
+  const raw = argv[i] === "--key" ? (i + 1 < argv.length ? argv[i + 1] : "") : argv[i].slice("--key=".length);
+  const key = String(raw || "").trim();
+  if (!KEY_RE.test(key)) {
+    throw new Error("Argument --key invalide : clé de licence malformée (8-128 caractères alphanumériques, tirets ou underscores).");
+  }
+  return key;
+}
+
+/**
+ * Injecte la clé dans env.PLUGCTO_LICENSE_KEY (sans écraser une valeur existante).
+ * @param {string[]} argv
+ * @param {EnvLike} env
+ * @returns {string | null}
+ */
+export function applyKeyToEnv(argv, env) {
+  const key = extractKeyArg(argv);
+  if (key && !env.PLUGCTO_LICENSE_KEY) env.PLUGCTO_LICENSE_KEY = key;
+  return key;
+}
+// MODULE_COMPLETE