agent-kitchen 0.2.0 → 0.3.1

package/dist/menu.js

@@ -1,9 +1,21 @@
 /**
- * @file The checkbox menu of the steps (`@clack/prompts`): one line per step, the ones a
- * piece suggests already ticked; space toggles, enter runs (the library shows the keys). It
- * only runs with a terminal.
+ * @file The questions, in Spanish (`@clack/prompts`), all asked before any step runs: the
+ * quick path (do everything suggested, pick, or leave), the checkbox menu of the steps, the
+ * skills of a step grouped by catalog with their description, and whether to replace the
+ * repo's own skills. They only run with a terminal.
  */
-import { isCancel, multiselect } from "@clack/prompts";
+import { styleText } from "node:util";
+import { confirm, groupMultiselect, isCancel, MULTISELECT_INSTRUCTIONS, multiselect, select, SELECT_INSTRUCTIONS } from "@clack/prompts";
+/** Width a skill's description is cut to in the menu. */
+const DESCRIPTION_WIDTH = 70;
+/**
+ * Puts the keys' help of the menus in Spanish. The library exports those lines as arrays,
+ * so they are replaced in place.
+ */
+function spanishKeys() {
+    MULTISELECT_INSTRUCTIONS.splice(0, MULTISELECT_INSTRUCTIONS.length, `${styleText("dim", "↑/↓")} moverse`, `${styleText("dim", "Espacio:")} marcar`, `${styleText("dim", "Enter:")} seguir`);
+    SELECT_INSTRUCTIONS.splice(0, SELECT_INSTRUCTIONS.length, `${styleText("dim", "↑/↓")} moverse`, `${styleText("dim", "Enter:")} elegir`);
+}
 /**
  * The menu's options: each step's index and label, which names its piece.
  * @param steps - The steps.
@@ -16,6 +28,36 @@ export function menuOptions(steps) {
         initialValues: steps.flatMap((step, index) => (step.checked ? [index] : [])),
     };
 }
+/**
+ * The skills menu's options: grouped by catalog, each with its description cut short.
+ * @param candidates - What the catalogs offer.
+ * @returns The groups.
+ * @example Object.keys(skillOptions(candidates)) // ["ramon-sg/issue-flow", "ramon-sg/agent-skills"]
+ */
+export function skillOptions(candidates) {
+    const groups = {};
+    for (const candidate of candidates) {
+        const hint = candidate.description.length > DESCRIPTION_WIDTH ? `${candidate.description.slice(0, DESCRIPTION_WIDTH - 1)}…` : candidate.description;
+        const group = candidate.catalog === "" ? "skills" : candidate.catalog;
+        groups[group] = [...(groups[group] ?? []), { value: candidate.id, label: candidate.name, ...(hint === "" ? {} : { hint }) }];
+    }
+    return groups;
+}
+/**
+ * Asks what to do: everything suggested, pick step by step, or leave.
+ * @param count - How many steps are suggested; with none, the option to do them is not shown.
+ * @returns The answer; "leave" if the person cancelled.
+ * @example await askPath(4) // "all"
+ */
+export async function askPath(count) {
+    spanishKeys();
+    const all = { value: "all", label: `Todo lo sugerido (${count} ${count === 1 ? "paso" : "pasos"})`, hint: "recomendado" };
+    const answer = await select({
+        message: "¿Qué hago?",
+        options: [...(count === 0 ? [] : [all]), { value: "pick", label: "Elegir qué hacer" }, { value: "leave", label: "Salir sin cambiar nada" }],
+    });
+    return isCancel(answer) ? "leave" : answer;
+}
 /**
  * Asks which steps to run.
  * @param steps - The steps.
@@ -23,9 +65,36 @@ export function menuOptions(steps) {
  * @example await askSteps(steps)
  */
 export async function askSteps(steps) {
+    spanishKeys();
     const { options, initialValues } = menuOptions(steps);
-    const picked = await multiselect({ message: "What to do?", options, initialValues, required: false });
+    const picked = await multiselect({ message: "¿Qué pasos hago?", options, initialValues, required: false });
     if (isCancel(picked))
         return null;
     return steps.filter((_, index) => picked.includes(index));
 }
+/**
+ * Asks which skills to install.
+ * @param candidates - What the catalogs offer.
+ * @param ticked - The ids ticked at the start.
+ * @returns The picked ids, or null if the person cancelled.
+ * @example await askSkills(candidates, ["catalog:ramon-sg/agent-skills/planning"])
+ */
+export async function askSkills(candidates, ticked) {
+    spanishKeys();
+    const picked = await groupMultiselect({ message: "¿Qué skills instalo?", options: skillOptions(candidates), initialValues: ticked, required: false });
+    return isCancel(picked) ? null : picked;
+}
+/**
+ * Asks whether the catalog's skills replace the repo's own ones with the same name.
+ * @param own - Their names.
+ * @returns True to replace them, false to keep them, or null if the person cancelled.
+ * @example await askReplace(["planning"])
+ */
+export async function askReplace(own) {
+    const answer = await confirm({
+        message: `El repo ya tiene su propia versión de: ${own.join(", ")}. ¿Las reemplazo por las del catálogo? Su project.md se conserva.`,
+        active: "Sí, reemplazar",
+        inactive: "No, dejarlas fuera",
+    });
+    return isCancel(answer) ? null : answer;
+}

package/dist/piece.d.ts

@@ -5,7 +5,6 @@
  * and runs the picked ones in order. Every step runs the piece's own tool, which owns its
  * files: agent-kitchen only writes the few lines that join two pieces.
  */
-import type { Output } from "./output.js";
 /** The issue flow on npm. */
 export declare const FLOW_PACKAGE = "@ramon-sg/issue-flow";
 /** The GitHub repo of the issue flow, which is also the catalog of its skills. */
@@ -20,12 +19,29 @@ export declare const SKILLS_MANIFEST = ".agents/skills.json";
 export declare const SKILLS_LOCK = ".agents/skills.lock.json";
 /** The issue flow's config. */
 export declare const FLOW_CONFIG = ".agents/flow.json";
-/** One step a piece offers: what it does, and how it runs. */
+/** A skill a catalog offers, as `skills-manager --candidates` lists it. */
+export interface Candidate {
+    id: string;
+    name: string;
+    catalog: string;
+    description: string;
+    skills: string[];
+    requires: string[];
+}
+/** The skills a step installs: what it offers, and what the person picked and lets it replace. */
+export interface SkillPick {
+    candidates: Candidate[];
+    picked: string[];
+    replace: string[];
+}
+/** One step a piece offers: what it does, what it downloads, and how it runs. */
 export interface Step {
     piece: string;
     label: string;
     checked: boolean;
-    run: (context: Context) => boolean;
+    downloads: string[];
+    skills?: SkillPick;
+    run: (context: Context) => Promise<boolean>;
 }
 /** What a piece found in the repo: whether it has it, how it is, and the steps offered. */
 export interface PieceStatus {
@@ -35,11 +51,15 @@ export interface PieceStatus {
     state: string;
     steps: Step[];
 }
-/** What a step gets when it runs. */
+/**
+ * What a step gets when it runs: the repo, and where to say what it did (`note`, one short
+ * line under the step) or what went wrong (`fail`, with the command to run by hand and the
+ * tool's output).
+ */
 export interface Context {
     root: string;
-    yes: boolean;
-    out: Output;
+    note: (text: string) => void;
+    fail: (text: string, output?: string) => void;
 }
 /** One check of `agent-kitchen doctor`: passed, failed, or only worth knowing. */
 export interface Check {

package/dist/piece.js

@@ -1,3 +1,10 @@
+/**
+ * @file What agent-kitchen knows of each piece it manages, and the names they share. A piece
+ * (the issue flow, claude-cloud, claude-repo-guard, the skills) tells what the repo has and
+ * the steps that would install or update it; agent-kitchen shows them, lets the person pick,
+ * and runs the picked ones in order. Every step runs the piece's own tool, which owns its
+ * files: agent-kitchen only writes the few lines that join two pieces.
+ */
 /** The issue flow on npm. */
 export const FLOW_PACKAGE = "@ramon-sg/issue-flow";
 /** The GitHub repo of the issue flow, which is also the catalog of its skills. */

package/dist/pieces/cloud.d.ts

@@ -1,17 +1,26 @@
+/**
+ * @file Claude cloud sessions (`@ramon-sg/claude-cloud`). The repo's version is the one
+ * `.claude/cloud.json` pins: the cloud machine runs exactly that one. Installing runs its
+ * `init`; updating only moves that version (and a `$schema` pinned to a version), which is
+ * how `claude-cloud` updates. Outside
+ * the cloud its hook does nothing, so a repo nobody opens in the cloud loses nothing.
+ */
 import type { Check, PieceStatus } from "../piece.js";
 /** The piece's name, as `--skip` takes it. */
 export declare const NAME = "claude-cloud";
+/** The package on npm. */
+export declare const PACKAGE = "@ramon-sg/claude-cloud";
 /**
  * What the repo has of claude-cloud, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
- * @example cloudStatus(root).state // "1.0.0, the latest"
+ * @example (await cloudStatus(root)).state // "1.0.0, al día"
  */
-export declare function cloudStatus(root: string): PieceStatus;
+export declare function cloudStatus(root: string): Promise<PieceStatus>;
 /**
  * Whether `.claude/cloud.json` pins a version, and whether a newer one exists.
  * @param root - The repo.
  * @returns The checks.
- * @example cloudChecks(root)[0].status // "ok"
+ * @example (await cloudChecks(root))[0].status // "ok"
  */
-export declare function cloudChecks(root: string): Check[];
+export declare function cloudChecks(root: string): Promise<Check[]>;

package/dist/pieces/cloud.js

@@ -1,17 +1,9 @@
-/**
- * @file Claude cloud sessions (`@ramon-sg/claude-cloud`). The repo's version is the one
- * `.claude/cloud.json` pins: the cloud machine runs exactly that one. Installing runs its
- * `init`; updating only moves that version (and a `$schema` pinned to a version), which is
- * how `claude-cloud` updates. Outside
- * the cloud its hook does nothing, so a repo nobody opens in the cloud loses nothing.
- */
-import { warn } from "../output.js";
 import { readJson, writeJson } from "../repo.js";
 import { compareVersions, isRelease, npmLatest, runNpx } from "../tools.js";
 /** The piece's name, as `--skip` takes it. */
 export const NAME = "claude-cloud";
 /** The package on npm. */
-const PACKAGE = "@ramon-sg/claude-cloud";
+export const PACKAGE = "@ramon-sg/claude-cloud";
 /** Its config in the repo, which pins its version. */
 const CONFIG = ".claude/cloud.json";
 /**
@@ -35,11 +27,13 @@ function stepFor(config, latest) {
         return {
             piece: NAME,
             checked: true,
-            label: `claude-cloud ${latest ?? "1.x"}: prepares Claude cloud sessions (${CONFIG})`,
-            run: (context) => {
-                if (runNpx(context.root, [spec, "init"]))
+            downloads: [spec],
+            label: `Instalar claude-cloud ${latest ?? "1.x"}: prepara las sesiones en la nube de Claude`,
+            run: async (context) => {
+                const run = await runNpx(context.root, [spec, "init"]);
+                if (run.ok)
                     return true;
-                warn(context.out, `claude-cloud init failed; run 'npx ${spec} init'.`);
+                context.fail(`claude-cloud init falló; corre 'npx ${spec} init'.`, run.output);
                 return false;
             },
         };
@@ -49,8 +43,9 @@ function stepFor(config, latest) {
     return {
         piece: NAME,
         checked: true,
-        label: `claude-cloud ${version ?? "?"} → ${latest}: the version ${CONFIG} pins`,
-        run: (context) => {
+        downloads: [],
+        label: `Actualizar claude-cloud ${version ?? "?"} → ${latest} (la versión que fija ${CONFIG})`,
+        run: async (context) => {
             const current = readJson(context.root, CONFIG) ?? {};
             const schema = typeof current.$schema === "string" ? current.$schema.replace(/@ramon-sg\/claude-cloud@[^/]+\//, `${PACKAGE}@${latest}/`) : undefined;
             writeJson(context.root, CONFIG, { ...current, ...(schema === undefined ? {} : { $schema: schema }), version: latest });
@@ -62,32 +57,32 @@ function stepFor(config, latest) {
  * What the repo has of claude-cloud, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
- * @example cloudStatus(root).state // "1.0.0, the latest"
+ * @example (await cloudStatus(root)).state // "1.0.0, al día"
  */
-export function cloudStatus(root) {
+export async function cloudStatus(root) {
     const config = readJson(root, CONFIG);
-    const latest = npmLatest(PACKAGE);
+    const latest = await npmLatest(PACKAGE);
     const version = pinned(config);
     const step = stepFor(config, latest);
-    const known = latest === null ? " (npm cannot tell the latest)" : "";
-    const state = config === null ? `not installed${known}` : version === null ? `${CONFIG} pins no version` : step === null ? `${version}${known}` : `${version}, ${latest ?? "?"} available`;
-    return { name: NAME, summary: "Claude cloud sessions: tools, Docker and the full clone", installed: config !== null, state, steps: step === null ? [] : [step] };
+    const known = latest === null ? " (npm no responde)" : "";
+    const state = config === null ? `no instalado${known}` : version === null ? `${CONFIG} no fija versión` : step === null ? `${version}, al día${known}` : `${version}, hay ${latest ?? "?"}`;
+    return { name: NAME, summary: "sesiones en la nube de Claude", installed: config !== null, state, steps: step === null ? [] : [step] };
 }
 /**
  * Whether `.claude/cloud.json` pins a version, and whether a newer one exists.
  * @param root - The repo.
  * @returns The checks.
- * @example cloudChecks(root)[0].status // "ok"
+ * @example (await cloudChecks(root))[0].status // "ok"
  */
-export function cloudChecks(root) {
+export async function cloudChecks(root) {
     const config = readJson(root, CONFIG);
     if (config === null)
-        return [{ name: NAME, status: "info", detail: "not installed" }];
+        return [{ name: NAME, status: "info", detail: "no instalado" }];
     const version = pinned(config);
+    const latest = await npmLatest(PACKAGE);
     if (version === null)
-        return [{ name: NAME, status: "fail", detail: `${CONFIG} pins no exact version: set "version" to the one to run, like "${npmLatest(PACKAGE) ?? "1.0.0"}"` }];
-    const latest = npmLatest(PACKAGE);
+        return [{ name: NAME, status: "fail", detail: `${CONFIG} no fija una versión exacta: pon en "version" la que se usa, como "${latest ?? "1.0.0"}"` }];
     if (latest !== null && compareVersions(latest, version) > 0)
-        return [{ name: NAME, status: "info", detail: `${version}, ${latest} available: run npx agent-kitchen` }];
+        return [{ name: NAME, status: "info", detail: `${version}, hay ${latest}: corre npx agent-kitchen` }];
     return [{ name: NAME, status: "ok", detail: version }];
 }

package/dist/pieces/guard.d.ts

@@ -1,6 +1,23 @@
+/**
+ * @file The guardrails (`claude-repo-guard`): auto mode with the sandbox, installed in the
+ * repo. It is not on npm, so it runs from GitHub at its `vX.Y.Z` tag; the repo's version is
+ * the one its manifest records. Before installing or updating, agent-kitchen writes in its
+ * options what the issue flow needs, if the repo has the flow: the auto mode is told that
+ * the flow's writes are normal, the flow's base branch becomes `integrationBranch`, and on
+ * macOS `weakerNetworkIsolation` lets `gh` work inside the sandbox (the guard's own default
+ * is false, so false counts as missing; the step can be unticked). When the flow is
+ * installed in the same run, the guard gets those options in that run too.
+ *
+ * Its command that installs or updates is `apply` since 0.5.0 and `install` before, so the
+ * command follows the version being run. If it fails, its own output is shown; the hint about
+ * Claude's sandbox is added only when that output is a permission error, which is how the
+ * sandbox's block on `.claude/settings.json` shows up.
+ */
 import { type Check, type PieceStatus } from "../piece.js";
 /** The piece's name, as `--skip` takes it. */
 export declare const NAME = "claude-repo-guard";
+/** Its GitHub repo. */
+export declare const REPO = "ramon-sg/claude-repo-guard";
 /** What the auto mode is told about the issue flow. */
 export declare const GUARD_ENVIRONMENT = "issue-flow is this repo's issue workflow: making the branch and worktree of an issue, its empty start commit, pushing it, opening its draft PR, assigning the issue and adding its \"Slug de rama\" block are normal steps of the work, not risky actions.";
 /** The option that lets `gh` verify TLS inside the macOS sandbox. */
@@ -12,12 +29,27 @@ export declare const WEAKER_NETWORK = "weakerNetworkIsolation";
  * @example guardSpec("0.2.0") // "github:ramon-sg/claude-repo-guard#v0.2.0"
  */
 export declare function guardSpec(version: string | null): string;
+/**
+ * The guard's command that installs or updates, at a version.
+ * @param version - The version, or null for the default branch.
+ * @returns `apply` from 0.5.0 on and on the default branch, `install` before.
+ * @example guardCommand("0.4.1") // "install"
+ */
+export declare function guardCommand(version: string | null): string;
+/**
+ * What to say when the guard did not install.
+ * @param version - The version it ran.
+ * @param output - What it printed.
+ * @returns One line: the command to run by hand, and the sandbox hint only if the output is a permission error.
+ * @example guardFailure("0.5.1", "Error: EPERM: operation not permitted") // "…sandbox…"
+ */
+export declare function guardFailure(version: string | null, output: string): string;
 /**
  * The guard's options with what the flow needs added; what the repo set stays.
  * @param root - The repo.
  * @param platform - The operating system (`process.platform`).
  * @returns The new options and what changed.
- * @example guardOptions(root, "darwin").changes // [".claude/repo-guard.config.json: weakerNetworkIsolation true, …"]
+ * @example guardOptions(root, "darwin").changes // ["weakerNetworkIsolation activado, …"]
  */
 export declare function guardOptions(root: string, platform: string): {
     options: Record<string, unknown>;
@@ -28,13 +60,13 @@ export declare function guardOptions(root: string, platform: string): {
  * @param root - The repo.
  * @param flowComing - Whether an earlier step of this run installs the issue flow.
  * @returns The piece's status.
- * @example guardStatus(root, false).state // "not installed"
+ * @example (await guardStatus(root, false)).state // "no instalado"
  */
-export declare function guardStatus(root: string, flowComing: boolean): PieceStatus;
+export declare function guardStatus(root: string, flowComing: boolean): Promise<PieceStatus>;
 /**
  * The guard's own doctor at the repo's version and, on macOS, the option `gh` needs.
  * @param root - The repo.
  * @returns The checks.
- * @example guardChecks(root).map((check) => check.status) // ["ok"]
+ * @example (await guardChecks(root)).map((check) => check.status) // ["ok"]
  */
-export declare function guardChecks(root: string): Check[];
+export declare function guardChecks(root: string): Promise<Check[]>;

package/dist/pieces/guard.js

@@ -7,15 +7,19 @@
  * macOS `weakerNetworkIsolation` lets `gh` work inside the sandbox (the guard's own default
  * is false, so false counts as missing; the step can be unticked). When the flow is
  * installed in the same run, the guard gets those options in that run too.
+ *
+ * Its command that installs or updates is `apply` since 0.5.0 and `install` before, so the
+ * command follows the version being run. If it fails, its own output is shown; the hint about
+ * Claude's sandbox is added only when that output is a permission error, which is how the
+ * sandbox's block on `.claude/settings.json` shows up.
  */
-import { warn } from "../output.js";
 import { FLOW_CONFIG } from "../piece.js";
 import { readJson, writeJson } from "../repo.js";
 import { captureNpx, compareVersions, isRelease, latestTag, runNpx } from "../tools.js";
 /** The piece's name, as `--skip` takes it. */
 export const NAME = "claude-repo-guard";
 /** Its GitHub repo. */
-const REPO = "ramon-sg/claude-repo-guard";
+export const REPO = "ramon-sg/claude-repo-guard";
 /** Its options in the repo. */
 const CONFIG = ".claude/repo-guard.config.json";
 /** What its install records, with its version. */
@@ -33,12 +37,38 @@ export const WEAKER_NETWORK = "weakerNetworkIsolation";
 export function guardSpec(version) {
     return version === null ? `github:${REPO}` : `github:${REPO}#v${version}`;
 }
+/** The first version whose install command is `apply`. */
+const APPLY_SINCE = "0.5.0";
+/** What a write blocked by a sandbox or by the file's permissions prints. */
+const PERMISSION_ERROR = /\b(EPERM|EACCES|EROFS)\b|operation not permitted|permission denied|read-only file system/i;
+/**
+ * The guard's command that installs or updates, at a version.
+ * @param version - The version, or null for the default branch.
+ * @returns `apply` from 0.5.0 on and on the default branch, `install` before.
+ * @example guardCommand("0.4.1") // "install"
+ */
+export function guardCommand(version) {
+    return version === null || compareVersions(version, APPLY_SINCE) >= 0 ? "apply" : "install";
+}
+/**
+ * What to say when the guard did not install.
+ * @param version - The version it ran.
+ * @param output - What it printed.
+ * @returns One line: the command to run by hand, and the sandbox hint only if the output is a permission error.
+ * @example guardFailure("0.5.1", "Error: EPERM: operation not permitted") // "…sandbox…"
+ */
+export function guardFailure(version, output) {
+    const command = `npx ${guardSpec(version)} ${guardCommand(version)}`;
+    if (PERMISSION_ERROR.test(output))
+        return `claude-repo-guard no se instaló: no tuvo permiso para escribir en el repo. Si corres agent-kitchen dentro de una sesión de Claude, su sandbox bloquea .claude/settings.json; corre '${command}' desde tu terminal.`;
+    return `claude-repo-guard no se instaló; su error está abajo. Para reintentar a mano: '${command}'.`;
+}
 /**
  * The guard's options with what the flow needs added; what the repo set stays.
  * @param root - The repo.
  * @param platform - The operating system (`process.platform`).
  * @returns The new options and what changed.
- * @example guardOptions(root, "darwin").changes // [".claude/repo-guard.config.json: weakerNetworkIsolation true, …"]
+ * @example guardOptions(root, "darwin").changes // ["weakerNetworkIsolation activado, …"]
  */
 export function guardOptions(root, platform) {
     const options = { ...(readJson(root, CONFIG) ?? {}) };
@@ -47,16 +77,16 @@ export function guardOptions(root, platform) {
     const environment = Array.isArray(options.environment) ? options.environment.map(String) : [];
     if (flow !== null && !environment.includes(GUARD_ENVIRONMENT)) {
         options.environment = [...environment, GUARD_ENVIRONMENT];
-        changes.push(`${CONFIG}: tells the auto mode about the issue flow`);
+        changes.push("le explica el flujo de issues al modo auto");
     }
     const baseBranch = typeof flow?.baseBranch === "string" ? flow.baseBranch : null;
     if (baseBranch !== null && (options.integrationBranch === undefined || options.integrationBranch === "")) {
         options.integrationBranch = baseBranch;
-        changes.push(`${CONFIG}: integrationBranch ${baseBranch}`);
+        changes.push(`rama de integración ${baseBranch}`);
     }
     if (platform === "darwin" && options[WEAKER_NETWORK] !== true) {
         options[WEAKER_NETWORK] = true;
-        changes.push(`${CONFIG}: ${WEAKER_NETWORK} true, so gh works inside the macOS sandbox`);
+        changes.push(`${WEAKER_NETWORK} activado, para que gh funcione en el sandbox de macOS`);
     }
     return { options, changes };
 }
@@ -66,15 +96,16 @@ export function guardOptions(root, platform) {
  * @param version - The version, or null for the default branch.
  * @returns Whether it installed.
  */
-function install(context, version) {
+async function install(context, version) {
     const { options, changes } = guardOptions(context.root, process.platform);
     if (changes.length > 0)
         writeJson(context.root, CONFIG, options);
     for (const change of changes)
-        context.out.stdout(`  ${change}\n`);
-    if (runNpx(context.root, [guardSpec(version), "install", "--yes"]))
+        context.note(change);
+    const run = await runNpx(context.root, [guardSpec(version), guardCommand(version), "--yes"]);
+    if (run.ok)
         return true;
-    failed(context.out, version);
+    context.fail(guardFailure(version, run.output), run.output);
     return false;
 }
 /**
@@ -84,20 +115,12 @@ function install(context, version) {
  * @param version - The guard's version, or null.
  * @returns Whether it worked, or true if nothing was missing.
  */
-function addOptions(context, version) {
+async function addOptions(context, version) {
     if (guardOptions(context.root, process.platform).changes.length > 0)
         return install(context, version);
-    context.out.stdout("  its options already have what the issue flow needs\n");
+    context.note("sus opciones ya tienen lo que necesita el flujo");
     return true;
 }
-/**
- * Says how to retry an install that failed.
- * @param out - Where to write.
- * @param version - The version it tried.
- */
-function failed(out, version) {
-    warn(out, `claude-repo-guard did not install; run 'npx ${guardSpec(version)} install' from your terminal (inside a Claude session its sandbox blocks .claude/settings.json).`);
-}
 /**
  * The version its manifest records.
  * @param root - The repo.
@@ -118,11 +141,11 @@ function installedVersion(root) {
  */
 function stepFor(root, installed, latest, flowComing) {
     if (installed === undefined)
-        return { piece: NAME, checked: true, label: `claude-repo-guard ${latest ?? "(main)"}: auto mode with the sandbox, and a doc of what it protects`, run: (context) => install(context, latest) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], label: `Instalar claude-repo-guard ${latest ?? "(main)"}: modo auto con sandbox, y un documento de qué protege`, run: (context) => install(context, latest) };
     if (latest !== null && (installed === null || compareVersions(latest, installed) > 0))
-        return { piece: NAME, checked: true, label: `claude-repo-guard ${installed ?? "?"} → ${latest}`, run: (context) => install(context, latest) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], label: `Actualizar claude-repo-guard ${installed ?? "?"} → ${latest}`, run: (context) => install(context, latest) };
     if (flowComing || guardOptions(root, process.platform).changes.length > 0)
-        return { piece: NAME, checked: true, label: "claude-repo-guard: what the issue flow needs in its options", run: (context) => addOptions(context, installed) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(installed)], label: "Ajustar claude-repo-guard a lo que necesita el flujo de issues", run: (context) => addOptions(context, installed) };
     return null;
 }
 /**
@@ -130,30 +153,30 @@ function stepFor(root, installed, latest, flowComing) {
  * @param root - The repo.
  * @param flowComing - Whether an earlier step of this run installs the issue flow.
  * @returns The piece's status.
- * @example guardStatus(root, false).state // "not installed"
+ * @example (await guardStatus(root, false)).state // "no instalado"
  */
-export function guardStatus(root, flowComing) {
+export async function guardStatus(root, flowComing) {
     const installed = installedVersion(root);
-    const latest = latestTag(REPO);
-    const known = latest === null ? " (GitHub has no release tag)" : "";
-    const state = installed === undefined ? `not installed${known}` : latest !== null && (installed === null || compareVersions(latest, installed) > 0) ? `${installed ?? "unknown version"}, ${latest} available` : `${installed ?? "unknown version"}${known}`;
+    const latest = await latestTag(REPO);
+    const known = latest === null ? " (GitHub no tiene una versión)" : "";
+    const state = installed === undefined ? `no instalado${known}` : latest !== null && (installed === null || compareVersions(latest, installed) > 0) ? `${installed ?? "versión desconocida"}, hay ${latest}` : `${installed ?? "versión desconocida"}, al día${known}`;
     const step = stepFor(root, installed, latest, flowComing);
-    return { name: NAME, summary: "guardrails: auto mode with the sandbox, writes only inside the worktree", installed: installed !== undefined, state, steps: step === null ? [] : [step] };
+    return { name: NAME, summary: "barandas: modo auto con sandbox", installed: installed !== undefined, state, steps: step === null ? [] : [step] };
 }
 /**
  * The guard's own doctor at the repo's version and, on macOS, the option `gh` needs.
  * @param root - The repo.
  * @returns The checks.
- * @example guardChecks(root).map((check) => check.status) // ["ok"]
+ * @example (await guardChecks(root)).map((check) => check.status) // ["ok"]
  */
-export function guardChecks(root) {
+export async function guardChecks(root) {
     const installed = installedVersion(root);
     if (installed === undefined)
-        return [{ name: NAME, status: "info", detail: "not installed (Claude opens with your own permissions)" }];
+        return [{ name: NAME, status: "info", detail: "no instalado (Claude se abre con tus propios permisos)" }];
     const checks = [];
     if (process.platform === "darwin" && readJson(root, CONFIG)?.[WEAKER_NETWORK] !== true)
-        checks.push({ name: `${NAME}: ${WEAKER_NETWORK}`, status: "fail", detail: `not true in ${CONFIG}, so gh fails inside the macOS sandbox: run npx agent-kitchen` });
-    const result = captureNpx(root, [guardSpec(installed), "doctor", "--json"]);
+        checks.push({ name: `${NAME}: ${WEAKER_NETWORK}`, status: "fail", detail: `no está activado en ${CONFIG}, así que gh falla en el sandbox de macOS: corre npx agent-kitchen` });
+    const result = await captureNpx(root, [guardSpec(installed), "doctor", "--json"]);
     let found;
     try {
         found = JSON.parse(result?.out ?? "");
@@ -162,10 +185,10 @@ export function guardChecks(root) {
         found = null;
     }
     if (!Array.isArray(found))
-        return [...checks, { name: NAME, status: "fail", detail: `could not run its doctor; run 'npx ${guardSpec(installed)} doctor'` }];
+        return [...checks, { name: NAME, status: "fail", detail: `no se pudo correr su doctor; corre 'npx ${guardSpec(installed)} doctor'` }];
     const bad = found.filter((check) => typeof check !== "object" || check === null || check.ok !== true);
     if (bad.length === 0)
-        return [...checks, { name: NAME, status: "ok", detail: `${installed ?? "unknown version"}, its doctor passes` }];
+        return [...checks, { name: NAME, status: "ok", detail: `${installed ?? "versión desconocida"}, su doctor pasa` }];
     return [...checks, ...bad.map((check) => {
             const entry = typeof check === "object" && check !== null ? check : { name: "?", detail: String(check) };
             return { name: `${NAME}: ${String(entry.name)}`, status: "fail", detail: String(entry.detail) };

package/dist/pieces/issue-flow.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @file The issue flow (`@ramon-sg/issue-flow`): its CLI, hooks and config, and its skills.
+ * The repo's version is the one in package.json. Installing runs its `init` at the latest
+ * version; updating runs its `upgrade` at the new one and then moves its skills to the same
+ * tag, because the skills call the CLI. If only the skills are off, it moves them alone.
+ * `init` runs with `--yes`: the person answered agent-kitchen's questions before the steps.
+ */
 import { type Check, type PieceStatus } from "../piece.js";
 /** The piece's name, as `--skip` takes it. */
 export declare const NAME = "issue-flow";
@@ -20,13 +27,13 @@ export declare function flowVersion(root: string): string | null;
  * What the repo has of the issue flow, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
- * @example issueFlowStatus(root).state // "0.1.0, 0.2.0 available"
+ * @example (await issueFlowStatus(root)).state // "0.1.0, hay 0.2.0"
  */
-export declare function issueFlowStatus(root: string): PieceStatus;
+export declare function issueFlowStatus(root: string): Promise<PieceStatus>;
 /**
  * The flow's own doctor at the repo's version, and whether its skills are at that tag.
  * @param root - The repo.
  * @returns The checks.
- * @example issueFlowChecks(root)[0].name // "issue-flow: .agents/flow.json"
+ * @example (await issueFlowChecks(root))[0].name // "issue-flow: .agents/flow.json"
  */
-export declare function issueFlowChecks(root: string): Check[];
+export declare function issueFlowChecks(root: string): Promise<Check[]>;