misterpropre 0.0.1

package/dist/chunk-HMGF6JWH.js

@@ -0,0 +1,884 @@
+// src/config/store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var LangSchema = z.enum(["fr", "en"]);
+var ProviderIdSchema = z.enum(["claude", "kiro", "q"]);
+var NotifyChannelSchema = z.enum(["none", "telegram", "slack"]);
+var ExecutionSchema = z.object({
+  maxParallel: z.number().int().min(1).max(16).default(3),
+  model: z.string().default("opus"),
+  // 'opus' = latest Opus, resolved per provider (see resolveModel)
+  effort: z.string().default(""),
+  timeouts: z.object({
+    fix: z.number().int().positive().default(3600),
+    purge: z.number().int().positive().default(7200)
+  }).default({}),
+  maxTurns: z.object({
+    fix: z.number().int().positive().default(120),
+    purge: z.number().int().positive().default(220)
+  }).default({})
+}).default({});
+var ProviderConfigSchema = z.object({
+  default: ProviderIdSchema.default("claude"),
+  scheduled: ProviderIdSchema.default("claude")
+}).default({});
+var NotificationsSchema = z.object({
+  channel: NotifyChannelSchema.default("none"),
+  scheduledDigest: z.boolean().default(true),
+  perRepoError: z.boolean().default(false)
+}).default({});
+var ScheduleSchema = z.object({
+  enabled: z.boolean().default(false),
+  time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "time must be HH:MM (24h)").default("10:00"),
+  phase: z.enum(["fix", "purge", "both"]).default("both"),
+  // Repos for the scheduled run; empty = every configured repo (`run --all`).
+  repos: z.array(z.string().min(1)).default([])
+}).default({});
+var ConfigSchema = z.object({
+  lang: LangSchema.default("en"),
+  org: z.string().min(1).default("mistertemp"),
+  repoBaseDir: z.string().min(1).default("~/Mistertemp/dev"),
+  packageScope: z.string().default("@mistertemp"),
+  baseBranch: z.string().min(1).default("dev"),
+  repos: z.array(z.string().min(1)).default([]),
+  provider: ProviderConfigSchema,
+  execution: ExecutionSchema,
+  notifications: NotificationsSchema,
+  schedule: ScheduleSchema
+});
+function defaultConfig() {
+  return ConfigSchema.parse({});
+}
+
+// src/config/store.ts
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+  return join(base, "misterpropre");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function isConfigured() {
+  return existsSync(configPath());
+}
+function readConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return null;
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  return ConfigSchema.parse(raw);
+}
+function writeConfig(config) {
+  const validated = ConfigSchema.parse(config);
+  mkdirSync(configDir(), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(validated, null, 2) + "\n", "utf8");
+}
+
+// src/skills/installer.ts
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/skills/templating.ts
+function renderTemplate(tmpl, vars) {
+  return tmpl.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    if (!(key in vars)) throw new Error(`renderTemplate: missing variable {{${key}}}`);
+    return vars[key];
+  });
+}
+
+// src/skills/installer.ts
+var MANAGED_MARKER = "managed-by: misterpropre";
+var FIX_INSTALL_NAME = "mrp-security-fix";
+var PURGE_INSTALL_NAME = "mrp-dependabot-purge";
+var BUNDLED_SKILLS = [
+  { sourceName: "security-dependabot-fix", installName: FIX_INSTALL_NAME },
+  { sourceName: "dependabot-purge", installName: PURGE_INSTALL_NAME }
+];
+function packageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dir;
+}
+function bundledSkillsRoot() {
+  return join2(packageRoot(), "skills");
+}
+function claudeSkillsRoot() {
+  return join2(homedir2(), ".claude", "skills");
+}
+function kiroSkillsRoot() {
+  return join2(homedir2(), ".kiro", "skills");
+}
+function skillsRootFor(provider) {
+  return provider === "kiro" ? kiroSkillsRoot() : claudeSkillsRoot();
+}
+function renderBundledSkill(installName, vars) {
+  const entry = BUNDLED_SKILLS.find((s) => s.installName === installName);
+  if (!entry) return null;
+  const tmpl = join2(bundledSkillsRoot(), entry.sourceName, "SKILL.md.tmpl");
+  if (!existsSync2(tmpl)) return null;
+  return renderTemplate(readFileSync2(tmpl, "utf8"), { ...vars, INSTALL_NAME: installName, MANAGED_MARKER });
+}
+function isManaged(skillMdPath) {
+  try {
+    return readFileSync2(skillMdPath, "utf8").includes(MANAGED_MARKER);
+  } catch {
+    return false;
+  }
+}
+function installTree(srcDir, destDir, vars) {
+  mkdirSync2(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const src = join2(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      installTree(src, join2(destDir, entry.name), vars);
+    } else if (entry.name.endsWith(".tmpl")) {
+      const rendered = renderTemplate(readFileSync2(src, "utf8"), vars);
+      writeFileSync2(join2(destDir, entry.name.slice(0, -".tmpl".length)), rendered, "utf8");
+    } else {
+      cpSync(src, join2(destDir, entry.name));
+    }
+  }
+}
+function installSkill(opts) {
+  const targetDir = join2(opts.targetRoot, opts.installName);
+  const targetSkillMd = join2(targetDir, "SKILL.md");
+  if (!existsSync2(join2(opts.sourceDir, "SKILL.md.tmpl"))) {
+    return { installName: opts.installName, path: "", action: "missing-source" };
+  }
+  const existed = existsSync2(targetSkillMd);
+  if (existed && !isManaged(targetSkillMd) && !opts.force) {
+    return { installName: opts.installName, path: targetDir, action: "skipped-unmanaged" };
+  }
+  installTree(opts.sourceDir, targetDir, { ...opts.vars, INSTALL_NAME: opts.installName, MANAGED_MARKER });
+  return { installName: opts.installName, path: targetDir, action: existed ? "updated" : "installed" };
+}
+function skillStatuses(targetRoot = claudeSkillsRoot()) {
+  return BUNDLED_SKILLS.map((s) => {
+    const bundled = existsSync2(join2(bundledSkillsRoot(), s.sourceName, "SKILL.md.tmpl"));
+    const installedMd = join2(targetRoot, s.installName, "SKILL.md");
+    const installed = existsSync2(installedMd);
+    return { installName: s.installName, bundled, installed, managed: installed && isManaged(installedMd) };
+  });
+}
+function installAllSkills(opts) {
+  const targetRoot = opts.targetRoot ?? claudeSkillsRoot();
+  return BUNDLED_SKILLS.map(
+    (s) => installSkill({
+      sourceDir: join2(bundledSkillsRoot(), s.sourceName),
+      installName: s.installName,
+      targetRoot,
+      vars: opts.vars,
+      force: opts.force
+    })
+  );
+}
+
+// src/core/login.ts
+import { execFileSync as execFileSync2, spawn } from "child_process";
+import { createInterface } from "readline";
+
+// src/lib/system.ts
+import { execFileSync } from "child_process";
+function commandVersion(cmd, args) {
+  try {
+    const out = execFileSync(cmd, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.split("\n")[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var REQUIRED_TOOLS = [
+  { label: "node", cmd: "node", args: ["--version"] },
+  { label: "npm", cmd: "npm", args: ["--version"] },
+  { label: "git", cmd: "git", args: ["--version"] },
+  { label: "gh", cmd: "gh", args: ["--version"] }
+];
+function checkSystem() {
+  return REQUIRED_TOOLS.map(({ label, cmd, args }) => {
+    const version = commandVersion(cmd, args);
+    return { label, ok: version !== null, detail: version ?? "not found" };
+  });
+}
+
+// src/core/login.ts
+var BIN = { claude: "claude", kiro: "kiro-cli", q: "q" };
+var LABEL = { claude: "Claude Code", kiro: "Kiro", q: "Amazon Q" };
+var INSTALL_CMD = {
+  claude: "curl -fsSL https://claude.ai/install.sh | bash",
+  kiro: "curl -fsSL https://cli.kiro.dev/install | bash"
+};
+async function linkProvider(provider, deps) {
+  const label = LABEL[provider];
+  if (!deps.isInstalled(provider)) {
+    deps.log(`${label} CLI is not installed.`);
+    if (!deps.canInstall(provider)) {
+      deps.log(`Install ${label} yourself (see its docs), then re-run \`mrp login ${provider}\`.`);
+      return { provider, installed: false, loggedIn: false, message: `${label} not installed` };
+    }
+    const yes = await deps.confirm(`Install ${label} now?`);
+    if (!yes) {
+      deps.log(`${label} is required to continue.`);
+      return { provider, installed: false, loggedIn: false, message: `${label} install declined` };
+    }
+    const ok = await deps.install(provider);
+    if (!ok) return { provider, installed: false, loggedIn: false, message: `${label} install failed` };
+  }
+  if (deps.isLoggedIn(provider)) {
+    deps.log(`\u2713 ${label} already logged in.`);
+    return { provider, installed: true, loggedIn: true, message: `${label} already linked` };
+  }
+  deps.log(`Opening ${label} login\u2026`);
+  await deps.login(provider);
+  const loggedIn = deps.isLoggedIn(provider);
+  deps.log(loggedIn ? `\u2713 ${label} linked.` : `\u2717 ${label} login did not complete.`);
+  return {
+    provider,
+    installed: true,
+    loggedIn,
+    message: loggedIn ? `${label} linked` : `${label} login failed`
+  };
+}
+function spawnInteractive(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: "inherit" });
+    child.on("error", () => resolve(-1));
+    child.on("close", (code) => resolve(code ?? -1));
+  });
+}
+function realLinkDeps(log = (m) => console.log(m)) {
+  const isInstalled = (provider) => commandVersion(BIN[provider], ["--version"]) !== null;
+  const isLoggedIn = (provider) => {
+    const args = provider === "claude" ? ["auth", "status"] : ["whoami"];
+    try {
+      execFileSync2(BIN[provider], args, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    log,
+    isInstalled,
+    isLoggedIn,
+    canInstall: (provider) => INSTALL_CMD[provider] !== void 0,
+    confirm: async (message) => {
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.resume();
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        const answer = await new Promise((res) => rl.question(`${message} [y/N] `, res));
+        return /^y(es)?$/i.test(answer.trim());
+      } finally {
+        rl.close();
+      }
+    },
+    install: async (provider) => {
+      const cmd = INSTALL_CMD[provider];
+      if (!cmd) {
+        log(`Install ${LABEL[provider]} first (see its docs), then re-run \`mrp login ${provider}\`.`);
+        return false;
+      }
+      log(`Installing ${LABEL[provider]}\u2026`);
+      await spawnInteractive("bash", ["-c", cmd]);
+      return isInstalled(provider);
+    },
+    login: async (provider) => {
+      const args = provider === "claude" ? ["auth", "login"] : ["login"];
+      await spawnInteractive(BIN[provider], args);
+    }
+  };
+}
+
+// src/core/github.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var pexec = promisify(execFile);
+var AUTOMATION_BRANCH_PREFIX = "fix/dependabot-security-";
+var isAutomationBranch = (ref) => ref.startsWith(AUTOMATION_BRANCH_PREFIX);
+function parseNdjson(s) {
+  const out = [];
+  for (const line of s.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+    }
+  }
+  return out;
+}
+function parseJsonArray(s) {
+  try {
+    const v = JSON.parse(s);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+var GhCli = class {
+  constructor(org, env = process.env) {
+    this.org = org;
+    this.env = env;
+  }
+  org;
+  env;
+  async gh(args) {
+    const { stdout } = await pexec("gh", args, {
+      env: this.env,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024
+    });
+    return stdout;
+  }
+  async listOpenAlerts(repo) {
+    const jq = ".[] | {number, severity: .security_advisory.severity, ghsaId: .security_advisory.ghsa_id, cveId: .security_advisory.cve_id, package: .dependency.package.name}";
+    const out = await this.gh([
+      "api",
+      `repos/${this.org}/${repo}/dependabot/alerts?state=open&per_page=100`,
+      "--paginate",
+      "--jq",
+      jq
+    ]);
+    return parseNdjson(out);
+  }
+  async listAutomationPRs(repo) {
+    const out = await this.gh([
+      "pr",
+      "list",
+      "--repo",
+      `${this.org}/${repo}`,
+      "--state",
+      "open",
+      "--json",
+      "number,url,headRefName,headRefOid,state"
+    ]);
+    return parseJsonArray(out).filter((p) => typeof p.headRefName === "string" && isAutomationBranch(p.headRefName)).map((p) => ({
+      number: p.number,
+      url: p.url,
+      headRefName: p.headRefName,
+      headSha: p.headRefOid,
+      state: p.state
+    }));
+  }
+  async listBotPRs(repo) {
+    const fields = "number,url,headRefName,state,title,labels";
+    const byAuthor = async (author) => {
+      const out2 = await this.gh([
+        "pr",
+        "list",
+        "--repo",
+        `${this.org}/${repo}`,
+        "--author",
+        author,
+        "--state",
+        "open",
+        "--json",
+        fields
+      ]);
+      return parseJsonArray(out2).map((p) => ({
+        number: p.number,
+        url: p.url,
+        headRefName: p.headRefName,
+        state: p.state,
+        title: p.title,
+        labels: (p.labels ?? []).map((l) => l.name)
+      }));
+    };
+    const [renovate, dependabot] = await Promise.all([byAuthor("app/renovate"), byAuthor("app/dependabot")]);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const p of [...renovate, ...dependabot]) {
+      if (seen.has(p.number)) continue;
+      seen.add(p.number);
+      out.push(p);
+    }
+    return out;
+  }
+  async pullState(repo, n) {
+    try {
+      const out = (await this.gh(["pr", "view", String(n), "--repo", `${this.org}/${repo}`, "--json", "state", "--jq", ".state"])).trim();
+      return out === "OPEN" || out === "MERGED" || out === "CLOSED" ? out : "UNKNOWN";
+    } catch {
+      return "UNKNOWN";
+    }
+  }
+};
+async function fetchOrgRepoNames(org, env = process.env) {
+  try {
+    const { stdout } = await pexec(
+      "gh",
+      ["repo", "list", org, "--json", "name", "--limit", "300", "--jq", ".[].name"],
+      { env, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 }
+    );
+    return stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/ui/theme.ts
+var theme = {
+  primary: "cyan",
+  accent: "magenta",
+  success: "green",
+  warn: "yellow",
+  error: "red",
+  dim: "gray",
+  text: "white"
+};
+var wordmarkGradient = ["#7aa2f7", "#bb9af7"];
+
+// src/core/history.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { z as z2 } from "zod";
+var RepoOutcomeSchema = z2.object({
+  repo: z2.string(),
+  phase: z2.enum(["fix", "purge"]),
+  kind: z2.string(),
+  prUrl: z2.string().optional(),
+  detail: z2.string().optional(),
+  hintAgreed: z2.boolean().optional(),
+  durationMs: z2.number().optional(),
+  // structured counts for own-runs stats
+  fixed: z2.number().int().nonnegative().optional(),
+  // vulns the fix PR addresses (skill RESULT hint)
+  merged: z2.number().int().nonnegative().optional(),
+  // bot PRs merged (authoritative)
+  handedOff: z2.number().int().nonnegative().optional(),
+  stillOpen: z2.number().int().nonnegative().optional()
+});
+var RunRecordSchema = z2.object({
+  id: z2.string(),
+  startedAt: z2.string(),
+  finishedAt: z2.string(),
+  trigger: z2.enum(["manual", "scheduled"]),
+  provider: z2.string(),
+  phases: z2.array(z2.enum(["fix", "purge"])),
+  repos: z2.array(RepoOutcomeSchema)
+});
+function runsPath() {
+  return join3(configDir(), "runs.jsonl");
+}
+function appendRun(record) {
+  const validated = RunRecordSchema.parse(record);
+  mkdirSync3(dirname2(runsPath()), { recursive: true });
+  appendFileSync(runsPath(), JSON.stringify(validated) + "\n", "utf8");
+}
+
+// src/core/stats.ts
+var EN_STATUS = {
+  prOpened: "security PR opened \u2014 awaiting review",
+  prUpToDate: "PR already up to date",
+  noAlerts: "no open alerts",
+  noFixable: "no auto-fixable alerts",
+  skippedBusy: "skipped \u2014 another run held it",
+  leftLocal: "fix left local",
+  failed: "failed",
+  error: "error",
+  merged: (m, h) => `merged ${m}, handed off ${h}`
+};
+function summarizeOutcome(o, t = EN_STATUS) {
+  const base = { repo: o.repo, phase: o.phase, kind: o.kind, prUrl: o.prUrl };
+  switch (o.kind) {
+    case "NEW_PR":
+    case "UPDATED_PR":
+      return { ...base, status: t.prOpened, ok: true };
+    case "PR_UP_TO_DATE":
+      return { ...base, status: t.prUpToDate, ok: true };
+    case "NO_ALERTS":
+      return { ...base, status: t.noAlerts, ok: true };
+    case "NO_FIXABLE":
+      return { ...base, status: t.noFixable, ok: true };
+    case "DONE":
+      return { ...base, status: t.merged(o.merged ?? 0, o.handedOff ?? 0), ok: true };
+    case "SKIPPED_BUSY":
+      return { ...base, status: t.skippedBusy, ok: true };
+    case "LEFT_LOCAL":
+      return { ...base, status: o.detail ? `${t.leftLocal} (${o.detail})` : t.leftLocal, ok: false };
+    case "ERROR":
+      return { ...base, status: o.detail ? `${t.error}: ${o.detail}` : t.error, ok: false };
+    case "FAIL":
+      return { ...base, status: o.detail ? `${t.failed}: ${o.detail}` : t.failed, ok: false };
+    default:
+      return { ...base, status: o.detail ?? o.kind.toLowerCase(), ok: true };
+  }
+}
+
+// src/ui/i18n.ts
+var en = {
+  orgPrompt: "Enter the GitHub organisation that owns the repositories you\u2019ll automate.",
+  baseDirPrompt: "Choose where your repositories are cloned locally.",
+  useCurrentDir: "Use the current directory",
+  enterPath: "Enter a different path\u2026",
+  pathPrompt: "Type the full path to the folder where your repositories are cloned.",
+  providerPrompt: "Which agent should run the automation?",
+  providerLoginNote: "You\u2019ll be signed in to the agent\u2019s CLI right after you choose.",
+  providerFound: "is installed.",
+  providerMissing: "CLI not found on PATH \u2014 install it before running.",
+  providerAuthPrompt: "Add a durable token for scheduled/unattended runs? Interactive runs use your existing login.",
+  skipLogin: "Skip \u2014 use my existing login",
+  addToken: "Add a token",
+  claudeTokenPrompt: "Paste your Claude Code OAuth token (hidden as you type).",
+  kiroTokenPrompt: "Paste your Kiro API key (hidden as you type).",
+  reposPrompt: "Select the repositories to automate.",
+  reposLoading: "Loading repositories\u2026",
+  reposEmpty: "No repositories found (check `gh auth status`). You can add them later in config.",
+  reposHint: "type to search \xB7 space to toggle \xB7 enter to confirm",
+  continueLabel: "Continue",
+  skillsInstalled: "Skills installed:",
+  done: "Setup complete. Run mrp doctor to verify, then a fix run.",
+  editTitle: "Configuration",
+  editHint: "Select a setting to change it \u2014 saved as you go.",
+  editDone: "Done",
+  labels: {
+    language: "Language",
+    org: "Org",
+    repoDir: "Repo dir",
+    provider: "Provider",
+    repos: "Repos",
+    saved: "\u2713 Saved"
+  }
+};
+var fr = {
+  orgPrompt: "Saisissez l\u2019organisation GitHub propri\xE9taire des repos \xE0 automatiser.",
+  baseDirPrompt: "Choisissez l\u2019emplacement o\xF9 vos repos sont clon\xE9s localement.",
+  useCurrentDir: "Utiliser le dossier actuel",
+  enterPath: "Saisir un autre chemin\u2026",
+  pathPrompt: "Saisissez le chemin complet du dossier o\xF9 vos repos sont clon\xE9s.",
+  providerPrompt: "Quel agent doit ex\xE9cuter l\u2019automatisation ?",
+  providerLoginNote: "Vous serez connect\xE9 \xE0 la CLI de l\u2019agent juste apr\xE8s votre choix.",
+  providerFound: "est install\xE9.",
+  providerMissing: "CLI introuvable dans le PATH \u2014 installez-le avant de lancer.",
+  providerAuthPrompt: "Ajouter un token durable pour les runs planifi\xE9s/non supervis\xE9s ? Les runs interactifs utilisent votre session.",
+  skipLogin: "Ignorer \u2014 utiliser ma session",
+  addToken: "Ajouter un token",
+  claudeTokenPrompt: "Collez votre token OAuth Claude Code (masqu\xE9 pendant la saisie).",
+  kiroTokenPrompt: "Collez votre cl\xE9 API Kiro (masqu\xE9e pendant la saisie).",
+  reposPrompt: "S\xE9lectionnez les repos \xE0 automatiser.",
+  reposLoading: "Chargement des repos\u2026",
+  reposEmpty: "Aucun repo trouv\xE9 (v\xE9rifiez `gh auth status`). Vous pourrez les ajouter plus tard.",
+  reposHint: "tapez pour filtrer \xB7 espace pour cocher \xB7 entr\xE9e pour valider",
+  continueLabel: "Continuer",
+  skillsInstalled: "Skills install\xE9s :",
+  done: "Configuration termin\xE9e. Lancez mrp doctor pour v\xE9rifier, puis un run.",
+  editTitle: "Configuration",
+  editHint: "S\xE9lectionnez une option \xE0 modifier (enregistr\xE9e automatiquement).",
+  editDone: "Valider",
+  labels: {
+    language: "Langue",
+    org: "Org",
+    repoDir: "Dossier",
+    provider: "Agent",
+    repos: "Repos",
+    saved: "\u2713 Enregistr\xE9"
+  }
+};
+var messages = { en, fr };
+function wizardT(lang) {
+  return messages[lang];
+}
+var enApp = {
+  tagline: "Security fixes + Renovate/Dependabot triage, on autopilot",
+  actions: "Actions",
+  actionRunSecurity: "Run security fix",
+  actionRunDependabot: "Run Dependabot purge",
+  actionRunBoth: "Run both (purge \u2192 fix)",
+  actionSchedule: "Schedule daily run",
+  actionScheduleEdit: "Configure daily run",
+  actionSetup: "Setup / reconfigure",
+  actionQuit: "Quit",
+  mode: "Mode",
+  modeAll: "All repos",
+  modeSingle: "Single repo",
+  modeSwitchHint: "Ctrl+Tab to switch mode (Single / Multiple repo)",
+  chooseRepo: "Choose a repo to run on",
+  noReposConfigured: "No repos configured \u2014 add some in the configuration.",
+  escBack: "Esc to go back",
+  runDone: "Run finished",
+  returnToMain: "Return to main screen",
+  handoffsHeader: (n) => `${n} PR(s) handed off \u2014 manual review needed:`,
+  schedule: {
+    title: "Schedule daily run",
+    reposPrompt: "Repos to include",
+    reposHint: "space to toggle \xB7 enter to confirm \xB7 none = all repos",
+    timePrompt: "Daily trigger time (HH:MM, 24h)",
+    timeLabel: "time",
+    timeInvalid: "Invalid time \u2014 use HH:MM (24h).",
+    modify: "Edit the schedule",
+    disable: "Disable daily run",
+    cancel: "Cancel",
+    noRepos: "No repos configured \u2014 add some in the configuration first.",
+    active: (time) => `Scheduled run active (${time})`,
+    setOk: (time, n) => `Daily run scheduled at ${time} \xB7 ${n} repo(s)`,
+    cleared: "Daily run disabled."
+  },
+  grid: {
+    queued: "queued",
+    purging: "Processing renovate/dependabot PRs",
+    fixing: "Fixing security issues",
+    done: "done",
+    failed: "failed",
+    skipped: "skipped"
+  },
+  status: EN_STATUS
+};
+var frStatus = {
+  prOpened: "PR de s\xE9curit\xE9 ouverte \u2014 en attente de revue",
+  prUpToDate: "PR d\xE9j\xE0 \xE0 jour",
+  noAlerts: "aucune alerte ouverte",
+  noFixable: "aucune alerte corrigeable automatiquement",
+  skippedBusy: "ignor\xE9 \u2014 une autre ex\xE9cution la traitait",
+  leftLocal: "correctif laiss\xE9 en local",
+  failed: "\xE9chec",
+  error: "erreur",
+  merged: (m, h) => `${m} merg\xE9e(s), ${h} \xE0 revoir`
+};
+var frApp = {
+  tagline: "Correctifs de s\xE9curit\xE9 et PR Renovate/Dependabot, automatis\xE9s",
+  actions: "Actions",
+  actionRunSecurity: "Traiter les alertes de s\xE9curit\xE9",
+  actionRunDependabot: "Traiter les PR renovate/dependabot",
+  actionRunBoth: "Lancer un traitement complet (s\xE9curit\xE9 + renovate/dependabot)",
+  actionSchedule: "Planifier un run quotidien",
+  actionScheduleEdit: "Configurer le run quotidien",
+  actionSetup: "Modifier la configuration",
+  actionQuit: "Quitter",
+  mode: "Mode",
+  modeAll: "Tous les repos",
+  modeSingle: "Repo unique",
+  modeSwitchHint: "Ctrl+Tab pour changer de mode (Seul / Multiple repo)",
+  chooseRepo: "Choisissez le repo \xE0 traiter",
+  noReposConfigured: "Aucun repo configur\xE9 \u2014 ajoutez-en dans la configuration.",
+  escBack: "\xC9chap pour revenir",
+  runDone: "Ex\xE9cution termin\xE9e",
+  returnToMain: "Revenir \xE0 l\u2019\xE9cran principal",
+  handoffsHeader: (n) => `${n} PR \xE0 revoir manuellement :`,
+  schedule: {
+    title: "Planifier un run quotidien",
+    reposPrompt: "Repos concern\xE9s",
+    reposHint: "espace pour cocher \xB7 entr\xE9e pour valider \xB7 aucun = tous les repos",
+    timePrompt: "Heure de d\xE9clenchement (HH:MM, 24 h)",
+    timeLabel: "heure",
+    timeInvalid: "Heure invalide \u2014 format HH:MM (24 h).",
+    modify: "Modifier la planification",
+    disable: "D\xE9sactiver le run quotidien",
+    cancel: "Annuler",
+    noRepos: "Aucun repo configur\xE9 \u2014 ajoutez-en d\u2019abord dans la configuration.",
+    active: (time) => `Run quotidien planifi\xE9 (${time})`,
+    setOk: (time, n) => `Run quotidien planifi\xE9 \xE0 ${time} \xB7 ${n} repo(s)`,
+    cleared: "Run quotidien d\xE9sactiv\xE9."
+  },
+  grid: {
+    queued: "en file",
+    purging: "Traitement des PR renovate/dependabot",
+    fixing: "R\xE9solution des probl\xE8mes de s\xE9curit\xE9",
+    done: "termin\xE9",
+    failed: "\xE9chec",
+    skipped: "ignor\xE9"
+  },
+  status: frStatus
+};
+var appMessages = { en: enApp, fr: frApp };
+function appT(lang) {
+  return appMessages[lang];
+}
+function phaseLabel(phase, lang) {
+  if (phase === "fix") return lang === "fr" ? "s\xE9curit\xE9" : "security";
+  if (phase === "purge") return "renovate/dependabot";
+  return phase;
+}
+
+// src/ui/components.tsx
+import { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import Gradient from "ink-gradient";
+import BigText from "ink-big-text";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Banner({ lang = "en" } = {}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Gradient, { colors: wordmarkGradient, children: /* @__PURE__ */ jsx(BigText, { text: "mister", font: "block", space: false }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: -4, children: /* @__PURE__ */ jsx(Gradient, { colors: wordmarkGradient, children: /* @__PURE__ */ jsx(BigText, { text: "propre", font: "block", space: false }) }) }),
+    /* @__PURE__ */ jsx(Text, { color: theme.dim, children: appT(lang).tagline })
+  ] });
+}
+function Panel({
+  title,
+  color = theme.primary,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box, { marginTop: -1, children: /* @__PURE__ */ jsx(Text, { backgroundColor: color, color: "black", bold: true, children: ` ${title} ` }) }),
+    children
+  ] });
+}
+function KeyVal({ label, value }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsxs(Text, { color: theme.success, bold: true, children: [
+      label,
+      ":"
+    ] }),
+    " ",
+    value
+  ] });
+}
+function Answered({ label, value }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.success, children: "\u2713" }),
+    " ",
+    /* @__PURE__ */ jsxs(Text, { color: theme.dim, children: [
+      label,
+      ":"
+    ] }),
+    " ",
+    value
+  ] });
+}
+var isPrintable = (s) => [...s].every((c) => c.charCodeAt(0) >= 32);
+function Select({
+  items,
+  onSelect,
+  onHighlight
+}) {
+  const [index, setIndex] = useState(0);
+  useEffect(() => {
+    onHighlight?.(items[0].value);
+  }, []);
+  useInput((_input, key) => {
+    if (key.return) {
+      onSelect(items[index].value);
+      return;
+    }
+    const delta = key.upArrow ? -1 : key.downArrow ? 1 : 0;
+    if (delta === 0) return;
+    const next = (index + delta + items.length) % items.length;
+    setIndex(next);
+    onHighlight?.(items[next].value);
+  });
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((it, i) => /* @__PURE__ */ jsxs(Text, { color: i === index ? theme.primary : theme.text, children: [
+    i === index ? "\u276F " : "  ",
+    it.label
+  ] }, it.value)) });
+}
+function MultiSelect({
+  items,
+  hint,
+  initial,
+  onConfirm
+}) {
+  const [query, setQuery] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const [selected, setSelected] = useState(new Set(initial ?? []));
+  const filtered = items.filter((it) => it.toLowerCase().includes(query.toLowerCase()));
+  const cur = Math.min(cursor, Math.max(0, filtered.length - 1));
+  const WINDOW = 8;
+  const start = Math.max(0, Math.min(cur - Math.floor(WINDOW / 2), Math.max(0, filtered.length - WINDOW)));
+  const view = filtered.slice(start, start + WINDOW);
+  useInput((input, key) => {
+    if (key.return) {
+      onConfirm([...selected]);
+    } else if (key.upArrow) {
+      setCursor(Math.max(0, cur - 1));
+    } else if (key.downArrow) {
+      setCursor(Math.min(filtered.length - 1, cur + 1));
+    } else if (input === " ") {
+      const it = filtered[cur];
+      if (it) {
+        const next = new Set(selected);
+        if (next.has(it)) next.delete(it);
+        else next.add(it);
+        setSelected(next);
+      }
+    } else if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setCursor(0);
+    } else if (input && input !== " " && !key.ctrl && !key.meta && isPrintable(input)) {
+      setQuery((q) => q + input);
+      setCursor(0);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.dim, children: "search: " }),
+      /* @__PURE__ */ jsx(Text, { children: query || " " })
+    ] }),
+    view.map((it, i) => {
+      const isCur = start + i === cur;
+      return /* @__PURE__ */ jsxs(Text, { color: isCur ? theme.primary : theme.text, children: [
+        isCur ? "\u276F " : "  ",
+        selected.has(it) ? "\u25C9" : "\u25EF",
+        " ",
+        it
+      ] }, it);
+    }),
+    /* @__PURE__ */ jsxs(Text, { color: theme.dim, children: [
+      filtered.length,
+      " match",
+      filtered.length === 1 ? "" : "es",
+      " \xB7 ",
+      selected.size,
+      " selected",
+      hint ? ` \xB7 ${hint}` : ""
+    ] })
+  ] });
+}
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ color = theme.primary }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+    return () => clearInterval(id);
+  }, []);
+  return /* @__PURE__ */ jsx(Text, { color, children: SPINNER_FRAMES[frame] });
+}
+function Chips({ items, color = theme.primary }) {
+  return /* @__PURE__ */ jsx(Box, { flexWrap: "wrap", marginTop: 1, children: items.map((it) => /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsx(Text, { backgroundColor: color, color: "black", children: ` ${it} ` }) }, it)) });
+}
+
+export {
+  checkSystem,
+  defaultConfig,
+  configDir,
+  configPath,
+  isConfigured,
+  readConfig,
+  writeConfig,
+  FIX_INSTALL_NAME,
+  PURGE_INSTALL_NAME,
+  skillsRootFor,
+  renderBundledSkill,
+  skillStatuses,
+  installAllSkills,
+  GhCli,
+  fetchOrgRepoNames,
+  theme,
+  appendRun,
+  summarizeOutcome,
+  wizardT,
+  appT,
+  phaseLabel,
+  Banner,
+  Panel,
+  KeyVal,
+  Answered,
+  Select,
+  MultiSelect,
+  Spinner,
+  Chips,
+  linkProvider,
+  realLinkDeps
+};
+//# sourceMappingURL=chunk-HMGF6JWH.js.map