argos-harness 0.1.0

package/dist/lib/workspaces.js

@@ -0,0 +1,241 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+import { parseIdentityFromRemote } from "./git.js";
+import { resolveArgosHome } from "./paths.js";
+export const WORKSPACES_FILENAME = "workspaces.json";
+/**
+ * Thrown by `loadRegistry` when `workspaces.json` exists but isn't valid
+ * JSON. Typed so callers can tell "the registry is corrupt" apart from any
+ * other unexpected throw and surface a clean, structured message instead of
+ * an unhandled parse-error stack trace.
+ */ export class RegistryError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "RegistryError";
+    }
+}
+function workspacesPath() {
+    return join(resolveArgosHome(), WORKSPACES_FILENAME);
+}
+/**
+ * Load `~/.argos/workspaces.json`. A missing file is a fresh install —
+ * returns `{}`. Throws `RegistryError` when the file exists but isn't valid
+ * JSON — callers must not let that crash bubble up as a raw stack trace
+ * (see commands/workspace.ts, commands/doctor.ts, commands/adopt.ts).
+ */ export function loadRegistry() {
+    const path = workspacesPath();
+    if (!existsSync(path)) return {};
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, "utf-8"));
+    } catch  {
+        throw new RegistryError("workspaces.json corrupto — arregla o borra el archivo.");
+    }
+    return raw;
+}
+/** Persist the registry (pretty JSON, trailing newline), creating `~/.argos` if needed. */ export function saveRegistry(registry) {
+    mkdirSync(resolveArgosHome(), {
+        recursive: true
+    });
+    writeFileAtomic(workspacesPath(), `${JSON.stringify(registry, null, 2)}\n`);
+}
+/**
+ * True when any entry in `matchRemotes` is a substring of the repo's remote
+ * identity — matched against both the parsed identity token (e.g.
+ * `github.com-bonum`) and the raw remote URL, so a rule can be as narrow as
+ * `bonum` or as specific as the full identity token.
+ */ function remoteMatches(remoteUrl, matchRemotes) {
+    if (!remoteUrl || matchRemotes.length === 0) return false;
+    const identity = parseIdentityFromRemote(remoteUrl);
+    return matchRemotes.some((rule)=>(identity?.includes(rule) ?? false) || remoteUrl.includes(rule));
+}
+/** Escape regex metacharacters other than `*`, then turn `*` into `.*`. */ function globToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+/** Prefix match for plain patterns, glob match (`*` wildcard) for patterns containing `*`. */ function pathMatches(repoPath, matchPaths) {
+    return matchPaths.some((pattern)=>pattern.includes("*") ? globToRegExp(pattern).test(repoPath) : repoPath.startsWith(pattern));
+}
+/**
+ * Resolve which workspace a repo belongs to, per spec 0003's chain:
+ * explicit name > `workspace` in argos.config.json > match rules (remote
+ * substring match first, path prefix/glob as fallback) > unresolved.
+ * 2+ candidates at a match stage is ambiguous — resolution never guesses
+ * between identities, it reports the candidates for the caller to surface.
+ */ export function resolveWorkspaceForRepo(registry, input) {
+    if (input.explicit) {
+        return {
+            kind: "resolved",
+            name: input.explicit,
+            source: "explicit"
+        };
+    }
+    if (input.configWorkspace) {
+        return {
+            kind: "resolved",
+            name: input.configWorkspace,
+            source: "config"
+        };
+    }
+    const remoteCandidates = Object.entries(registry).filter(([, ws])=>remoteMatches(input.remoteUrl, ws.match.remotes)).map(([name])=>name);
+    if (remoteCandidates.length === 1) {
+        return {
+            kind: "resolved",
+            name: remoteCandidates[0],
+            source: "match-remote"
+        };
+    }
+    if (remoteCandidates.length > 1) {
+        return {
+            kind: "ambiguous",
+            candidates: remoteCandidates,
+            source: "match-remote"
+        };
+    }
+    const pathCandidates = Object.entries(registry).filter(([, ws])=>pathMatches(input.repoPath, ws.match.paths)).map(([name])=>name);
+    if (pathCandidates.length === 1) {
+        return {
+            kind: "resolved",
+            name: pathCandidates[0],
+            source: "match-path"
+        };
+    }
+    if (pathCandidates.length > 1) {
+        return {
+            kind: "ambiguous",
+            candidates: pathCandidates,
+            source: "match-path"
+        };
+    }
+    return {
+        kind: "unresolved"
+    };
+}
+/**
+ * Thrown by `linkRepo` when `repo.name` is already registered in
+ * `workspaceName` pointing at a DIFFERENT path that still exists on disk —
+ * i.e. two distinct physical repos colliding on the same `config.name`.
+ * Overwriting silently here would evict the old entry with no trace (data
+ * loss for whoever relies on it), so `linkRepo` refuses unless `force` is
+ * passed. Carries both paths so the caller can print a clear diagnostic.
+ */ export class WorkspaceNameCollisionError extends Error {
+    workspaceName;
+    repoName;
+    oldPath;
+    newPath;
+    constructor(workspaceName, repoName, oldPath, newPath){
+        super(`El repo '${repoName}' ya está registrado en el workspace '${workspaceName}' apuntando a otro path.\n` + `  actual: ${oldPath}\n` + `  nuevo:  ${newPath}\n` + "Si son repos distintos, usá otro config.name; si el cambio es intencional, pasá --force."), this.workspaceName = workspaceName, this.repoName = repoName, this.oldPath = oldPath, this.newPath = newPath;
+        this.name = "WorkspaceNameCollisionError";
+    }
+}
+/**
+ * Register `repo` under workspace `workspaceName`, creating the workspace if
+ * it doesn't exist yet. Re-linking the same repo name updates its path
+ * (idempotent no-op when the path is unchanged). The path is normalized to
+ * an absolute, symlink-resolved form before it's stored — `workspace show`
+ * and `workspace agents` then compare disk state against exactly what's on
+ * record. Throws when `repo.path` doesn't exist on disk.
+ *
+ * When an entry with the same name already exists at a DIFFERENT path, and
+ * that old path still exists on disk with a different realpath, this
+ * refuses with `WorkspaceNameCollisionError` instead of silently evicting
+ * the old entry — unless `options.force` is set. If the old path is gone
+ * from disk, it's treated as a legitimate move (repo relocated) and updated
+ * as before, force or not.
+ */ export function linkRepo(workspaceName, repo, options = {}) {
+    let normalizedPath;
+    try {
+        normalizedPath = realpathSync(resolve(repo.path));
+    } catch  {
+        throw new Error(`No existe el directorio del repo: ${repo.path}`);
+    }
+    const registry = loadRegistry();
+    const existing = registry[workspaceName];
+    const createdWorkspace = !existing;
+    const workspace = existing ?? {
+        match: {
+            remotes: [],
+            paths: []
+        },
+        repos: []
+    };
+    const repoIndex = workspace.repos.findIndex((r)=>r.name === repo.name);
+    let action;
+    let previousPath;
+    if (repoIndex === -1) {
+        workspace.repos.push({
+            name: repo.name,
+            path: normalizedPath
+        });
+        action = "added";
+    } else {
+        const current = workspace.repos[repoIndex];
+        if (current.path === normalizedPath) {
+            action = "unchanged";
+        } else {
+            if (!options.force) {
+                let isCollision = false;
+                try {
+                    // Re-resolve rather than trusting the stored value verbatim: it's
+                    // normally already a realpath, but re-checking is what actually
+                    // proves the old path is still live and distinct on disk.
+                    isCollision = realpathSync(current.path) !== normalizedPath;
+                } catch  {
+                    isCollision = false; // old path is gone from disk -> legitimate move, not a collision
+                }
+                if (isCollision) {
+                    throw new WorkspaceNameCollisionError(workspaceName, repo.name, current.path, normalizedPath);
+                }
+            }
+            previousPath = current.path;
+            workspace.repos[repoIndex] = {
+                name: repo.name,
+                path: normalizedPath
+            };
+            action = "updated-path";
+        }
+    }
+    registry[workspaceName] = workspace;
+    saveRegistry(registry);
+    return {
+        workspaceName,
+        createdWorkspace,
+        action,
+        previousPath,
+        repoPath: normalizedPath
+    };
+}
+/**
+ * Decide whether a newly-created workspace should learn the repo's remote as
+ * a match rule. Per spec: only offered when the workspace is brand new AND
+ * the name was given explicitly (so it isn't a false positive from a match
+ * rule that already matched something else) AND the repo actually has a
+ * parseable remote that isn't already recorded.
+ */ export function offerMatchRule(input) {
+    if (!input.createdWorkspace || !input.viaExplicitName || !input.remoteUrl) {
+        return {
+            shouldPersist: false
+        };
+    }
+    const identity = parseIdentityFromRemote(input.remoteUrl);
+    if (!identity || input.currentMatch.remotes.includes(identity)) {
+        return {
+            shouldPersist: false
+        };
+    }
+    return {
+        shouldPersist: true,
+        identity
+    };
+}
+/** Append `identity` to a workspace's `match.remotes`, if it isn't already there. */ export function addRemoteMatchRule(workspaceName, identity) {
+    const registry = loadRegistry();
+    const workspace = registry[workspaceName];
+    if (!workspace) return;
+    if (workspace.match.remotes.includes(identity)) return;
+    workspace.match.remotes.push(identity);
+    saveRegistry(registry);
+}
+
+//# sourceMappingURL=workspaces.js.map

package/dist/lib/workspaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/workspaces.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, realpathSync } from \"node:fs\";\nimport { join, resolve } from \"node:path\";\nimport { writeFileAtomic } from \"./atomic-write.js\";\nimport { parseIdentityFromRemote } from \"./git.js\";\nimport { resolveArgosHome } from \"./paths.js\";\n\nexport const WORKSPACES_FILENAME = \"workspaces.json\";\n\nexport interface WorkspaceMatch {\n  remotes: string[];\n  paths: string[];\n}\n\nexport interface WorkspaceRepoEntry {\n  name: string;\n  path: string;\n}\n\nexport interface WorkspaceEntry {\n  match: WorkspaceMatch;\n  repos: WorkspaceRepoEntry[];\n}\n\n/** `name -> workspace` machine-local registry, per spec 0003. */\nexport type WorkspaceRegistry = Record<string, WorkspaceEntry>;\n\n/**\n * Thrown by `loadRegistry` when `workspaces.json` exists but isn't valid\n * JSON. Typed so callers can tell \"the registry is corrupt\" apart from any\n * other unexpected throw and surface a clean, structured message instead of\n * an unhandled parse-error stack trace.\n */\nexport class RegistryError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"RegistryError\";\n  }\n}\n\nfunction workspacesPath(): string {\n  return join(resolveArgosHome(), WORKSPACES_FILENAME);\n}\n\n/**\n * Load `~/.argos/workspaces.json`. A missing file is a fresh install —\n * returns `{}`. Throws `RegistryError` when the file exists but isn't valid\n * JSON — callers must not let that crash bubble up as a raw stack trace\n * (see commands/workspace.ts, commands/doctor.ts, commands/adopt.ts).\n */\nexport function loadRegistry(): WorkspaceRegistry {\n  const path = workspacesPath();\n  if (!existsSync(path)) return {};\n  let raw: unknown;\n  try {\n    raw = JSON.parse(readFileSync(path, \"utf-8\"));\n  } catch {\n    throw new RegistryError(\"workspaces.json corrupto — arregla o borra el archivo.\");\n  }\n  return raw as WorkspaceRegistry;\n}\n\n/** Persist the registry (pretty JSON, trailing newline), creating `~/.argos` if needed. */\nexport function saveRegistry(registry: WorkspaceRegistry): void {\n  mkdirSync(resolveArgosHome(), { recursive: true });\n  writeFileAtomic(workspacesPath(), `${JSON.stringify(registry, null, 2)}\\n`);\n}\n\n// --- resolution chain ------------------------------------------------------\n\nexport interface ResolveWorkspaceInput {\n  /** An explicit name the user passed on the command line, e.g. `workspace link bonum`. */\n  explicit?: string;\n  /** The `workspace` field from the repo's argos.config.json, if set. */\n  configWorkspace?: string;\n  /** The repo's `origin` remote URL, if it has one. */\n  remoteUrl?: string | null;\n  /** Absolute path to the repo, used for path-based match rules. */\n  repoPath: string;\n}\n\nexport type ResolveMatchSource = \"match-remote\" | \"match-path\";\nexport type ResolveSource = \"explicit\" | \"config\" | ResolveMatchSource;\n\nexport type ResolveWorkspaceResult =\n  | { kind: \"resolved\"; name: string; source: ResolveSource }\n  | { kind: \"ambiguous\"; candidates: string[]; source: ResolveMatchSource }\n  | { kind: \"unresolved\" };\n\n/**\n * True when any entry in `matchRemotes` is a substring of the repo's remote\n * identity — matched against both the parsed identity token (e.g.\n * `github.com-bonum`) and the raw remote URL, so a rule can be as narrow as\n * `bonum` or as specific as the full identity token.\n */\nfunction remoteMatches(remoteUrl: string | null | undefined, matchRemotes: string[]): boolean {\n  if (!remoteUrl || matchRemotes.length === 0) return false;\n  const identity = parseIdentityFromRemote(remoteUrl);\n  return matchRemotes.some((rule) => (identity?.includes(rule) ?? false) || remoteUrl.includes(rule));\n}\n\n/** Escape regex metacharacters other than `*`, then turn `*` into `.*`. */\nfunction globToRegExp(pattern: string): RegExp {\n  const escaped = pattern.replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$&\").replace(/\\*/g, \".*\");\n  return new RegExp(`^${escaped}$`);\n}\n\n/** Prefix match for plain patterns, glob match (`*` wildcard) for patterns containing `*`. */\nfunction pathMatches(repoPath: string, matchPaths: string[]): boolean {\n  return matchPaths.some((pattern) =>\n    pattern.includes(\"*\") ? globToRegExp(pattern).test(repoPath) : repoPath.startsWith(pattern),\n  );\n}\n\n/**\n * Resolve which workspace a repo belongs to, per spec 0003's chain:\n * explicit name > `workspace` in argos.config.json > match rules (remote\n * substring match first, path prefix/glob as fallback) > unresolved.\n * 2+ candidates at a match stage is ambiguous — resolution never guesses\n * between identities, it reports the candidates for the caller to surface.\n */\nexport function resolveWorkspaceForRepo(\n  registry: WorkspaceRegistry,\n  input: ResolveWorkspaceInput,\n): ResolveWorkspaceResult {\n  if (input.explicit) {\n    return { kind: \"resolved\", name: input.explicit, source: \"explicit\" };\n  }\n  if (input.configWorkspace) {\n    return { kind: \"resolved\", name: input.configWorkspace, source: \"config\" };\n  }\n\n  const remoteCandidates = Object.entries(registry)\n    .filter(([, ws]) => remoteMatches(input.remoteUrl, ws.match.remotes))\n    .map(([name]) => name);\n  if (remoteCandidates.length === 1) {\n    return { kind: \"resolved\", name: remoteCandidates[0] as string, source: \"match-remote\" };\n  }\n  if (remoteCandidates.length > 1) {\n    return { kind: \"ambiguous\", candidates: remoteCandidates, source: \"match-remote\" };\n  }\n\n  const pathCandidates = Object.entries(registry)\n    .filter(([, ws]) => pathMatches(input.repoPath, ws.match.paths))\n    .map(([name]) => name);\n  if (pathCandidates.length === 1) {\n    return { kind: \"resolved\", name: pathCandidates[0] as string, source: \"match-path\" };\n  }\n  if (pathCandidates.length > 1) {\n    return { kind: \"ambiguous\", candidates: pathCandidates, source: \"match-path\" };\n  }\n\n  return { kind: \"unresolved\" };\n}\n\n// --- linking ----------------------------------------------------------------\n\nexport type LinkAction = \"added\" | \"updated-path\" | \"unchanged\";\n\nexport interface LinkRepoResult {\n  workspaceName: string;\n  createdWorkspace: boolean;\n  action: LinkAction;\n  previousPath?: string;\n  /** Normalized (absolute, symlink-resolved) repo path that was stored. */\n  repoPath: string;\n}\n\nexport interface LinkRepoOptions {\n  /**\n   * Bypass the name-collision refusal below and overwrite the existing\n   * entry's path anyway. Mirrors `argos workspace link --force`.\n   */\n  force?: boolean;\n}\n\n/**\n * Thrown by `linkRepo` when `repo.name` is already registered in\n * `workspaceName` pointing at a DIFFERENT path that still exists on disk —\n * i.e. two distinct physical repos colliding on the same `config.name`.\n * Overwriting silently here would evict the old entry with no trace (data\n * loss for whoever relies on it), so `linkRepo` refuses unless `force` is\n * passed. Carries both paths so the caller can print a clear diagnostic.\n */\nexport class WorkspaceNameCollisionError extends Error {\n  constructor(\n    public readonly workspaceName: string,\n    public readonly repoName: string,\n    public readonly oldPath: string,\n    public readonly newPath: string,\n  ) {\n    super(\n      `El repo '${repoName}' ya está registrado en el workspace '${workspaceName}' apuntando a otro path.\\n` +\n        `  actual: ${oldPath}\\n` +\n        `  nuevo:  ${newPath}\\n` +\n        \"Si son repos distintos, usá otro config.name; si el cambio es intencional, pasá --force.\",\n    );\n    this.name = \"WorkspaceNameCollisionError\";\n  }\n}\n\n/**\n * Register `repo` under workspace `workspaceName`, creating the workspace if\n * it doesn't exist yet. Re-linking the same repo name updates its path\n * (idempotent no-op when the path is unchanged). The path is normalized to\n * an absolute, symlink-resolved form before it's stored — `workspace show`\n * and `workspace agents` then compare disk state against exactly what's on\n * record. Throws when `repo.path` doesn't exist on disk.\n *\n * When an entry with the same name already exists at a DIFFERENT path, and\n * that old path still exists on disk with a different realpath, this\n * refuses with `WorkspaceNameCollisionError` instead of silently evicting\n * the old entry — unless `options.force` is set. If the old path is gone\n * from disk, it's treated as a legitimate move (repo relocated) and updated\n * as before, force or not.\n */\nexport function linkRepo(\n  workspaceName: string,\n  repo: WorkspaceRepoEntry,\n  options: LinkRepoOptions = {},\n): LinkRepoResult {\n  let normalizedPath: string;\n  try {\n    normalizedPath = realpathSync(resolve(repo.path));\n  } catch {\n    throw new Error(`No existe el directorio del repo: ${repo.path}`);\n  }\n\n  const registry = loadRegistry();\n  const existing = registry[workspaceName];\n  const createdWorkspace = !existing;\n  const workspace: WorkspaceEntry = existing ?? { match: { remotes: [], paths: [] }, repos: [] };\n\n  const repoIndex = workspace.repos.findIndex((r) => r.name === repo.name);\n  let action: LinkAction;\n  let previousPath: string | undefined;\n  if (repoIndex === -1) {\n    workspace.repos.push({ name: repo.name, path: normalizedPath });\n    action = \"added\";\n  } else {\n    const current = workspace.repos[repoIndex] as WorkspaceRepoEntry;\n    if (current.path === normalizedPath) {\n      action = \"unchanged\";\n    } else {\n      if (!options.force) {\n        let isCollision = false;\n        try {\n          // Re-resolve rather than trusting the stored value verbatim: it's\n          // normally already a realpath, but re-checking is what actually\n          // proves the old path is still live and distinct on disk.\n          isCollision = realpathSync(current.path) !== normalizedPath;\n        } catch {\n          isCollision = false; // old path is gone from disk -> legitimate move, not a collision\n        }\n        if (isCollision) {\n          throw new WorkspaceNameCollisionError(workspaceName, repo.name, current.path, normalizedPath);\n        }\n      }\n      previousPath = current.path;\n      workspace.repos[repoIndex] = { name: repo.name, path: normalizedPath };\n      action = \"updated-path\";\n    }\n  }\n\n  registry[workspaceName] = workspace;\n  saveRegistry(registry);\n\n  return { workspaceName, createdWorkspace, action, previousPath, repoPath: normalizedPath };\n}\n\n// --- auto-teaching match rules ----------------------------------------------\n\nexport interface OfferMatchRuleInput {\n  createdWorkspace: boolean;\n  /** True when the workspace name came from an explicit `link <name>` argument. */\n  viaExplicitName: boolean;\n  remoteUrl?: string | null;\n  currentMatch: WorkspaceMatch;\n}\n\nexport interface OfferMatchRuleResult {\n  shouldPersist: boolean;\n  identity?: string;\n}\n\n/**\n * Decide whether a newly-created workspace should learn the repo's remote as\n * a match rule. Per spec: only offered when the workspace is brand new AND\n * the name was given explicitly (so it isn't a false positive from a match\n * rule that already matched something else) AND the repo actually has a\n * parseable remote that isn't already recorded.\n */\nexport function offerMatchRule(input: OfferMatchRuleInput): OfferMatchRuleResult {\n  if (!input.createdWorkspace || !input.viaExplicitName || !input.remoteUrl) {\n    return { shouldPersist: false };\n  }\n  const identity = parseIdentityFromRemote(input.remoteUrl);\n  if (!identity || input.currentMatch.remotes.includes(identity)) {\n    return { shouldPersist: false };\n  }\n  return { shouldPersist: true, identity };\n}\n\n/** Append `identity` to a workspace's `match.remotes`, if it isn't already there. */\nexport function addRemoteMatchRule(workspaceName: string, identity: string): void {\n  const registry = loadRegistry();\n  const workspace = registry[workspaceName];\n  if (!workspace) return;\n  if (workspace.match.remotes.includes(identity)) return;\n  workspace.match.remotes.push(identity);\n  saveRegistry(registry);\n}\n"],"names":["existsSync","mkdirSync","readFileSync","realpathSync","join","resolve","writeFileAtomic","parseIdentityFromRemote","resolveArgosHome","WORKSPACES_FILENAME","RegistryError","Error","message","name","workspacesPath","loadRegistry","path","raw","JSON","parse","saveRegistry","registry","recursive","stringify","remoteMatches","remoteUrl","matchRemotes","length","identity","some","rule","includes","globToRegExp","pattern","escaped","replace","RegExp","pathMatches","repoPath","matchPaths","test","startsWith","resolveWorkspaceForRepo","input","explicit","kind","source","configWorkspace","remoteCandidates","Object","entries","filter","ws","match","remotes","map","candidates","pathCandidates","paths","WorkspaceNameCollisionError","workspaceName","repoName","oldPath","newPath","linkRepo","repo","options","normalizedPath","existing","createdWorkspace","workspace","repos","repoIndex","findIndex","r","action","previousPath","push","current","force","isCollision","offerMatchRule","viaExplicitName","shouldPersist","currentMatch","addRemoteMatchRule"],"mappings":"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"}

package/dist/lib/zod-messages.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+/** Map every issue in a ZodError to a readable Spanish sentence. */
+export declare function describeZodError(error: z.core.$ZodError | unknown): string[];
+//# sourceMappingURL=zod-messages.d.ts.map

package/dist/lib/zod-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-messages.d.ts","sourceRoot":"","sources":["../../src/lib/zod-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,OAAO,GAAG,MAAM,EAAE,CAG5E"}

package/dist/lib/zod-messages.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/** Render a single zod issue as a plain Spanish sentence, not a raw zod dump. */ function describeIssue(issue) {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(raíz)";
+    switch(issue.code){
+        case "invalid_type":
+            return `${path}: tipo inválido, se esperaba ${issue.expected}.`;
+        case "too_small":
+            return `${path}: valor demasiado pequeño/corto (mínimo ${issue.minimum}).`;
+        case "too_big":
+            return `${path}: valor demasiado grande/largo (máximo ${issue.maximum}).`;
+        case "invalid_value":
+            return `${path}: valor no permitido (opciones válidas: ${issue.values.join(", ")}).`;
+        case "unrecognized_keys":
+            return `${path}: propiedades desconocidas (${issue.keys.join(", ")}).`;
+        case "invalid_format":
+            return `${path}: formato inválido (${issue.format}).`;
+        default:
+            return `${path}: ${issue.message}`;
+    }
+}
+/** Map every issue in a ZodError to a readable Spanish sentence. */ export function describeZodError(error) {
+    if (error instanceof z.ZodError) return error.issues.map(describeIssue);
+    return [
+        error instanceof Error ? error.message : String(error)
+    ];
+}
+
+//# sourceMappingURL=zod-messages.js.map

package/dist/lib/zod-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/zod-messages.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/** Render a single zod issue as a plain Spanish sentence, not a raw zod dump. */\nfunction describeIssue(issue: z.core.$ZodIssue): string {\n  const path = issue.path.length > 0 ? issue.path.join(\".\") : \"(raíz)\";\n  switch (issue.code) {\n    case \"invalid_type\":\n      return `${path}: tipo inválido, se esperaba ${issue.expected}.`;\n    case \"too_small\":\n      return `${path}: valor demasiado pequeño/corto (mínimo ${issue.minimum}).`;\n    case \"too_big\":\n      return `${path}: valor demasiado grande/largo (máximo ${issue.maximum}).`;\n    case \"invalid_value\":\n      return `${path}: valor no permitido (opciones válidas: ${issue.values.join(\", \")}).`;\n    case \"unrecognized_keys\":\n      return `${path}: propiedades desconocidas (${issue.keys.join(\", \")}).`;\n    case \"invalid_format\":\n      return `${path}: formato inválido (${issue.format}).`;\n    default:\n      return `${path}: ${issue.message}`;\n  }\n}\n\n/** Map every issue in a ZodError to a readable Spanish sentence. */\nexport function describeZodError(error: z.core.$ZodError | unknown): string[] {\n  if (error instanceof z.ZodError) return error.issues.map(describeIssue);\n  return [error instanceof Error ? error.message : String(error)];\n}\n"],"names":["z","describeIssue","issue","path","length","join","code","expected","minimum","maximum","values","keys","format","message","describeZodError","error","ZodError","issues","map","Error","String"],"mappings":"AAAA,SAASA,CAAC,QAAQ,MAAM;AAExB,+EAA+E,GAC/E,SAASC,cAAcC,KAAuB;IAC5C,MAAMC,OAAOD,MAAMC,IAAI,CAACC,MAAM,GAAG,IAAIF,MAAMC,IAAI,CAACE,IAAI,CAAC,OAAO;IAC5D,OAAQH,MAAMI,IAAI;QAChB,KAAK;YACH,OAAO,GAAGH,KAAK,6BAA6B,EAAED,MAAMK,QAAQ,CAAC,CAAC,CAAC;QACjE,KAAK;YACH,OAAO,GAAGJ,KAAK,wCAAwC,EAAED,MAAMM,OAAO,CAAC,EAAE,CAAC;QAC5E,KAAK;YACH,OAAO,GAAGL,KAAK,uCAAuC,EAAED,MAAMO,OAAO,CAAC,EAAE,CAAC;QAC3E,KAAK;YACH,OAAO,GAAGN,KAAK,wCAAwC,EAAED,MAAMQ,MAAM,CAACL,IAAI,CAAC,MAAM,EAAE,CAAC;QACtF,KAAK;YACH,OAAO,GAAGF,KAAK,4BAA4B,EAAED,MAAMS,IAAI,CAACN,IAAI,CAAC,MAAM,EAAE,CAAC;QACxE,KAAK;YACH,OAAO,GAAGF,KAAK,oBAAoB,EAAED,MAAMU,MAAM,CAAC,EAAE,CAAC;QACvD;YACE,OAAO,GAAGT,KAAK,EAAE,EAAED,MAAMW,OAAO,EAAE;IACtC;AACF;AAEA,kEAAkE,GAClE,OAAO,SAASC,iBAAiBC,KAAiC;IAChE,IAAIA,iBAAiBf,EAAEgB,QAAQ,EAAE,OAAOD,MAAME,MAAM,CAACC,GAAG,CAACjB;IACzD,OAAO;QAACc,iBAAiBI,QAAQJ,MAAMF,OAAO,GAAGO,OAAOL;KAAO;AACjE"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "argos-harness",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Argos — global-first CLI harness for setting up and managing Claude Code across your projects",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Navori-Technologies/argos.git"
+  },
+  "homepage": "https://github.com/Navori-Technologies/argos#readme",
+  "bugs": {
+    "url": "https://github.com/Navori-Technologies/argos/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cli",
+    "ai",
+    "harness",
+    "agents",
+    "anthropic"
+  ],
+  "bin": {
+    "argos": "./bin/argos.js"
+  },
+  "files": [
+    "dist",
+    "assets",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "citty": "^0.2.2",
+    "picocolors": "^1.1.1",
+    "zod": "^4.4.3"
+  }
+}