pipcode 0.0.0-stage → 2.1.0

package/src/auto/backup-touched.js

@@ -0,0 +1,30 @@
+// src/auto/backup-touched.js — Avant qu'un diff modifie des fichiers, copie leur état ACTUEL sous PLUGCTO_BACKUP_DIR (dossier absolu
+// fourni par l'extension : « sauvegarde du <date> » dans le dossier des sauvegardes PipCode). Sans cette variable : aucune sauvegarde. Chemins du diff = non fiables :
+// tout chemin qui sortirait du projet est refusé. Une sauvegarde déjà prise dans ce dossier n'est jamais écrasée (l'original du run).
+import fs from "node:fs/promises";
+import path from "node:path";
+import { touchedFilesFromDiff } from "./diff.js";
+
+/** @param {string} root @param {string} rel @returns {string | null} chemin absolu dans root, sinon null */
+function inside(root, rel) {
+  const abs = path.resolve(root, rel);
+  const back = path.relative(root, abs);
+  return back && !back.startsWith("..") && !path.isAbsolute(back) ? abs : null;
+}
+
+/** @param {string} projectPath @param {string} diff @param {string | undefined} [dir] @returns {Promise<string[]>} fichiers sauvegardés */
+export async function backupTouched(projectPath, diff, dir = process.env.PLUGCTO_BACKUP_DIR) {
+  if (!dir || !path.isAbsolute(dir)) return [];
+  /** @type {string[]} */ const saved = [];
+  for (const rel of touchedFilesFromDiff(diff)) {
+    const src = inside(projectPath, rel);
+    const dst = inside(dir, rel);
+    if (!src || !dst) throw new Error(`Chemin refusé (hors du projet) : ${rel}`);
+    const exists = await fs.stat(src).then((s) => s.isFile(), () => false); // fichier nouveau : rien à sauvegarder
+    if (!exists) continue;
+    await fs.mkdir(path.dirname(dst), { recursive: true });
+    await fs.copyFile(src, dst, fs.constants.COPYFILE_EXCL).then(() => saved.push(rel), (e) => { if (/** @type {NodeJS.ErrnoException} */ (e).code !== "EEXIST") throw e; });
+  }
+  return saved;
+}
+// MODULE_COMPLETE

package/src/auto/budget.js

@@ -0,0 +1,52 @@
+// src/auto/budget.js — Pilier 1 : Budget / Devis (pur, 0 appel LLM).
+// estimateTaskTokens : tokens d'une tâche (analysis + patch). estimateRelayCost :
+// coût des relais de contexte (fichier > zone de confort → agents supplémentaires).
+// estimateRunBudget : coût d'exécution (N appels + relais) + headroom ×1.3.
+
+import { lookupPrice } from "./pricing.js";
+import { localCapacity, readLocalWindow } from "../engine/context-margin.js";
+import { countRelays, fragmentBudget } from "../engine/context-relay.js";
+import { readSecondaryProvider } from "../core/llm-config-secondary.js";
+
+// Tokens du passage de contrôle duo (Phase 3) : le contrôle peut réémettre un
+// diff complet → même budget que le patch, si et seulement si un provider
+// SECONDAIRE est configuré (le moteur ne facture que ce qu'il exécute).
+/** @param {AutoDeps} deps @param {number} fileBytes @param {Record<string, string | undefined>} [env] @returns {number} */
+export function estimateControlTokens(deps, fileBytes, env = process.env) {
+  const { secondary } = readSecondaryProvider(env);
+  if (!secondary) return 0;
+  return deps.patchMaxTokens(Number(fileBytes) || 0);
+}
+
+// Tokens d'une tâche (analysis max + patch max + contrôle duo éventuel).
+/** @param {AutoDeps} deps @param {number} fileBytes @returns {number} */
+export function estimateTaskTokens(deps, fileBytes) {
+  return deps.ANALYSIS_MAX_TOKENS + deps.patchMaxTokens(Number(fileBytes) || 0) + estimateControlTokens(deps, fileBytes);
+}
+
+// Coût des relais d'UNE tâche : ~4 chars/token, chaque agent relais refacture
+// une analyse complète (ANALYSIS_MAX_TOKENS). Fenêtre injectable pour les tests.
+/** @param {AutoDeps} deps @param {number} fileBytes @param {number} [windowTokens] @returns {{ relays: number, tokens: number }} */
+export function estimateRelayCost(deps, fileBytes, windowTokens = readLocalWindow()) {
+  const frag = fragmentBudget(localCapacity(windowTokens));
+  const relays = countRelays(Math.ceil((Number(fileBytes) || 0) / 4), frag);
+  return { relays, tokens: relays * (deps && deps.ANALYSIS_MAX_TOKENS || 0) };
+}
+
+// Estime le coût d'exécution (N appels + relais) + headroom re-attaque ×1.3 (MAX_QA_ATTEMPTS=3).
+/** @param {AutoTask[]} tasks @param {MissionPlan} _mission @param {Record<string, number>} fileSizes @param {AutoDeps} deps @param {{ primary: ProviderPrimary }} pcfg @returns {AutoBudgetResult} */
+export function estimateRunBudget(tasks, _mission, fileSizes, deps, pcfg) {
+  let runTokens = 0, relayTokens = 0, relaysEst = 0;
+  const perTask = tasks.map((t) => {
+    const size = (fileSizes && fileSizes[t.file]) || 0;
+    const tTokens = estimateTaskTokens(deps, size);
+    const relay = estimateRelayCost(deps, size);
+    runTokens += tTokens + relay.tokens; relayTokens += relay.tokens; relaysEst += relay.relays;
+    return { id: t.id, file: t.file, tokens: tTokens, relayTokens: relay.tokens };
+  });
+  runTokens = Math.round(runTokens * 1.3); // Headroom re-attaque (moyenne prudente).
+  const price = lookupPrice(pcfg && pcfg.primary && pcfg.primary.provider, pcfg && pcfg.primary && pcfg.primary.model);
+  const costUsdEst = Math.round((runTokens / 1_000_000) * price.out * 10000) / 10000; // prix output (conservateur).
+  return { tokensEst: runTokens, costUsdEst, perTask, relaysEst, relayTokensEst: Math.round(relayTokens * 1.3) };
+}
+// MODULE_COMPLETE

package/src/auto/cancel.js

@@ -0,0 +1,20 @@
+// src/auto/cancel.js — Arrêt demandé par l'utilisateur pendant le Mode Auto : le plan est sauvegardé en PAUSE (statut « paused »), la tâche en cours
+// reste « pending » (aucun échec compté), rien n'est perdu ; une reprise (auto resume) repart de cette tâche.
+import { loadAutoState, saveAutoState, progressOf } from "./state.js";
+
+export const CANCEL_EXIT_CODE = 4;
+
+/** @param {StepCtx} ctx @returns {Promise<AutoResult>} */
+export async function cancelExit({ state, projectPath, task }) {
+  state.status = "paused"; state.updatedAt = new Date().toISOString();
+  await saveAutoState(projectPath, state);
+  return { cancelled: true, status: "paused", task, progress: progressOf(state) };
+}
+
+/** Pause du plan sans tâche en cours (arrêt entre deux tâches). @param {string} projectPath @returns {Promise<AutoResult>} */
+export async function pauseRun(projectPath) {
+  const state = await loadAutoState(projectPath);
+  if (state && state.status === "running") { state.status = "paused"; state.updatedAt = new Date().toISOString(); await saveAutoState(projectPath, state); }
+  return { cancelled: true, status: "paused", progress: state ? progressOf(state) : undefined };
+}
+// MODULE_COMPLETE

package/src/auto/constants.js

@@ -0,0 +1,30 @@
+// src/auto/constants.js — Constantes du Mode Auto (timings, caps, état, retry).
+// Aucune dépendance. LLM_RETRY est mutable/exporté pour raccourcir les délais en test.
+
+// Status HTTP retryables (429 rate-limit, 5xx serveur, 408/409/425 timeout/conflit).
+export const LLM_RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+
+// Extensions de fichiers source reconnues (borne anti-monospace sur git ls-files).
+export const SRC_EXT =
+  /\.(js|mjs|cjs|ts|mts|cts|tsx|jsx|py|go|rs|java|kt|rb|php|cs|c|cpp|h|hpp|vue|svelte|sql|sh|bash|ps1|yaml|yml|json|toml)$/i;
+
+// --- Constantes ---------------------------------------------------------------
+export const AUTO_STATE_VERSION = 1;
+export const AUTO_STATE_FILENAME = "auto-state.json";
+export const MAX_QA_ATTEMPTS = 3; // doctrine orchestration_pipeline.md (Dev↔QA loop).
+export const MAX_LS_FILES = 300; // borne anti-monospace sur `git ls-files`.
+export const TASK_DECOMP_MAX_TOKENS = 4096; // large : tableau JSON de micro-tâches.
+export const GIT_TIMEOUT_MS = 30_000; // défensive_engineering : tout I/O borné.
+export const NODE_CHECK_TIMEOUT_MS = 15_000;
+export const MAX_EXEC_TURNS = 3; // boucle auto-corrective : tours AGIR → OBSERVER → ÉVALUER → CORRIGER avant la pause.
+export const MAX_CONSECUTIVE_FAILURES = 3; // garde-fou : cap d'échecs consécutifs Auto.
+export const GREEN_TSC_TIMEOUT_MS = 180_000; // gate tsc --noEmit du projet client.
+export const GREEN_TEST_TIMEOUT_MS = 600_000; // gate npm test du projet client.
+
+// U3 — Retry/backoff sur erreurs provider transient. Borné pour ne pas bloquer le
+// Mode Auto indéfiniment. Backoff exponentiel + jitter (anti thundering herd).
+// Config mutable (exporté) pour raccourcir les délais en test sans toucher au
+// timing de production.
+/** @type {RetryConfig} */
+export const LLM_RETRY = { maxRetries: 3, baseMs: 800 }; // 0.8s, 1.6s, 3.2s (±jitter).
+// MODULE_COMPLETE

package/src/auto/crypto-util.js

@@ -0,0 +1,17 @@
+// src/auto/crypto-util.js — Empreintes cryptographiques (sha8, sha256).
+// Utilisées pour le runId, le missionHash et le nonce des fichiers temporaires.
+
+import crypto from "node:crypto";
+
+// sha256 tronqué à 8 hex (runId, identifiants courts).
+/** @param {unknown} input @returns {string} */
+export function sha8(input) {
+  return crypto.createHash("sha256").update(String(input), "utf8").digest("hex").slice(0, 8);
+}
+
+// sha256 complet (missionHash, ancrage d'intégrité).
+/** @param {unknown} input @returns {string} */
+export function sha256(input) {
+  return crypto.createHash("sha256").update(String(input), "utf8").digest("hex");
+}
+// MODULE_COMPLETE

package/src/auto/decompose.js

@@ -0,0 +1,47 @@
+// src/auto/decompose.js — Décomposition LLM d'un cahier des charges en micro-tâches.
+// decomposeAutoTasks : git ls-files + doctrine complète + 1 appel LLM (smart_model)
+// avec retry transient, puis normalizeTasks. Best-effort doctrine (trial sans quota).
+
+import { listProjectFiles } from "./project-files.js";
+import { normalizeTasks } from "./tasks.js";
+import { withTransientRetry } from "./retry.js";
+import { TASK_DECOMP_MAX_TOKENS } from "./constants.js";
+import { TRUNCATED } from "../engine/json-balance.js";
+import { taskDecompPrompt } from "./prompts.js";
+import { adjustBlock, feasibilityNotice, dropImpossible } from "./adjust.js";
+import { buildGraph } from "../engine/code-graph.js";
+import { formatRelations } from "../engine/project-context.js";
+import { projectBrief } from "../engine/project-brief.js";
+
+// Décompose le besoin en AutoTask[] via LLM. Retourne { tasks } ou { error }.
+/** @param {string} need @param {string} projectPath @param {{ primary: ProviderPrimary }} pcfg @param {PlugConfig} cfg @param {AutoDeps} deps @param {string} missionCtx @param {string} [adjust] @returns {Promise<{ notice?: string, tasks?: AutoTask[], error?: string }>} */
+export async function decomposeAutoTasks(need, projectPath, pcfg, cfg, deps, missionCtx, adjust) {
+  const repoFiles = await listProjectFiles(projectPath);
+  let doctrine = "";
+  try { doctrine = await deps.loadAllDoctrine(cfg); } catch { /* best-effort : trial sans quota Pro */ }
+  const doctrineBlock = doctrine ? `\n\nDoctrine (règles absolues à respecter dans la décomposition):\n${doctrine}\n` : "";
+  const relations = formatRelations(await buildGraph(projectPath, repoFiles)); // graphe : qui importe quoi (une seule fois)
+  const instructions = await projectBrief(projectPath); // CLAUDE.md du client + décisions validées de la mémoire : complétés par les règles PipCode, jamais écrasés
+  const userText =
+    (instructions ? `${instructions}\n\n` : "") + `${missionCtx}\n\nFichiers du dépôt (${repoFiles.length} fichiers source retenus) :\n${repoFiles.join("\n")}\n\n` +
+    (relations ? `Relations entre fichiers (imports, symboles déclarés) :\n${relations}\n\n` : "") +
+    `Cahier des charges : ${need}${adjustBlock(adjust)}${doctrineBlock}`;
+  const smartModel = (pcfg.primary.smartModel || pcfg.primary.model);
+  let raw;
+  try {
+    raw = await withTransientRetry(() => deps.callLLM({
+      provider: pcfg.primary.provider, key: pcfg.primary.key,
+      model: smartModel, base: pcfg.primary.base,
+      systemPrompt: taskDecompPrompt(), userText, maxTokens: TASK_DECOMP_MAX_TOKENS,
+    }), "decomp");
+  } catch (e) { const ee = /** @type {Error} */ (e); return { error: `Décomposition impossible (LLM) : ${ee.message}` }; }
+  try {
+    const parsed = /** @type {Record<string, unknown>[] | { tasks?: Record<string, unknown>[] }} */ (deps.parseJsonLoose(raw, { arrays: true, recover: true })); // tableau racine accepté ; JSON tronqué rattrapé
+    const kept = dropImpossible(parsed); // une tâche qui ne sert qu'un ajustement impossible est retirée par le code, même si le modèle l'a écrite
+    const tasks = normalizeTasks(/** @type {Record<string, unknown>[] | { tasks?: Record<string, unknown>[] }} */ (kept.parsed), repoFiles);
+    const cut = parsed && /** @type {Record<symbol, unknown>} */ (parsed)[TRUNCATED];
+    const notice = cut ? `⚠ Réponse du modèle coupée : ${tasks.length} tâche(s) complète(s) récupérée(s), la dernière (incomplète) est abandonnée. Relancez si la liste semble incomplète.\n` : "";
+    return { tasks, notice: feasibilityNotice(parsed, adjust) + notice };
+  } catch (e) { const ee = /** @type {Error} */ (e); return { error: `Décomposition invalide : ${ee.message}` }; }
+}
+// MODULE_COMPLETE

package/src/auto/diff.js

@@ -0,0 +1,19 @@
+// src/auto/diff.js — Parseur des chemins `b/...` d'un diff Unified (fichiers touchés).
+// Pur. Extrait les fichiers modifiés/créés depuis les en-têtes `+++ b/…`.
+
+// Retourne les chemins touchés par un diff (en-têtes +++ b/…). Pur, déterministe.
+/** @param {string} diff @returns {string[]} */
+export function touchedFilesFromDiff(diff) {
+  const set = new Set();
+  for (const line of String(diff || "").split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      const f = line.slice(6).trim();
+      if (f) set.add(f);
+    } else if (line.startsWith("+++ ") && !line.startsWith("+++ /dev/null")) {
+      const rest = line.slice(4).trim();
+      if (rest && rest !== "/dev/null" && !rest.startsWith("b/")) set.add(rest);
+    }
+  }
+  return [...set];
+}
+// MODULE_COMPLETE

package/src/auto/fs-list.js

@@ -0,0 +1,34 @@
+// src/auto/fs-list.js — Liste des fichiers source par lecture du disque (projet SANS git). Bornée (profondeur,
+// nombre de fichiers), sans lien symbolique, dossiers lourds et fichiers sensibles (.env, clés) exclus.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { MAX_LS_FILES, SRC_EXT } from "./constants.js";
+
+export const SKIP_DIRS = new Set(["node_modules", ".git", ".pipcode", "dist", "build", "out", "coverage", ".venv", "venv", "__pycache__", ".next", "target"]);
+const SECRET_FILE = /(^|\/)(\.env.*|.*\.(pem|key|p12|pfx)|id_(rsa|ed25519).*|.*(secret|credential|token)s?\.(json|ya?ml|toml))$/i;
+const MAX_DEPTH = 6;
+
+/** @param {string} rel @returns {boolean} */
+export const isSecretPath = (rel) => SECRET_FILE.test(rel.replace(/\\/g, "/"));
+
+/** @param {string} root @param {string} rel @param {number} depth @param {string[]} out @returns {Promise<void>} */
+async function walk(root, rel, depth, out) {
+  let entries;
+  try { entries = await fs.readdir(path.join(root, rel), { withFileTypes: true }); }
+  catch { return; } // dossier illisible : ignoré (liste partielle, jamais d'échec)
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (out.length >= MAX_LS_FILES) return;
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory() && depth < MAX_DEPTH && !SKIP_DIRS.has(e.name)) await walk(root, r, depth + 1, out);
+    else if (e.isFile() && SRC_EXT.test(e.name) && !isSecretPath(r)) out.push(r);
+  }
+}
+
+/** Fichiers source du dossier (chemins relatifs « / »), au plus MAX_LS_FILES. @param {string} projectPath @returns {Promise<string[]>} */
+export async function fsListSourceFiles(projectPath) {
+  /** @type {string[]} */ const out = [];
+  await walk(projectPath, "", 0, out);
+  return out;
+}
+// MODULE_COMPLETE

package/src/auto/git-base.js

@@ -0,0 +1,16 @@
+// src/auto/git-base.js — Point de retour : indexe les fichiers déjà suivis (modifiés ou supprimés) et les sources non sensibles, puis commite.
+// Jamais .env ni clés. Identité du commit en option (config git de l'utilisateur jamais modifiée).
+import { gitExec } from "./git.js";
+import { fsListSourceFiles } from "./fs-list.js";
+
+export const IDENT = ["-c", "user.name=PipCode", "-c", "user.email=pipcode@localhost", "-c", "commit.gpgsign=false"];
+const CHUNK = 100;
+
+/** @param {string} projectPath @param {string} message @returns {Promise<void>} */
+export async function commitBase(projectPath, message) {
+  await gitExec(projectPath, ["add", "-u"]);
+  const files = await fsListSourceFiles(projectPath);
+  for (let i = 0; i < files.length; i += CHUNK) await gitExec(projectPath, ["add", "--", ...files.slice(i, i + CHUNK)]);
+  await gitExec(projectPath, [...IDENT, "commit", "--allow-empty", "-m", message]);
+}
+// MODULE_COMPLETE

package/src/auto/git-init.js

@@ -0,0 +1,39 @@
+// src/auto/git-init.js — Projet sans dépôt git : initialisation + commit de base (état initial), pour que le Mode Auto
+// puisse appliquer et annuler ses modifications. Appelée APRÈS le consentement au devis. Seuls les fichiers source non
+// sensibles sont indexés (jamais .env, clés). Avec PLUGCTO_GIT_DIR, l'historique vit HORS du projet (jamais de .git créé chez lui) et
+// chaque exécution y ajoute un point de retour.
+
+import fs from "node:fs/promises";
+import { gitExec } from "./git.js";
+import { gitScope } from "./git-scope.js";
+import { commitBase } from "./git-base.js";
+
+export const NO_GIT_NOTICE = "ℹ️ Aucun dépôt Git dans ce dossier : au lancement (après votre accord), PipCode en initialisera un avec un commit de base de vos fichiers source (hors .env et clés).\n\n";
+const BASE_MSG = "chore(pipcode): état initial avant Mode Auto";
+const RUN_MSG = "chore(pipcode): état avant exécution";
+
+/** Dossier de travail isolé (PLUGCTO_OWN_REPO=1) : il lui faut SON PROPRE dépôt — jamais celui du projet qui le contient. @param {string} projectPath @returns {Promise<boolean>} */
+export async function isGitRepo(projectPath) {
+  try {
+    if (process.env.PLUGCTO_OWN_REPO !== "1" || gitScope(projectPath).length > 0) return (await gitExec(projectPath, ["rev-parse", "--is-inside-work-tree"])) === "true";
+    const [top, here] = await Promise.all([gitExec(projectPath, ["rev-parse", "--show-toplevel"]), fs.realpath(projectPath)]);
+    return (await fs.realpath(top)) === here;
+  } catch { return false; } // pas de dépôt (ou git absent) : traité par l'appelant
+}
+
+/** Initialise git + commit de base si absent ; renvoie true si initialisé. Historique hors du projet : un point de retour par exécution. @param {string} projectPath @returns {Promise<boolean>} */
+export async function ensureGitRepo(projectPath) {
+  const apart = gitScope(projectPath).length > 0;
+  try {
+    if (await isGitRepo(projectPath)) { if (apart) await commitBase(projectPath, RUN_MSG); return false; }
+    if (apart) await fs.mkdir(String(process.env.PLUGCTO_GIT_DIR), { recursive: true }); // git ne crée pas les dossiers parents de l'historique
+    await gitExec(projectPath, ["init"]);
+    if (apart) for (const [k, v] of [["user.name", "PipCode"], ["user.email", "pipcode@localhost"], ["commit.gpgsign", "false"], ["core.autocrlf", "false"]]) await gitExec(projectPath, ["config", k, v]); // réglages propres à ce dépôt (identité, fins de ligne conservées à l'octet près) : la config de l'utilisateur n'est jamais touchée
+    await commitBase(projectPath, BASE_MSG);
+    return true;
+  } catch (e) {
+    const err = /** @type {Error & { stderr?: string }} */ (e);
+    throw new Error(`Initialisation Git impossible dans ${projectPath} (git est-il installé ?) : ${(err.stderr || err.message || "").slice(0, 200)}`);
+  }
+}
+// MODULE_COMPLETE

package/src/auto/git-restore.js

@@ -0,0 +1,34 @@
+// src/auto/git-restore.js — Restitue les fichiers touchés à l'état HEAD (SAFE_SURGERY).
+// unstage + restore (checkout) pour les fichiers présents dans HEAD ; rm pour les
+// nouveaux fichiers non présents dans HEAD. Rollback propre après apply/commit échoué.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { gitExec } from "./git.js";
+
+// Fichier absent de HEAD : s'il existait avant le travail (html, texte, config… non suivis), son ORIGINAL sauvegardé est remis ; sinon il est nouveau → retiré.
+/** @param {string} projectPath @param {string} f @returns {Promise<void>} */
+async function dropOrRestoreOriginal(projectPath, f) {
+  const dir = process.env.PLUGCTO_BACKUP_DIR;
+  const saved = dir && path.isAbsolute(dir) ? path.resolve(dir, f) : "";
+  const dst = path.resolve(projectPath, f);
+  const sane = saved && !path.relative(dir ?? "", saved).startsWith("..") && !path.relative(projectPath, dst).startsWith("..");
+  if (sane && await fs.stat(saved).then((s) => s.isFile(), () => false)) await fs.copyFile(saved, dst);
+  else await fs.rm(dst, { force: true });
+}
+
+// Restitue les fichiers à l'état HEAD (unstage + restore/rm). Best-effort par fichier.
+/** @param {string} projectPath @param {string[]} files @returns {Promise<void>} */
+export async function gitRestore(projectPath, files) {
+  for (const f of files) {
+    let inHead = true;
+    try { await gitExec(projectPath, ["cat-file", "-e", `HEAD:${f}`]); } catch { inHead = false; }
+    try { await gitExec(projectPath, ["reset", "-q", "HEAD", "--", f]); } catch { /* best-effort par fichier */ }
+    if (inHead) {
+      try { await gitExec(projectPath, ["checkout", "--", f]); } catch { /* best-effort par fichier */ }
+    } else {
+      try { await dropOrRestoreOriginal(projectPath, f); } catch { /* best-effort par fichier */ }
+    }
+  }
+}
+// MODULE_COMPLETE

package/src/auto/git-scope.js

@@ -0,0 +1,10 @@
+// src/auto/git-scope.js — Dépôt d'historique HORS du projet : PLUGCTO_GIT_DIR (chemin absolu fourni par l'extension) fait pointer git sur ce dossier
+// avec le projet pour arbre de travail. Le .git du projet n'est jamais créé ni touché ; sans la variable, ou si elle n'est pas absolue : comportement normal.
+import path from "node:path";
+
+/** @param {string} projectPath @param {NodeJS.ProcessEnv} [env] @returns {string[]} options git à placer avant la commande ([] = dépôt du projet) */
+export function gitScope(projectPath, env = process.env) {
+  const dir = env.PLUGCTO_GIT_DIR;
+  return dir && path.isAbsolute(dir) ? [`--git-dir=${dir}`, `--work-tree=${projectPath}`] : [];
+}
+// MODULE_COMPLETE

package/src/auto/git.js

@@ -0,0 +1,38 @@
+// src/auto/git.js — Primitives git (execFile sans shell — anti-injection shell).
+// gitExec : promisifié, borné. assertGitRepo : garde Auto Mode (apply+commit).
+// gitListSourceFiles : liste des fichiers source du dépôt (cap MAX_LS_FILES).
+
+import { execFile } from "node:child_process";
+import { GIT_TIMEOUT_MS, MAX_LS_FILES, SRC_EXT } from "./constants.js";
+import { gitScope } from "./git-scope.js";
+
+// execFile git promisifié (stdout trimé). Rejette avec err.stderr rempli.
+/** @param {string} projectPath @param {string[]} args @param {number} [timeoutMs] @returns {Promise<string>} */
+export function gitExec(projectPath, args, timeoutMs = GIT_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    execFile("git", [...gitScope(projectPath), ...args], { cwd: projectPath, windowsHide: true, timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) { err.stderr = (stderr || "").toString().trim(); reject(err); }
+      else resolve((stdout || "").toString().trim());
+    });
+  });
+}
+
+// Vérifie que projectPath est un dépôt git (Auto Mode exige apply+commit).
+/** @param {string} projectPath @returns {Promise<void>} */
+export async function assertGitRepo(projectPath) {
+  let out;
+  try { out = await gitExec(projectPath, ["rev-parse", "--is-inside-work-tree"]); }
+  catch { throw new Error(`Le chemin n'est pas un dépôt git : ${projectPath}. L'Auto Mode (apply+commit) exige un dépôt git.`); }
+  if (out !== "true") throw new Error(`Le chemin n'est pas un dépôt git : ${projectPath}.`);
+}
+
+// Liste les fichiers source du dépôt (cap MAX_LS_FILES, exclut .pipcode/).
+/** @param {string} projectPath @returns {Promise<string[]>} */
+export async function gitListSourceFiles(projectPath) {
+  /** @type {string} */ let raw = "";
+  try { raw = await gitExec(projectPath, ["ls-files"]); } catch { return []; }
+  const all = raw.split("\n").map((s) => s.trim()).filter(Boolean);
+  const src = all.filter((f) => SRC_EXT.test(f) && !f.startsWith(".pipcode/"));
+  return src.slice(0, MAX_LS_FILES);
+}
+// MODULE_COMPLETE

package/src/auto/mission-docs.js

@@ -0,0 +1,29 @@
+// src/auto/mission-docs.js — Déclenchement du trio documentaire client en fin de
+// mission Auto (README + GUIDE_ARCHITECTURE_CODE + RUNBOOK, racine du projet).
+// Coexistence garantie par construction : chaque générateur n'écrit QUE son fichier.
+import { generateReadme } from "../engine/generate-readme.js";
+import { generateArchitectureGuide } from "../engine/generate-architecture-guide.js";
+import { generateRunbook } from "../engine/generate-runbook.js";
+
+// Mode de mission : au moins la moitié des fichiers nouveaux → création, sinon refactoring.
+/** @param {AutoTask[]} tasks @returns {DocMode} */
+export function detectDocMode(tasks) {
+  const created = tasks.filter((t) => t.isNew).length;
+  return created * 2 >= tasks.length ? "creation" : "refactoring";
+}
+
+// Génère/met à jour les 3 documents. Best-effort PAR document : l'échec de l'un
+// n'interrompt pas les autres et n'échoue JAMAIS la mission (stderr uniquement).
+/** @param {{ projectPath: string, state: AutoState, mission: MissionPlan | null }} arg @returns {Promise<void>} */
+export async function generateClientDocs({ projectPath, state, mission }) {
+  const mode = detectDocMode(state.tasks);
+  const generators = [generateReadme, generateArchitectureGuide, generateRunbook];
+  for (const gen of generators) {
+    try { await gen(projectPath, state, mission, mode); }
+    catch (e) {
+      const ee = /** @type {Error} */ (e);
+      console.error(`[pipcode auto] Documentation client (${gen.name}) : échec best-effort — ${ee.message}`);
+    }
+  }
+}
+// MODULE_COMPLETE

package/src/auto/mission-line.js

@@ -0,0 +1,22 @@
+// src/auto/mission-line.js — Reprise de mission après /clear : si un plan autonome est en cours (auto-state.json actif), UNE phrase courte pour le prompt
+// système (mission, tâche active, consigne). Lecture seule : ne modifie jamais l'état. Texte de mission nettoyé (une ligne, borné) avant injection.
+import fs from "node:fs/promises";
+import { loadAutoState } from "./state.js";
+import { missionPathOf } from "./paths.js";
+
+const ACTIVE = new Set(["running", "awaiting_user", "paused"]);
+
+/** @param {string} s @returns {string} */
+const oneLine = (s) => s.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/^[#>*\-\s]+/, "").trim().slice(0, 120);
+
+/** @param {string} projectPath @returns {Promise<string>} "" si aucun plan en cours */
+export async function missionLine(projectPath) {
+  const state = await loadAutoState(projectPath);
+  if (!state || !ACTIVE.has(state.status) || !Array.isArray(state.tasks) || !state.tasks.length) return "";
+  const idx = Math.min(Math.max(Number.isInteger(state.cursor) ? state.cursor : 0, 0), state.tasks.length - 1);
+  const task = state.tasks[idx];
+  const raw = await fs.readFile(missionPathOf(projectPath), "utf8").catch(() => "");
+  const title = oneLine(raw.split("\n").find((l) => l.trim()) || "") || "plan autonome";
+  return `Mission en cours : ${title}. Tâche active : ${idx + 1}/${state.tasks.length} — ${oneLine(String(task?.title || ""))}. Poursuis l'exécution sur le code présent dans le workspace.`;
+}
+// MODULE_COMPLETE

package/src/auto/node-check.js

@@ -0,0 +1,30 @@
+// src/auto/node-check.js — Validation syntaxique JS family via `node --check`.
+// Authentique (exécuté après git apply, avant commit). Rejette la syntaxe invalide.
+// Un .js écrit en ESM (import/export) sans package.json « type: module » passe `node --check` même cassé : on le revérifie en module.
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import { NODE_CHECK_TIMEOUT_MS } from "./constants.js";
+
+const ESM = /^\s*(?:import|export)\s/m;
+
+/** @param {string[]} args @param {string} [input] @returns {Promise<void>} */
+function run(args, input) {
+  return new Promise((resolve, reject) => {
+    const child = execFile("node", args, { windowsHide: true, timeout: NODE_CHECK_TIMEOUT_MS }, (err, _o, stderr) => {
+      if (err) reject(new Error((stderr || err.message || "syntaxe invalide").toString().trim()));
+      else resolve();
+    });
+    if (input !== undefined) child.stdin?.end(input);
+  });
+}
+
+// Vérifie la syntaxe d'un fichier JS/MJS/CJS via `node --check`. Reject si invalide.
+/** @param {string} file @returns {Promise<void>} */
+export async function nodeCheck(file) {
+  await run(["--check", file]);
+  if (!/\.js$/i.test(file)) return;
+  const source = await fs.readFile(file, "utf8");
+  if (ESM.test(source)) await run(["--input-type=module", "--check"], source);
+}
+// MODULE_COMPLETE

package/src/auto/observe.js

@@ -0,0 +1,23 @@
+// src/auto/observe.js — OBSERVER : mise en forme de ce que l'exécution a réellement produit (erreur d'application du patch, sortie de tsc / des tests) pour
+// la boucle auto-corrective. Sortie volumineuse → tête + queue (la cause est à la fin) ; secrets masqués (redactError) ; signature pour reconnaître
+// la MÊME panne d'un tour à l'autre (inutile de recommencer une correction qui ne change rien). Pur.
+import { redactError } from "./amnesia.js";
+
+export const OBSERVE_MAX_CHARS = 2000;
+
+/** @param {string} text @param {number} [max] @returns {string} */
+export function headTail(text, max = OBSERVE_MAX_CHARS) {
+  const s = redactError(String(text ?? "")).trim();
+  if (s.length <= max) return s;
+  const head = Math.floor(max * 0.35);
+  return `${s.slice(0, head)}\n[… ${s.length - max} caractères omis …]\n${s.slice(-(max - head))}`;
+}
+
+/** Fin du log nettoyée : deux tours qui échouent pareil ont la même signature. @param {string} text @returns {string} */
+export const failureSignature = (text) => redactError(String(text ?? "")).replace(/\s+/g, " ").trim().slice(-200);
+
+/** Bloc réinjecté dans le prompt du tour suivant (sans validation de l'utilisateur). @param {number} turn @param {string} observed @returns {string} */
+export function feedbackBlock(turn, observed) {
+  return `Le tour ${turn} a échoué à l'exécution (le patch a été annulé). Sortie réelle ci-dessous : corrige la cause, sans réintroduire le problème.\n${headTail(observed)}`;
+}
+// MODULE_COMPLETE

package/src/auto/orchestrator.js

@@ -0,0 +1,30 @@
+// src/auto/orchestrator.js — Factory createAutoOrchestrator(deps) (DI, anti-import circulaire).
+// Lie les méthodes (plan/step/run/resume) en passant deps explicitement (extraction closure).
+// Expose aussi les helpers purs (amnesia, state, budget) pour les tests directs.
+
+import { buildAutoPlan } from "./plan.js";
+import { runAutoStep } from "./step.js";
+import { runAutoRun, resumeAuto } from "./run.js";
+import { applyDiffSafe } from "./apply-diff.js";
+import { estimateRunBudget } from "./budget.js";
+import { buildAmnesiaContext, buildCorrectionSignal } from "./amnesia.js";
+import { loadAutoState, saveAutoState } from "./state.js";
+
+// Factory : retourne l'orchestrateur Auto avec deps lié à chaque méthode.
+/** @param {AutoDeps} deps @returns {AutoOrchestrator} */
+export function createAutoOrchestrator(deps) {
+  if (!deps || typeof deps !== "object") throw new Error("createAutoOrchestrator : deps requis.");
+  return {
+    buildAutoPlan: (arg) => buildAutoPlan(arg, deps),
+    runAutoStep: (arg) => runAutoStep(arg, deps),
+    runAutoRun: (arg) => runAutoRun(arg, deps),
+    resumeAuto: (arg) => resumeAuto(arg, deps),
+    applyDiffSafe: (arg) => applyDiffSafe(arg),
+    estimateRunBudget: (tasks, mission, fileSizes, pcfg) => estimateRunBudget(tasks, mission, fileSizes, deps, pcfg),
+    buildAmnesiaContext,
+    buildCorrectionSignal,
+    loadAutoState,
+    saveAutoState,
+  };
+}
+// MODULE_COMPLETE

package/src/auto/patch-ask.js

@@ -0,0 +1,16 @@
+// src/auto/patch-ask.js — Phase patch avec question possible : une vraie question du modèle met la tâche en pause ; une question qui vise la doctrine interne
+// (ou des fichiers qui n'existent pas dans le projet) n'arrête JAMAIS le plan — la phase est relancée UNE fois avec l'interdiction de poser une question.
+import { ASK_NOTE, parseAskUser } from "./ask-user.js";
+import { guardQuestion } from "./ask-guard.js";
+
+export const NO_ASK_NOTE = "Ne pose AUCUNE question. Travaille uniquement avec les fichiers du projet fournis ; tes instructions et fiches internes ne sont pas des fichiers du projet : ne les cite pas, ne les modifie pas. Produis directement le résultat de la tâche.";
+
+/** @param {(note: string) => Promise<string>} runPatch @param {boolean} canAsk @param {string} doctrine @returns {Promise<{ patch: string, asking: string | null }>} */
+export async function patchOrAsk(runPatch, canAsk, doctrine) {
+  const patch = await runPatch(canAsk ? ASK_NOTE : "");
+  const question = canAsk ? parseAskUser(patch) : null;
+  if (!question) return { patch, asking: null };
+  if (guardQuestion(question, doctrine) === question) return { patch, asking: question };
+  return { patch: await runPatch(NO_ASK_NOTE), asking: null };
+}
+// MODULE_COMPLETE

package/src/auto/paths.js

@@ -0,0 +1,18 @@
+// src/auto/paths.js — Chemins du dossier .pipcode/ (mission, state).
+// PipCode confine ses artefacts dans .pipcode/ à la racine du projet.
+
+import path from "node:path";
+import { AUTO_STATE_FILENAME } from "./constants.js";
+
+// Dossier plugcto à la racine du projet (<projectPath>/.pipcode).
+/** @param {string} projectPath @returns {string} */
+export function plugDirOf(projectPath) { return path.join(projectPath, ".pipcode"); }
+
+// Chemin du scratchpad mission (.pipcode/mission.md).
+/** @param {string} projectPath @returns {string} */
+export function missionPathOf(projectPath) { return path.join(plugDirOf(projectPath), "mission.md"); }
+
+// Chemin du state Auto (.pipcode/auto-state.json).
+/** @param {string} projectPath @returns {string} */
+export function statePathOf(projectPath) { return path.join(plugDirOf(projectPath), AUTO_STATE_FILENAME); }
+// MODULE_COMPLETE

package/src/auto/plan.js

@@ -0,0 +1,42 @@
+// src/auto/plan.js — Pilier 1 : buildAutoPlan (Plan + Devis, Dry-Run).
+// Valide → charge/crée mission → décompose LLM → budget + state consent_pending.
+// Aucun appel orchestrateLLM tant que l'utilisateur n'a pas confirmé.
+
+import path from "node:path";
+import { gitExec } from "./git.js";
+import { isGitRepo, NO_GIT_NOTICE } from "./git-init.js";
+import { gitScope } from "./git-scope.js";
+import { missionPathOf } from "./paths.js";
+import { sha256, sha8 } from "./crypto-util.js";
+import { collectFileSizes } from "./tasks.js";
+import { estimateRunBudget } from "./budget.js";
+import { formatQuote } from "./quote-format.js";
+import { saveAutoState } from "./state.js";
+import { decomposeAutoTasks } from "./decompose.js";
+import { anonymizeTasks } from "./anonymize-tasks.js";
+import { AUTO_STATE_VERSION } from "./constants.js";
+
+// Construit le plan Auto : mission, décomposition, devis, state consent_pending.
+/** @param {AutoPlanArgs} arg @param {AutoDeps} deps @returns {Promise<AutoResult>} */
+export async function buildAutoPlan({ need, projectPath, pcfg, cfg, instructions, adjust }, deps) {
+  need = String(need || "").trim(); projectPath = String(projectPath || "").trim();
+  if (!need) return { isError: true, text: "Paramètre `need` manquant pour le plan Auto." };
+  if (!projectPath) return { isError: true, text: "Paramètre `project_path` manquant pour le plan Auto." };
+  const noGit = gitScope(projectPath).length === 0 && !(await isGitRepo(projectPath)); // projet brut : accepté, git initialisé après consentement (run-loop)
+  const missionPath = missionPathOf(projectPath);
+  let mission = await deps.readMissionContext(missionPath);
+  if (!mission) { mission = await deps.extractMission(need, pcfg); mission.need = need; await deps.writeMission(mission, missionPath); }
+  const missionHash = sha256(JSON.stringify(mission));
+  const missionCtx = deps.missionContextPrefix(mission);
+  const decomp = await decomposeAutoTasks(need, projectPath, pcfg, cfg, deps, instructions ? `${missionCtx}\n\n${instructions}` : missionCtx, adjust); // instructions confidentielles : décomposition SEULE, jamais persistées.
+  if (decomp.error) return { isError: true, text: decomp.error };
+  const tasks = instructions ? anonymizeTasks(/** @type {AutoTask[]} */ (decomp.tasks)) : /** @type {AutoTask[]} */ (decomp.tasks); // plan d'audit : titres génériques
+  const fileSizes = await collectFileSizes(projectPath, tasks);
+  const budget = estimateRunBudget(tasks, mission, fileSizes, deps, pcfg);
+  const runId = sha8(need + projectPath);
+  const gitHead = await gitExec(projectPath, ["rev-parse", "HEAD"]).catch(() => "");
+  const state = { version: AUTO_STATE_VERSION, runId, projectPath: path.resolve(projectPath), missionHash, gitHead, tasks, cursor: 0, lastDiff: "", budget: { tokensEst: budget.tokensEst, tokensUsed: 0, costUsdEst: budget.costUsdEst, costUsdUsed: 0 }, status: "consent_pending", startedAt: new Date().toISOString(), updatedAt: new Date().toISOString() };
+  await saveAutoState(projectPath, /** @type {AutoState} */ (/** @type {unknown} */ (state)));
+  return { runId, tasks, budget, quote: (noGit ? NO_GIT_NOTICE : "") + (decomp.notice ?? "") + formatQuote(tasks, budget), consent: false, status: "consent_pending" };
+}
+// MODULE_COMPLETE