pipcode 0.0.0-stage → 2.1.1

package/src/types/cli-auto.d.ts

@@ -0,0 +1,42 @@
+// src/types/cli-auto.d.ts — Types du shell CLI Mode Auto (résultats + orchestrateur).
+// Ambient global (aucun import/export) : utilisables via JSDoc sans import.
+// Types du gate (NodeErr/AutoFlags/GateAutoDeps/GateAutoResult) : cli-auto-gate.d.ts.
+
+/** Résultat lâche d'une opération du cœur Auto (branches isError/done/needsConsent). */
+interface AutoOpResult {
+  isError?: boolean;
+  text?: string;
+  runId?: string;
+  tasks?: AutoTask[];
+  quote?: string;
+  status?: string;
+  consent?: boolean;
+  needsConsent?: boolean;
+  done?: boolean;
+  failed?: boolean;
+  progress?: string;
+  summary?: string;
+  steps?: unknown[];
+  last?: { failed?: boolean; task?: AutoTask; error?: string; asking?: boolean; question?: string; cancelled?: boolean };
+  /** Pause « ASK_USER » : question à poser à l'utilisateur (code de sortie 3). */
+  asking?: boolean;
+  question?: string;
+  /** Arrêt demandé par l'utilisateur : plan en pause (code de sortie 4). */
+  cancelled?: boolean;
+}
+
+/** Orchestrateur Auto consommé par le shell CLI (subset de createAutoOrchestrator). */
+interface AutoShell {
+  buildAutoPlan: (args: { need: string; projectPath: string; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig; instructions?: string; adjust?: string }) => Promise<AutoOpResult>;
+  runAutoRun: (args: { projectPath: string; confirmed?: boolean; maxSteps?: number; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig }) => Promise<AutoOpResult>;
+  resumeAuto: (args: { projectPath: string; maxSteps?: number; answer?: string; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig }) => Promise<AutoOpResult>;
+  loadAutoState: (projectPath: string) => Promise<AutoState | null>;
+}
+
+/** Args du gate Auto (cfg/pcfg/tier) passés aux handlers plan/run/resume. */
+interface AutoGateOk {
+  cfg: PlugConfig;
+  pcfg: { primary: ProviderPrimary };
+  tier: string;
+}
+// MODULE_COMPLETE

package/src/types/config.d.ts

@@ -0,0 +1,53 @@
+// src/types/config.d.ts — Contrats config client + provider + licence.
+// Fichier ambient global (aucun import/export racine) : les interfaces sont
+// disponibles partout pour les annotations JSDoc (checkJs strict, zéro any).
+
+type ProviderName = "openai" | "anthropic" | "gemini" | "zhipu";
+
+interface PlugConfig {
+  installedAt: string;
+  clientId: string;
+  licenseKey: string;
+  email: string;
+  trialExpiredNotified?: boolean;
+}
+
+interface LicenseSessionPayload { cid: string; tier: string; iat: number; exp: number; fp?: string; }
+interface LicenseSession { token: string; tier: string; expSec: number; }
+
+interface ProviderPrimary {
+  provider: ProviderName;
+  key: string;
+  base: string;
+  model: string;
+  smartModel: string;
+  fastModel: string;
+}
+
+interface CallLLMArgs {
+  provider: ProviderName; key: string; model: string; base: string;
+  systemPrompt: string; userText: string; cachePrefix?: string; maxTokens?: number; showThinking?: boolean;
+  /** Remet chaque morceau de la réponse pendant la génération (affichage jeton par jeton). */
+  onDelta?: (text: string) => void;
+}
+
+interface ProviderAdapter {
+  callLLM(args: CallLLMArgs): Promise<string>;
+  readProviderConfig(env?: Record<string, string | undefined>): { primary: ProviderPrimary | null };
+}
+
+/** Erreur enrichie (status HTTP, code errno, provider, payload, analysis Phase 2). */
+interface EnrichedError extends Error {
+  status?: number;
+  code?: string;
+  provider?: string;
+  payload?: unknown;
+  analysis?: string;
+  rateLimitExhausted?: boolean;
+}
+/** État de l'essai tel que tranché par le serveur (affichage seulement). */
+type TrialStatus =
+  | { state: "active"; endsAt?: string }
+  | { state: "expired"; upgrade?: string }
+  | { state: "error"; message: string };
+// MODULE_COMPLETE

package/src/types/control.d.ts

@@ -0,0 +1,56 @@
+// src/types/control.d.ts — Contrats Phase 3 duo (contrôle/doute). Ambient global
+// (aucun import/export) : fusion de déclaration sur OrchestratorResult — les
+// champs duo/duo_same_provider/control S'AJOUTENT au retour existant ; aucun
+// champ historique (analysis, patch, models, route) n'est modifié ni supprimé.
+
+/** Verdict strict issu de la sortie LLM du contrôle (validation Zero Trust). */
+interface ControlVerdict {
+  status: "ok" | "corrected" | "rejected";
+  reason: string;
+  patch: string | null;
+}
+
+/** Sortie du passage de contrôle : draft conservé en cas d'échec ou de rejet. */
+interface ControlPhaseOutcome {
+  status: "ok" | "corrected" | "rejected" | "failed" | "skipped";
+  reason: string;
+  model: string;
+  patch: string;
+  checkpoints?: string[];
+}
+
+/** Autobilan du Modèle 1 : doutes déclarés (« doubts »), aucun (« none »), ou indisponible. */
+interface SelfAssessment { state: "none" | "doubts" | "unavailable"; text: string }
+
+/** Fichier d'un patch (Unified Diff) : chemin, texte, lignes ajoutées, nombre de lignes touchées. */
+interface DiffSection { path: string; text: string; added: string[]; changed: number }
+
+/** Point clé détecté : fichier à faire relire par le superviseur + raisons. */
+interface Checkpoint { path: string; reasons: string[] }
+
+/** Métadonnées duo remontées dans OrchestratorResult (comptabilité honnête). */
+interface ControlReport {
+  status: "ok" | "corrected" | "rejected" | "failed" | "skipped" | "not_configured";
+  reason: string;
+  model: string | null;
+  checkpoints?: string[];
+  selfAssessment?: SelfAssessment["state"];
+}
+
+/** Décision + résultat du duo pour l'orchestrateur. */
+interface DuoOutcome {
+  duo: boolean;
+  duoSameProvider: boolean;
+  control: ControlReport;
+  patch: string;
+}
+
+// Fusion : champs Phase 3 ajoutés au retour d'orchestrateLLM.
+interface OrchestratorResult {
+  duo?: boolean;
+  duo_same_provider?: boolean;
+  control?: ControlReport;
+  /** Pause « ASK_USER » : le modèle d'écriture pose une question au lieu de produire un patch. */
+  asking?: string;
+}
+// MODULE_COMPLETE

package/src/types/docs.d.ts

@@ -0,0 +1,6 @@
+// src/types/docs.d.ts — Types ambients du trio documentaire client (fin de mission Auto).
+// Aucun import/export top-level : déclarations ambient globales.
+
+/** Mode de mission dérivé des tâches (majorité de fichiers nouveaux → création). */
+type DocMode = "creation" | "refactoring";
+// MODULE_COMPLETE

package/src/types/doctrine.d.ts

@@ -0,0 +1,22 @@
+// src/types/doctrine.d.ts — Types globaux pour la doctrine fetchée & signée (thin client).
+// Payload signé renvoyé par le Worker (fiche individuelle) + contenu déroulé après vérif Ed25519.
+
+interface SignedSkillPayload {
+  data: string;
+  sig: string;
+}
+
+interface SkillPayloadContent {
+  slug?: string;
+  tier?: string;
+  serverTime?: string;
+  nonce?: string;
+  content: string;
+}
+
+/** Entrée de cache RAM de doctrine (TTL 5 h, cache-ttl.js) — jamais sur disque. */
+interface DoctrineCache {
+  content: string;
+  cachedAt: number;
+}
+// MODULE_COMPLETE

package/src/types/llm.d.ts

@@ -0,0 +1,28 @@
+// src/types/llm.d.ts — Types globaux pour le client LLM BYOK (réponses providers + warmup cache).
+// Ambient global (aucun import/export) — référencé via JSDoc sans import.
+
+interface LLMErrorResponse {
+  error?: { message?: string };
+  message?: string;
+}
+
+interface LLMResponse {
+  choices?: { message?: { content?: string } }[];
+  content?: { type: string; text: string }[];
+  candidates?: { content?: { parts?: { text?: string; thought?: boolean }[] } }[];
+}
+
+interface WarmupPrimedEntry {
+  provider: string;
+  model: string;
+  target: string;
+  ok: boolean;
+  error?: string;
+}
+
+interface WarmupResult {
+  warmed: boolean;
+  reason: string;
+  primed: WarmupPrimedEntry[];
+}
+// MODULE_COMPLETE

package/src/types/mcp.d.ts

@@ -0,0 +1,32 @@
+// src/types/mcp.d.ts — Contrats du serveur MCP (requêtes/réponses outils).
+
+// Schéma d'entrée JSON d'un outil MCP (subset strict exposé par le manifest).
+interface McpInputSchema {
+  type: "object";
+  properties?: Record<string, unknown>;
+  required?: string[];
+  additionalProperties?: boolean;
+}
+
+// Définition d'un outil exposé par tools/list.
+interface McpToolDef {
+  name: string;
+  description?: string;
+  inputSchema: McpInputSchema;
+}
+
+// Requête tools/call (structure minimale consommée par le dispatch).
+// params non-optionnel avec name requis : reflète le typage zod du SDK
+// (CallToolRequestSchema) et permet la déstructuration `request.params ?? {}`.
+interface McpToolRequest {
+  params: { name: string; arguments?: Record<string, unknown> | undefined };
+}
+
+// Bloc texte d'une réponse MCP. Type alias (et non interface) : les résultats
+// zod du SDK sont « loose » (signature d'index) et seuls les aliases d'objets
+// littéraux portent la signature d'index implicite nécessaire à l'assignation.
+type McpTextContent = { type: "text"; text: string };
+
+// Réponse tools/call (type alias pour la même raison).
+type McpToolResponse = { isError?: boolean; content: McpTextContent[] };
+// MODULE_COMPLETE

package/src/types/memory.d.ts

@@ -0,0 +1,17 @@
+// src/types/memory.d.ts — Contrats de la mémoire persistante (client local).
+// Fichier ambient global : interfaces disponibles pour les annotations JSDoc.
+
+/** Entrée de mémoire long terme. `source` = "user" | "mission" | "session" (jamais un slug produit). */
+interface MemoryEntry {
+  kind: string;
+  text: string;
+  source: string;
+  createdAt: string;
+}
+
+/** Contenu du fichier memory.json (0600, écriture atomique). */
+interface MemoryFile {
+  version: number;
+  entries: MemoryEntry[];
+}
+// MODULE_COMPLETE

package/src/types/mission.d.ts

@@ -0,0 +1,46 @@
+// src/types/mission.d.ts — Contrats Phase 0 (scratchpad mission + orchestration).
+// Fichier ambient global : partagés entre index.js et auto.js (résout la
+// contravariance des signatures AutoDeps — même type strict des deux côtés).
+
+interface DesignViolation { rule: string; patterns: string[]; }
+interface DomainConstraint { text: string; invariant: string; patterns: string[]; }
+interface DomainPitfall { never: string; always: string; patterns: string[]; }
+interface GlossaryEntry { term: string; definition: string; }
+
+interface BusinessDomain {
+  label: string; keywords: string[]; roles: string[]; regles: string[];
+  contraintes: string[]; failles: string[]; fiches: string[];
+}
+
+interface UxDesignEntry {
+  family: string; style: string; density: string; palette: string;
+  microInteractions: string; uxRules: string[]; designViolations: DesignViolation[];
+}
+
+// Charte visuelle contextualisée attachée à un MissionPlan (section 6 du scratchpad).
+interface DesignSystem {
+  family: string; style: string; density: string; palette: string;
+  microInteractions: string; wcag: string; violations: DesignViolation[];
+}
+
+interface Violation {
+  kind: "ast" | "pitfall" | "constraint" | "design";
+  rule: string; alternative: string; matched: string;
+}
+
+interface OrchestratorResult {
+  analysis: string; patch: string;
+  models: { analysis: string; patch: string };
+}
+
+interface MissionPlan {
+  projectName: string; need: string; domainKeys?: string[];
+  personas: { role_name: string; scope: string; mandate: string }[];
+  constraints: DomainConstraint[]; pitfalls: DomainPitfall[]; glossary: GlossaryEntry[];
+  impact: { files: string[]; steps: string[]; tokens: number; risk: string };
+  fiches?: string[]; uxDirectives: string[];
+  designSystem: { family: string; style: string; density: string; palette: string; microInteractions: string; wcag: string; violations: DesignViolation[] };
+  autoMode: boolean; createdAt?: string; validatedAt?: string | null; iterations?: number;
+  checkedSteps: boolean[]; patternsLoaded?: boolean; raw?: string;
+}
+// MODULE_COMPLETE

package/src/types/orchestrator.d.ts

@@ -0,0 +1,33 @@
+// src/types/orchestrator.d.ts — Contrats orchestration Mode Auto.
+// Fichier ambient global : interfaces disponibles pour index.js, auto.js et
+// bin/setup.js (checkJs strict, zéro any).
+
+interface OrchestratorArgs {
+  code: string; file_path?: string; language?: string; domain?: string;
+  missionContext?: string; doctrine?: string; lastDiff?: string; correction?: string; canAsk?: boolean;
+}
+
+interface AmnesiaContext { doctrine: string; lastDiff: string; missionContext: string; }
+
+interface AutoTask {
+  id: string; title: string; file: string; objective: string; acceptance: string;
+  status: "pending" | "done" | "failed"; attempts: number;
+  commit: string | null; error: string | null; isNew: boolean;
+}
+
+interface AutoBudget { tokensEst: number; tokensUsed: number; costUsdEst: number; costUsdUsed: number; }
+
+interface AutoState {
+  version: string; runId: string; projectPath: string; missionHash: string; gitHead: string;
+  tasks: AutoTask[]; cursor: number; lastDiff: string; budget: AutoBudget;
+  status: "consent_pending" | "running" | "done" | "failed" | "awaiting_user" | "paused";
+  startedAt: string; updatedAt: string;
+  /** Pause « ASK_USER » : question en attente, tâche concernée, réponses reçues, nombre de questions posées. */
+  question?: string; pendingTask?: string; answers?: { taskId: string; q: string; a: string }[]; questionsAsked?: number;
+}
+
+interface OrchestratorContext {
+  args: OrchestratorArgs; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig;
+  projectPath: string; state?: AutoState; fileSizes?: Record<string, number>;
+}
+// MODULE_COMPLETE

package/src/types/routing.d.ts

@@ -0,0 +1,25 @@
+// src/types/routing.d.ts — Types du routage hybride (délégation locale/cloud)
+// et de la capture de l'agent hôte. Ambient global (aucun import/export). Les
+// champs route s'ajoutent à OrchestratorResult par fusion de déclarations.
+
+/** Décision de routage d'une phase d'orchestration. */
+interface RouteDecision { route: "local" | "cloud" | "primary" | "none"; reason: string; }
+
+/** Args de decideRoute (routage hybride local-first, conditions a/b/c). */
+interface RouteArgs {
+  local: ProviderPrimary | null;
+  secondary: ProviderPrimary | null;
+  promptTokens: number;
+  capacityTokens: number;
+  localMultiAgent?: boolean;
+  heavyTokens: number;
+}
+
+/** Agent hôte MCP capturé à l'initialize (clientInfo). */
+interface ClientInfo { name: string; version: string; }
+
+// Fusion (declaration merging) : trace de routage ajoutée au résultat existant.
+interface OrchestratorResult {
+  route?: { analysis: RouteDecision["route"]; patch: RouteDecision["route"]; reason: string };
+}
+// MODULE_COMPLETE

package/src/types/rules.d.ts

@@ -0,0 +1,30 @@
+// src/types/rules.d.ts — Types des règles métier servies par le serveur PipCode (registre mémoire src/rules).
+
+/** Règles métier servies par le serveur (jamais embarquées dans le paquet) — registre mémoire src/rules. */
+interface EngineRules {
+  domains: Record<string, BusinessDomain>;
+  patterns: Record<string, { constraints?: DomainConstraint[]; pitfalls?: DomainPitfall[] }>;
+  glossary: Record<string, GlossaryEntry[]>;
+  ux: { design: Record<string, UxDesignEntry>; universal: string[] };
+  prompts: { analysis: string; mission: string; patch: string; master: string; decomp: string; control: string };
+  plan: { steps: string[]; impact: { base: number; perDomain: number; perRole: number; perRule: number; perFiche: number; filesPerDomain: number; filesBase: number } };
+  pricing: PricingGrid | null; // grille tarifaire servie par le serveur (null si absente)
+  prefix: Record<string, string> | null; // gabarits du préfixe de mission (lot Pro ; null pour un compte gratuit)
+  scan: ScanRules | null; // lot Pro : règles du scan de patch (null pour un compte gratuit).
+}
+
+/** Texte de règle : gabarit à variables {name}, éventuellement par langage. */
+type RuleMsg = string | { js: string; py: string };
+interface ScanMsg { rule: RuleMsg; alt: RuleMsg; }
+/** Règles du scan de patch servies par le serveur (appliquées localement, jamais embarquées). */
+interface ScanRules {
+  ast: {
+    callees: { js: { dangerous: string[]; shell: string[]; xssWrites: string[]; xssCalls: string[]; stringEval: string[] }; py: { dangerous: string[] } };
+    xssWriteAll: string[]; secretNames: string; minString: number; jsxSinks: string[];
+    msgs: { dangerous: ScanMsg; shell: ScanMsg; stringEval: ScanMsg; xssCall: ScanMsg; xssWrite: ScanMsg; secret: ScanMsg; jsx: ScanMsg };
+  };
+  graph: { cycle: ScanMsg; orphan: ScanMsg };
+  cheat: { testFile: string; tauto: string; assert: string; emptyCatch: string; skip: string; commented: string; commentedMin: number; callAssign: string; stub: string; rules: { rule: string; alt: string }[] };
+  design: { shellInUi: { rule: string; patterns: string[] }[]; shellAlt: string; charterAlt: string };
+}
+// MODULE_COMPLETE

package/src/types/snapshots.d.ts

@@ -0,0 +1,25 @@
+// src/types/snapshots.d.ts — Types du garde-fou snapshots & rollback intellectuel
+// (Mode Auto). Ambient global (aucun import/export). Les champs stop/failureStreak
+// s'ajoutent aux interfaces existantes par fusion de déclarations.
+
+/** Repère de snapshot capturé sous .pipcode/cache/snapshots/ (diff/patch léger). */
+interface SnapshotMarker {
+  kind: string;
+  head: string;
+  patch: string;
+  untracked: string[];
+  takenAt: string;
+}
+
+/** État des gates du projet client (green/red/skipped chacun, best-effort). */
+interface GreenReport {
+  tsc: "green" | "red" | "skipped";
+  tests: "green" | "red" | "skipped";
+  /** Sortie (stdout + stderr) des gates rouges : ce que la boucle auto-corrective relit. */
+  log?: string;
+}
+
+// Fusion (declaration merging) : champs garde-fou ajoutés aux types existants.
+interface AutoResult { stop?: string; }
+interface AutoState { failureStreak?: number; }
+// MODULE_COMPLETE

package/src/types/teardown.d.ts

@@ -0,0 +1,13 @@
+// src/types/teardown.d.ts — Types ambients du domaine Teardown (Phase 6).
+// Désinstallation propre de PipCode : retrait de l'entrée MCP `pipcode` des
+// configs IDE + suppression de la config partagée ~/.pipcode/config.json.
+// Aucun import/export top-level : déclarations ambient globales.
+
+type TeardownStatus = "removed" | "file-removed" | "absent" | "kept-foreign" | "error";
+interface TeardownFlags { yes: boolean; dryRun: boolean; keepConfig: boolean; configOnly: boolean; ideOnly: boolean; help: boolean; }
+interface TeardownAction { kind: "ide-entry" | "config"; path: string; label: string; schema?: "mcpServers" | "servers" | "context_servers" | "toml"; }
+interface RemoveResult { status: TeardownStatus; error?: string; }
+interface TeardownResult extends RemoveResult { path: string; label: string; }
+interface TeardownSummary { removed: number; absent: number; errors: number; dryRun: boolean; }
+interface TeardownCtx { argv?: string[]; osName?: "macos" | "windows" | "linux"; env?: Record<string, string | undefined>; home?: string; }
+// MODULE_COMPLETE

package/src/types/usage.d.ts

@@ -0,0 +1,30 @@
+// src/types/usage.d.ts — Types de l'usage RÉEL rapporté par les API (tokens, coût) et du relevé émis à l'extension.
+
+/** Partie « usage » d'une réponse fournisseur (tous champs possibles, tous optionnels, non fiables). */
+interface ProviderUsageBody {
+  usage?: {
+    prompt_tokens?: unknown; completion_tokens?: unknown; prompt_tokens_details?: { cached_tokens?: unknown }; cost?: unknown;
+    input_tokens?: unknown; output_tokens?: unknown; cache_read_input_tokens?: unknown; cache_creation_input_tokens?: unknown;
+  };
+  usageMetadata?: { promptTokenCount?: unknown; candidatesTokenCount?: unknown; cachedContentTokenCount?: unknown };
+}
+
+/** Usage d'UN appel : tokens d'entrée (cache inclus), de sortie, part servie par le cache, coût rapporté par l'API. */
+interface UsageSample { input: number; output: number; cached: number; cacheWrite: number; cost: number | null; }
+
+/** Grille tarifaire d'un modèle (USD par million de tokens), servie par le serveur. */
+interface PriceEntry { in: number; out: number; cachedIn?: number; cacheWriteIn?: number; note?: string; }
+interface PricingGrid { asOf: string; currency: string; models: Record<string, PriceEntry>; }
+
+/** Cumul par modèle dans le processus moteur. */
+interface UsageEntry {
+  provider: string; model: string; local: boolean; calls: number;
+  input: number; output: number; cached: number; cacheWrite: number; apiCost: number; apiCostCalls: number;
+}
+
+/** Ligne du relevé émis (PLUGCTO_USAGE) : coût et sa SOURCE ("api" | "local" | "grille" | null = inconnu). */
+interface UsageReportEntry {
+  provider: string; model: string; calls: number; input: number; output: number; cached: number;
+  cost: number | null; costSource: "api" | "local" | "grille" | null; grid: { in: number; out: number; cachedIn: number | null; asOf: string; note: string | null } | null;
+}
+// MODULE_COMPLETE