argos-harness 0.1.0

package/dist/lib/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/lib/git.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,iFAAiF;IACjF,UAAU,EAAE,OAAO,CAAC;CACrB;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAUxD;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAexE"}

package/dist/lib/git.js

@@ -0,0 +1,79 @@
+import { execFileSync } from "node:child_process";
+function isSpawnEnoent(err) {
+    return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+/**
+ * Check whether `cwd` sits inside a git working tree, distinguishing a real
+ * infra problem (the `git` binary itself is missing) from the normal "not a
+ * repo" case — collapsing both into one message hides a broken environment
+ * behind what looks like an ordinary state.
+ */ export function checkGitRepo(cwd) {
+    try {
+        execFileSync("git", [
+            "rev-parse",
+            "--is-inside-work-tree"
+        ], {
+            cwd,
+            stdio: [
+                "ignore",
+                "pipe",
+                "ignore"
+            ]
+        });
+        return {
+            isRepo: true,
+            gitMissing: false
+        };
+    } catch (err) {
+        return {
+            isRepo: false,
+            gitMissing: isSpawnEnoent(err)
+        };
+    }
+}
+/** True when `cwd` sits inside a git working tree. */ export function isGitRepo(cwd) {
+    return checkGitRepo(cwd).isRepo;
+}
+/** `git remote get-url origin`, or null when there is no such remote. */ export function getRemoteOriginUrl(cwd) {
+    try {
+        return execFileSync("git", [
+            "remote",
+            "get-url",
+            "origin"
+        ], {
+            cwd,
+            stdio: [
+                "ignore",
+                "pipe",
+                "ignore"
+            ],
+            encoding: "utf-8"
+        }).trim();
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Derive a short identity token from a git remote URL, e.g.
+ * `https://github.com/bonum/repo.git` or `git@github.com:bonum/repo.git`
+ * both become `github.com-bonum` (host + first path segment, which is the
+ * org/user account on every common host — GitHub, GitLab, Bitbucket).
+ *
+ * Returns null when the URL doesn't match either the scp-like SSH form
+ * (`user@host:path`) or a URL form (`scheme://host/path`).
+ */ export function parseIdentityFromRemote(remoteUrl) {
+    // scp-like SSH form: git@host:org/repo(.git)?
+    const scpMatch = /^[^@/]+@([^:/]+):([^/]+)\//.exec(remoteUrl);
+    if (scpMatch) return `${scpMatch[1]}-${scpMatch[2]}`;
+    // URL form: ssh://git@host/org/repo(.git)?, https://host/org/repo(.git)?
+    try {
+        const url = new URL(remoteUrl);
+        const segments = url.pathname.split("/").filter(Boolean);
+        if (segments.length >= 1 && url.hostname) return `${url.hostname}-${segments[0]}`;
+    } catch  {
+    // not a parseable URL — give up
+    }
+    return null;
+}
+
+//# sourceMappingURL=git.js.map

package/dist/lib/git.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/git.ts"],"sourcesContent":["import { execFileSync } from \"node:child_process\";\n\nexport interface GitCheckResult {\n  isRepo: boolean;\n  /** True when `git` itself could not be spawned (not installed / not on PATH). */\n  gitMissing: boolean;\n}\n\nfunction isSpawnEnoent(err: unknown): boolean {\n  return typeof err === \"object\" && err !== null && (err as { code?: unknown }).code === \"ENOENT\";\n}\n\n/**\n * Check whether `cwd` sits inside a git working tree, distinguishing a real\n * infra problem (the `git` binary itself is missing) from the normal \"not a\n * repo\" case — collapsing both into one message hides a broken environment\n * behind what looks like an ordinary state.\n */\nexport function checkGitRepo(cwd: string): GitCheckResult {\n  try {\n    execFileSync(\"git\", [\"rev-parse\", \"--is-inside-work-tree\"], {\n      cwd,\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n    });\n    return { isRepo: true, gitMissing: false };\n  } catch (err) {\n    return { isRepo: false, gitMissing: isSpawnEnoent(err) };\n  }\n}\n\n/** True when `cwd` sits inside a git working tree. */\nexport function isGitRepo(cwd: string): boolean {\n  return checkGitRepo(cwd).isRepo;\n}\n\n/** `git remote get-url origin`, or null when there is no such remote. */\nexport function getRemoteOriginUrl(cwd: string): string | null {\n  try {\n    return execFileSync(\"git\", [\"remote\", \"get-url\", \"origin\"], {\n      cwd,\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n      encoding: \"utf-8\",\n    }).trim();\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Derive a short identity token from a git remote URL, e.g.\n * `https://github.com/bonum/repo.git` or `git@github.com:bonum/repo.git`\n * both become `github.com-bonum` (host + first path segment, which is the\n * org/user account on every common host — GitHub, GitLab, Bitbucket).\n *\n * Returns null when the URL doesn't match either the scp-like SSH form\n * (`user@host:path`) or a URL form (`scheme://host/path`).\n */\nexport function parseIdentityFromRemote(remoteUrl: string): string | null {\n  // scp-like SSH form: git@host:org/repo(.git)?\n  const scpMatch = /^[^@/]+@([^:/]+):([^/]+)\\//.exec(remoteUrl);\n  if (scpMatch) return `${scpMatch[1]}-${scpMatch[2]}`;\n\n  // URL form: ssh://git@host/org/repo(.git)?, https://host/org/repo(.git)?\n  try {\n    const url = new URL(remoteUrl);\n    const segments = url.pathname.split(\"/\").filter(Boolean);\n    if (segments.length >= 1 && url.hostname) return `${url.hostname}-${segments[0]}`;\n  } catch {\n    // not a parseable URL — give up\n  }\n\n  return null;\n}\n"],"names":["execFileSync","isSpawnEnoent","err","code","checkGitRepo","cwd","stdio","isRepo","gitMissing","isGitRepo","getRemoteOriginUrl","encoding","trim","parseIdentityFromRemote","remoteUrl","scpMatch","exec","url","URL","segments","pathname","split","filter","Boolean","length","hostname"],"mappings":"AAAA,SAASA,YAAY,QAAQ,qBAAqB;AAQlD,SAASC,cAAcC,GAAY;IACjC,OAAO,OAAOA,QAAQ,YAAYA,QAAQ,QAAQ,AAACA,IAA2BC,IAAI,KAAK;AACzF;AAEA;;;;;CAKC,GACD,OAAO,SAASC,aAAaC,GAAW;IACtC,IAAI;QACFL,aAAa,OAAO;YAAC;YAAa;SAAwB,EAAE;YAC1DK;YACAC,OAAO;gBAAC;gBAAU;gBAAQ;aAAS;QACrC;QACA,OAAO;YAAEC,QAAQ;YAAMC,YAAY;QAAM;IAC3C,EAAE,OAAON,KAAK;QACZ,OAAO;YAAEK,QAAQ;YAAOC,YAAYP,cAAcC;QAAK;IACzD;AACF;AAEA,oDAAoD,GACpD,OAAO,SAASO,UAAUJ,GAAW;IACnC,OAAOD,aAAaC,KAAKE,MAAM;AACjC;AAEA,uEAAuE,GACvE,OAAO,SAASG,mBAAmBL,GAAW;IAC5C,IAAI;QACF,OAAOL,aAAa,OAAO;YAAC;YAAU;YAAW;SAAS,EAAE;YAC1DK;YACAC,OAAO;gBAAC;gBAAU;gBAAQ;aAAS;YACnCK,UAAU;QACZ,GAAGC,IAAI;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASC,wBAAwBC,SAAiB;IACvD,8CAA8C;IAC9C,MAAMC,WAAW,6BAA6BC,IAAI,CAACF;IACnD,IAAIC,UAAU,OAAO,GAAGA,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAEA,QAAQ,CAAC,EAAE,EAAE;IAEpD,yEAAyE;IACzE,IAAI;QACF,MAAME,MAAM,IAAIC,IAAIJ;QACpB,MAAMK,WAAWF,IAAIG,QAAQ,CAACC,KAAK,CAAC,KAAKC,MAAM,CAACC;QAChD,IAAIJ,SAASK,MAAM,IAAI,KAAKP,IAAIQ,QAAQ,EAAE,OAAO,GAAGR,IAAIQ,QAAQ,CAAC,CAAC,EAAEN,QAAQ,CAAC,EAAE,EAAE;IACnF,EAAE,OAAM;IACN,gCAAgC;IAClC;IAEA,OAAO;AACT"}

package/dist/lib/managed-files.d.ts

@@ -0,0 +1,35 @@
+export declare const SHELL_VERSION_PLACEHOLDER = "__ARGOS_VERSION__";
+/** True when `content` carries an `argos:file` ownership marker (any version). */
+export declare function hasArgosFileMarker(content: string): boolean;
+/**
+ * Insert the `argos:file` marker immediately after the leading YAML
+ * frontmatter block, so the frontmatter stays the very first thing in the
+ * file (required by tools that parse it, e.g. Claude Code agents/skills).
+ * Falls back to prefixing the marker when there is no frontmatter.
+ */
+export declare function withFileMarker(content: string, version: string): string;
+export type FileStatus = "created" | "updated" | "unchanged" | "skipped-foreign";
+/**
+ * Write a full-file Argos-owned asset (agent, skill, output-style) to
+ * `destPath`, honoring the ownership marker policy:
+ * - absent → write it (created)
+ * - present with the argos:file marker → overwrite (updated/unchanged)
+ * - present without the marker (foreign) → never touch it (skipped-foreign)
+ */
+export declare function writeManagedFile(destPath: string, sourceContent: string, version: string): FileStatus;
+/** True when `content` carries a shell-comment `# argos:file` ownership marker (any version). */
+export declare function hasArgosShellFileMarker(content: string): boolean;
+/**
+ * Write a full-file Argos-owned shell script (a hook) to `destPath`.
+ * `sourceContent` must already contain the literal
+ * `# argos:file v="__ARGOS_VERSION__"` marker line as the first line after
+ * the shebang (see assets/hooks/*.sh) — this stamps it with the real
+ * `version` (simple placeholder replace, no structural splicing needed since
+ * the marker line is already in the right place in the source) and chmods
+ * the result executable (0o755). Same ownership policy as `writeManagedFile`:
+ * - absent → write it (created)
+ * - present with the shell marker → overwrite (updated/unchanged)
+ * - present without the marker (foreign) → never touch it (skipped-foreign)
+ */
+export declare function writeManagedShellFile(destPath: string, sourceContent: string, version: string): FileStatus;
+//# sourceMappingURL=managed-files.d.ts.map

package/dist/lib/managed-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-files.d.ts","sourceRoot":"","sources":["../../src/lib/managed-files.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAM7D,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAOvE;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,iBAAiB,CAAC;AAEjF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CAerG;AAED,iGAAiG;AACjG,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CA6B1G"}

package/dist/lib/managed-files.js

@@ -0,0 +1,97 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+const MARKER_PREFIX = '<!-- argos:file v="';
+const FRONTMATTER_RE = /^---\n[\s\S]*?\n---\n/;
+// Shell assets (hooks) can't carry the HTML-comment marker above (`.sh` has
+// no such syntax) or YAML frontmatter, so they get their own shell-comment
+// marker form: `# argos:file v="<version>"`, hardcoded as the literal first
+// line after the shebang in the asset source (see assets/hooks/*.sh) with a
+// `SHELL_VERSION_PLACEHOLDER` token in place of the version — stamped with
+// the real version at install time by `writeManagedShellFile`.
+const SHELL_MARKER_PREFIX = '# argos:file v="';
+export const SHELL_VERSION_PLACEHOLDER = "__ARGOS_VERSION__";
+function fileMarker(version) {
+    return `${MARKER_PREFIX}${version}" -->`;
+}
+/** True when `content` carries an `argos:file` ownership marker (any version). */ export function hasArgosFileMarker(content) {
+    return content.includes(MARKER_PREFIX);
+}
+/**
+ * Insert the `argos:file` marker immediately after the leading YAML
+ * frontmatter block, so the frontmatter stays the very first thing in the
+ * file (required by tools that parse it, e.g. Claude Code agents/skills).
+ * Falls back to prefixing the marker when there is no frontmatter.
+ */ export function withFileMarker(content, version) {
+    const marker = fileMarker(version);
+    const fmMatch = FRONTMATTER_RE.exec(content);
+    if (!fmMatch) return `${marker}\n\n${content}`;
+    const frontmatter = fmMatch[0];
+    const rest = content.slice(frontmatter.length);
+    return `${frontmatter}${marker}\n${rest}`;
+}
+/**
+ * Write a full-file Argos-owned asset (agent, skill, output-style) to
+ * `destPath`, honoring the ownership marker policy:
+ * - absent → write it (created)
+ * - present with the argos:file marker → overwrite (updated/unchanged)
+ * - present without the marker (foreign) → never touch it (skipped-foreign)
+ */ export function writeManagedFile(destPath, sourceContent, version) {
+    const finalContent = withFileMarker(sourceContent, version);
+    if (!existsSync(destPath)) {
+        mkdirSync(dirname(destPath), {
+            recursive: true
+        });
+        writeFileAtomic(destPath, finalContent);
+        return "created";
+    }
+    const current = readFileSync(destPath, "utf-8");
+    if (!hasArgosFileMarker(current)) return "skipped-foreign";
+    if (current === finalContent) return "unchanged";
+    writeFileAtomic(destPath, finalContent);
+    return "updated";
+}
+/** True when `content` carries a shell-comment `# argos:file` ownership marker (any version). */ export function hasArgosShellFileMarker(content) {
+    return content.includes(SHELL_MARKER_PREFIX);
+}
+/**
+ * Write a full-file Argos-owned shell script (a hook) to `destPath`.
+ * `sourceContent` must already contain the literal
+ * `# argos:file v="__ARGOS_VERSION__"` marker line as the first line after
+ * the shebang (see assets/hooks/*.sh) — this stamps it with the real
+ * `version` (simple placeholder replace, no structural splicing needed since
+ * the marker line is already in the right place in the source) and chmods
+ * the result executable (0o755). Same ownership policy as `writeManagedFile`:
+ * - absent → write it (created)
+ * - present with the shell marker → overwrite (updated/unchanged)
+ * - present without the marker (foreign) → never touch it (skipped-foreign)
+ */ export function writeManagedShellFile(destPath, sourceContent, version) {
+    const finalContent = sourceContent.replaceAll(SHELL_VERSION_PLACEHOLDER, version);
+    if (!existsSync(destPath)) {
+        mkdirSync(dirname(destPath), {
+            recursive: true
+        });
+        writeFileAtomic(destPath, finalContent, 0o755);
+        return "created";
+    }
+    const current = readFileSync(destPath, "utf-8");
+    if (!hasArgosShellFileMarker(current)) return "skipped-foreign";
+    if (current === finalContent) {
+        // Re-assert the executable bit even when content is unchanged, in case
+        // it drifted (e.g. a user ran `chmod -x` on it by hand). Best-effort:
+        // hooks are invoked as `bash "<path>"` (see lib/settings-merge.ts), so
+        // the executable bit is inert for Claude Code's own purposes — a chmod
+        // failure here (e.g. EPERM on an unusual filesystem) shouldn't fail the
+        // whole `argos init` run over a cosmetic permission bit.
+        try {
+            chmodSync(destPath, 0o755);
+        } catch  {
+        // Swallowed on purpose — see comment above.
+        }
+        return "unchanged";
+    }
+    writeFileAtomic(destPath, finalContent, 0o755);
+    return "updated";
+}
+
+//# sourceMappingURL=managed-files.js.map

package/dist/lib/managed-files.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/managed-files.ts"],"sourcesContent":["import { chmodSync, existsSync, mkdirSync, readFileSync } from \"node:fs\";\nimport { dirname } from \"node:path\";\nimport { writeFileAtomic } from \"./atomic-write.js\";\n\nconst MARKER_PREFIX = '<!-- argos:file v=\"';\nconst FRONTMATTER_RE = /^---\\n[\\s\\S]*?\\n---\\n/;\n\n// Shell assets (hooks) can't carry the HTML-comment marker above (`.sh` has\n// no such syntax) or YAML frontmatter, so they get their own shell-comment\n// marker form: `# argos:file v=\"<version>\"`, hardcoded as the literal first\n// line after the shebang in the asset source (see assets/hooks/*.sh) with a\n// `SHELL_VERSION_PLACEHOLDER` token in place of the version — stamped with\n// the real version at install time by `writeManagedShellFile`.\nconst SHELL_MARKER_PREFIX = '# argos:file v=\"';\nexport const SHELL_VERSION_PLACEHOLDER = \"__ARGOS_VERSION__\";\n\nfunction fileMarker(version: string): string {\n  return `${MARKER_PREFIX}${version}\" -->`;\n}\n\n/** True when `content` carries an `argos:file` ownership marker (any version). */\nexport function hasArgosFileMarker(content: string): boolean {\n  return content.includes(MARKER_PREFIX);\n}\n\n/**\n * Insert the `argos:file` marker immediately after the leading YAML\n * frontmatter block, so the frontmatter stays the very first thing in the\n * file (required by tools that parse it, e.g. Claude Code agents/skills).\n * Falls back to prefixing the marker when there is no frontmatter.\n */\nexport function withFileMarker(content: string, version: string): string {\n  const marker = fileMarker(version);\n  const fmMatch = FRONTMATTER_RE.exec(content);\n  if (!fmMatch) return `${marker}\\n\\n${content}`;\n  const frontmatter = fmMatch[0];\n  const rest = content.slice(frontmatter.length);\n  return `${frontmatter}${marker}\\n${rest}`;\n}\n\nexport type FileStatus = \"created\" | \"updated\" | \"unchanged\" | \"skipped-foreign\";\n\n/**\n * Write a full-file Argos-owned asset (agent, skill, output-style) to\n * `destPath`, honoring the ownership marker policy:\n * - absent → write it (created)\n * - present with the argos:file marker → overwrite (updated/unchanged)\n * - present without the marker (foreign) → never touch it (skipped-foreign)\n */\nexport function writeManagedFile(destPath: string, sourceContent: string, version: string): FileStatus {\n  const finalContent = withFileMarker(sourceContent, version);\n\n  if (!existsSync(destPath)) {\n    mkdirSync(dirname(destPath), { recursive: true });\n    writeFileAtomic(destPath, finalContent);\n    return \"created\";\n  }\n\n  const current = readFileSync(destPath, \"utf-8\");\n  if (!hasArgosFileMarker(current)) return \"skipped-foreign\";\n  if (current === finalContent) return \"unchanged\";\n\n  writeFileAtomic(destPath, finalContent);\n  return \"updated\";\n}\n\n/** True when `content` carries a shell-comment `# argos:file` ownership marker (any version). */\nexport function hasArgosShellFileMarker(content: string): boolean {\n  return content.includes(SHELL_MARKER_PREFIX);\n}\n\n/**\n * Write a full-file Argos-owned shell script (a hook) to `destPath`.\n * `sourceContent` must already contain the literal\n * `# argos:file v=\"__ARGOS_VERSION__\"` marker line as the first line after\n * the shebang (see assets/hooks/*.sh) — this stamps it with the real\n * `version` (simple placeholder replace, no structural splicing needed since\n * the marker line is already in the right place in the source) and chmods\n * the result executable (0o755). Same ownership policy as `writeManagedFile`:\n * - absent → write it (created)\n * - present with the shell marker → overwrite (updated/unchanged)\n * - present without the marker (foreign) → never touch it (skipped-foreign)\n */\nexport function writeManagedShellFile(destPath: string, sourceContent: string, version: string): FileStatus {\n  const finalContent = sourceContent.replaceAll(SHELL_VERSION_PLACEHOLDER, version);\n\n  if (!existsSync(destPath)) {\n    mkdirSync(dirname(destPath), { recursive: true });\n    writeFileAtomic(destPath, finalContent, 0o755);\n    return \"created\";\n  }\n\n  const current = readFileSync(destPath, \"utf-8\");\n  if (!hasArgosShellFileMarker(current)) return \"skipped-foreign\";\n\n  if (current === finalContent) {\n    // Re-assert the executable bit even when content is unchanged, in case\n    // it drifted (e.g. a user ran `chmod -x` on it by hand). Best-effort:\n    // hooks are invoked as `bash \"<path>\"` (see lib/settings-merge.ts), so\n    // the executable bit is inert for Claude Code's own purposes — a chmod\n    // failure here (e.g. EPERM on an unusual filesystem) shouldn't fail the\n    // whole `argos init` run over a cosmetic permission bit.\n    try {\n      chmodSync(destPath, 0o755);\n    } catch {\n      // Swallowed on purpose — see comment above.\n    }\n    return \"unchanged\";\n  }\n\n  writeFileAtomic(destPath, finalContent, 0o755);\n  return \"updated\";\n}\n"],"names":["chmodSync","existsSync","mkdirSync","readFileSync","dirname","writeFileAtomic","MARKER_PREFIX","FRONTMATTER_RE","SHELL_MARKER_PREFIX","SHELL_VERSION_PLACEHOLDER","fileMarker","version","hasArgosFileMarker","content","includes","withFileMarker","marker","fmMatch","exec","frontmatter","rest","slice","length","writeManagedFile","destPath","sourceContent","finalContent","recursive","current","hasArgosShellFileMarker","writeManagedShellFile","replaceAll"],"mappings":"AAAA,SAASA,SAAS,EAAEC,UAAU,EAAEC,SAAS,EAAEC,YAAY,QAAQ,UAAU;AACzE,SAASC,OAAO,QAAQ,YAAY;AACpC,SAASC,eAAe,QAAQ,oBAAoB;AAEpD,MAAMC,gBAAgB;AACtB,MAAMC,iBAAiB;AAEvB,4EAA4E;AAC5E,2EAA2E;AAC3E,4EAA4E;AAC5E,4EAA4E;AAC5E,2EAA2E;AAC3E,+DAA+D;AAC/D,MAAMC,sBAAsB;AAC5B,OAAO,MAAMC,4BAA4B,oBAAoB;AAE7D,SAASC,WAAWC,OAAe;IACjC,OAAO,GAAGL,gBAAgBK,QAAQ,KAAK,CAAC;AAC1C;AAEA,gFAAgF,GAChF,OAAO,SAASC,mBAAmBC,OAAe;IAChD,OAAOA,QAAQC,QAAQ,CAACR;AAC1B;AAEA;;;;;CAKC,GACD,OAAO,SAASS,eAAeF,OAAe,EAAEF,OAAe;IAC7D,MAAMK,SAASN,WAAWC;IAC1B,MAAMM,UAAUV,eAAeW,IAAI,CAACL;IACpC,IAAI,CAACI,SAAS,OAAO,GAAGD,OAAO,IAAI,EAAEH,SAAS;IAC9C,MAAMM,cAAcF,OAAO,CAAC,EAAE;IAC9B,MAAMG,OAAOP,QAAQQ,KAAK,CAACF,YAAYG,MAAM;IAC7C,OAAO,GAAGH,cAAcH,OAAO,EAAE,EAAEI,MAAM;AAC3C;AAIA;;;;;;CAMC,GACD,OAAO,SAASG,iBAAiBC,QAAgB,EAAEC,aAAqB,EAAEd,OAAe;IACvF,MAAMe,eAAeX,eAAeU,eAAed;IAEnD,IAAI,CAACV,WAAWuB,WAAW;QACzBtB,UAAUE,QAAQoB,WAAW;YAAEG,WAAW;QAAK;QAC/CtB,gBAAgBmB,UAAUE;QAC1B,OAAO;IACT;IAEA,MAAME,UAAUzB,aAAaqB,UAAU;IACvC,IAAI,CAACZ,mBAAmBgB,UAAU,OAAO;IACzC,IAAIA,YAAYF,cAAc,OAAO;IAErCrB,gBAAgBmB,UAAUE;IAC1B,OAAO;AACT;AAEA,+FAA+F,GAC/F,OAAO,SAASG,wBAAwBhB,OAAe;IACrD,OAAOA,QAAQC,QAAQ,CAACN;AAC1B;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASsB,sBAAsBN,QAAgB,EAAEC,aAAqB,EAAEd,OAAe;IAC5F,MAAMe,eAAeD,cAAcM,UAAU,CAACtB,2BAA2BE;IAEzE,IAAI,CAACV,WAAWuB,WAAW;QACzBtB,UAAUE,QAAQoB,WAAW;YAAEG,WAAW;QAAK;QAC/CtB,gBAAgBmB,UAAUE,cAAc;QACxC,OAAO;IACT;IAEA,MAAME,UAAUzB,aAAaqB,UAAU;IACvC,IAAI,CAACK,wBAAwBD,UAAU,OAAO;IAE9C,IAAIA,YAAYF,cAAc;QAC5B,uEAAuE;QACvE,sEAAsE;QACtE,uEAAuE;QACvE,uEAAuE;QACvE,wEAAwE;QACxE,yDAAyD;QACzD,IAAI;YACF1B,UAAUwB,UAAU;QACtB,EAAE,OAAM;QACN,4CAA4C;QAC9C;QACA,OAAO;IACT;IAEAnB,gBAAgBmB,UAAUE,cAAc;IACxC,OAAO;AACT"}

package/dist/lib/markers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Argos managed-block primitives for Markdown files.
+ *
+ * Block format:
+ *   <!-- argos:managed id="<id>" v="<version>" -->
+ *   ...content...
+ *   <!-- argos:managed end id="<id>" -->
+ *
+ * HARD RULE: never modify anything outside argos markers. Foreign file
+ * content (anything the user wrote, or another tool's own markers) is
+ * untouchable — every function here only reads/writes inside its own
+ * `id`'s block boundaries.
+ *
+ * KNOWN LIMITATION: ownership here is purely text-pattern based — anything
+ * that quotes the exact marker comment text (e.g. `<!-- argos:managed id="x"
+ * v="1" -->`) inside otherwise-foreign content is indistinguishable from a
+ * real Argos block and can be spoofed or accidentally matched. This is a
+ * deliberate tradeoff for staying dependency-free; the mitigation is that
+ * every mutation site backs up the file before touching it (see
+ * `createBackup` usage in `init.ts`/`adopt.ts`), so a bad match is always
+ * recoverable.
+ */
+export interface InjectBlockResult {
+    content: string;
+    /** Count of duplicate blocks (beyond the first) removed by this call. */
+    healedDuplicates: number;
+}
+/**
+ * Insert or update a managed block by id, self-healing duplicate blocks left
+ * behind by crash residue (e.g. a process killed mid-write that appended a
+ * second block instead of replacing the first).
+ * - No existing block with this id → append at the end, separated by a
+ *   blank line from whatever precedes it.
+ * - One or more existing blocks with this id → replace the FIRST one's open
+ *   marker (version) and body in place, and remove every other block sharing
+ *   the id; everything else before/after is untouched.
+ */
+export declare function injectBlockDetailed(fileContent: string, id: string, version: string, content: string): InjectBlockResult;
+/** String-only convenience wrapper over `injectBlockDetailed` for existing call sites. */
+export declare function injectBlock(fileContent: string, id: string, version: string, content: string): string;
+/**
+ * Remove a managed block by id. No-op if the block does not exist.
+ * Also removes a single trailing newline so removal doesn't leave a
+ * double-blank line behind.
+ */
+export declare function removeBlock(fileContent: string, id: string): string;
+export interface ListedBlock {
+    id: string;
+    version: string | null;
+}
+/** Enumerate every managed block found in `fileContent`, in document order. */
+export declare function listBlocks(fileContent: string): ListedBlock[];
+/**
+ * Ids of every block whose OPEN marker in `fileContent` has no matching
+ * CLOSE marker anywhere in the file — a dangling/unclosed block, usually
+ * crash residue or hand-edited corruption. `listBlocks` alone can't answer
+ * this: it only scans for open markers and doesn't verify a close exists
+ * (see its implementation above), which is exactly why a dangling block
+ * still shows up as "present" there. Callers that need to remove blocks
+ * (see `removeBlock`) must guard against this: a dangling id makes
+ * `removeBlock` a no-op forever, since there is nothing valid to cut.
+ */
+export declare function listDanglingBlockIds(fileContent: string): string[];
+//# sourceMappingURL=markers.d.ts.map

package/dist/lib/markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markers.d.ts","sourceRoot":"","sources":["../../src/lib/markers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAuEH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,iBAAiB,CA2BnB;AAED,0FAA0F;AAC1F,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAErG;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAcnE;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE,CAU7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAOlE"}

package/dist/lib/markers.js

@@ -0,0 +1,157 @@
+/**
+ * Argos managed-block primitives for Markdown files.
+ *
+ * Block format:
+ *   <!-- argos:managed id="<id>" v="<version>" -->
+ *   ...content...
+ *   <!-- argos:managed end id="<id>" -->
+ *
+ * HARD RULE: never modify anything outside argos markers. Foreign file
+ * content (anything the user wrote, or another tool's own markers) is
+ * untouchable — every function here only reads/writes inside its own
+ * `id`'s block boundaries.
+ *
+ * KNOWN LIMITATION: ownership here is purely text-pattern based — anything
+ * that quotes the exact marker comment text (e.g. `<!-- argos:managed id="x"
+ * v="1" -->`) inside otherwise-foreign content is indistinguishable from a
+ * real Argos block and can be spoofed or accidentally matched. This is a
+ * deliberate tradeoff for staying dependency-free; the mitigation is that
+ * every mutation site backs up the file before touching it (see
+ * `createBackup` usage in `init.ts`/`adopt.ts`), so a bad match is always
+ * recoverable.
+ */ const OPEN_PREFIX = '<!-- argos:managed id="';
+const CLOSE_PREFIX = '<!-- argos:managed end id="';
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function openMarker(id, version) {
+    return `<!-- argos:managed id="${id}" v="${version}" -->`;
+}
+function closeMarker(id) {
+    return `${CLOSE_PREFIX}${id}" -->`;
+}
+/** Find the first block with `id` starting at or after `fromIndex`. */ function findBlockFrom(fileContent, id, fromIndex) {
+    const openRegex = new RegExp(`${escapeRegex(OPEN_PREFIX)}${escapeRegex(id)}"(?:\\s+v="([^"]*)")?\\s*-->`, "g");
+    openRegex.lastIndex = fromIndex;
+    const openMatch = openRegex.exec(fileContent);
+    if (!openMatch) return null;
+    const close = closeMarker(id);
+    const openEnd = openMatch.index + openMatch[0].length;
+    const closeStart = fileContent.indexOf(close, openEnd);
+    if (closeStart < 0) return null;
+    const rawContent = fileContent.slice(openEnd, closeStart);
+    const content = rawContent.replace(/^\n/, "").replace(/\n$/, "");
+    return {
+        openStart: openMatch.index,
+        openEnd,
+        closeStart,
+        closeEnd: closeStart + close.length,
+        version: openMatch[1] ?? null,
+        content
+    };
+}
+function findBlock(fileContent, id) {
+    return findBlockFrom(fileContent, id, 0);
+}
+/** Find every block with `id`, in document order. Duplicates included. */ function findAllBlocks(fileContent, id) {
+    const blocks = [];
+    let fromIndex = 0;
+    for(;;){
+        const match = findBlockFrom(fileContent, id, fromIndex);
+        if (!match) break;
+        blocks.push(match);
+        fromIndex = match.closeEnd;
+    }
+    return blocks;
+}
+/**
+ * Insert or update a managed block by id, self-healing duplicate blocks left
+ * behind by crash residue (e.g. a process killed mid-write that appended a
+ * second block instead of replacing the first).
+ * - No existing block with this id → append at the end, separated by a
+ *   blank line from whatever precedes it.
+ * - One or more existing blocks with this id → replace the FIRST one's open
+ *   marker (version) and body in place, and remove every other block sharing
+ *   the id; everything else before/after is untouched.
+ */ export function injectBlockDetailed(fileContent, id, version, content) {
+    const block = `${openMarker(id, version)}\n${content}\n${closeMarker(id)}`;
+    const matches = findAllBlocks(fileContent, id);
+    if (matches.length === 0) {
+        if (fileContent.length === 0) return {
+            content: `${block}\n`,
+            healedDuplicates: 0
+        };
+        const sep = fileContent.endsWith("\n\n") ? "" : fileContent.endsWith("\n") ? "\n" : "\n\n";
+        return {
+            content: `${fileContent}${sep}${block}\n`,
+            healedDuplicates: 0
+        };
+    }
+    const first = matches[0];
+    // Drop every duplicate after the first, from the end backwards so offsets
+    // computed against the original `fileContent` (including `first`'s, which
+    // always sit before every duplicate) stay valid throughout.
+    let healed = fileContent;
+    for(let i = matches.length - 1; i >= 1; i--){
+        const dup = matches[i];
+        let endCut = dup.closeEnd;
+        if (healed[endCut] === "\n") endCut++;
+        let startCut = dup.openStart;
+        if (healed.slice(0, startCut).endsWith("\n\n")) startCut -= 1;
+        healed = healed.slice(0, startCut) + healed.slice(endCut);
+    }
+    const result = healed.slice(0, first.openStart) + block + healed.slice(first.closeEnd);
+    return {
+        content: result,
+        healedDuplicates: matches.length - 1
+    };
+}
+/** String-only convenience wrapper over `injectBlockDetailed` for existing call sites. */ export function injectBlock(fileContent, id, version, content) {
+    return injectBlockDetailed(fileContent, id, version, content).content;
+}
+/**
+ * Remove a managed block by id. No-op if the block does not exist.
+ * Also removes a single trailing newline so removal doesn't leave a
+ * double-blank line behind.
+ */ export function removeBlock(fileContent, id) {
+    const match = findBlock(fileContent, id);
+    if (!match) return fileContent;
+    let endCut = match.closeEnd;
+    if (fileContent[endCut] === "\n") endCut++;
+    // Collapse the blank-line separator injectBlock adds before an appended
+    // block, so removing a cleanly-appended block restores the original bytes
+    // instead of leaving a stray blank line behind.
+    let startCut = match.openStart;
+    if (fileContent.slice(0, startCut).endsWith("\n\n")) startCut -= 1;
+    return fileContent.slice(0, startCut) + fileContent.slice(endCut);
+}
+/** Enumerate every managed block found in `fileContent`, in document order. */ export function listBlocks(fileContent) {
+    const openRegex = new RegExp(`${escapeRegex(OPEN_PREFIX)}([^"]+)"(?:\\s+v="([^"]*)")?\\s*-->`, "g");
+    const blocks = [];
+    for (const m of fileContent.matchAll(openRegex)){
+        blocks.push({
+            id: m[1],
+            version: m[2] ?? null
+        });
+    }
+    return blocks;
+}
+/**
+ * Ids of every block whose OPEN marker in `fileContent` has no matching
+ * CLOSE marker anywhere in the file — a dangling/unclosed block, usually
+ * crash residue or hand-edited corruption. `listBlocks` alone can't answer
+ * this: it only scans for open markers and doesn't verify a close exists
+ * (see its implementation above), which is exactly why a dangling block
+ * still shows up as "present" there. Callers that need to remove blocks
+ * (see `removeBlock`) must guard against this: a dangling id makes
+ * `removeBlock` a no-op forever, since there is nothing valid to cut.
+ */ export function listDanglingBlockIds(fileContent) {
+    const ids = new Set(listBlocks(fileContent).map((b)=>b.id));
+    const dangling = [];
+    for (const id of ids){
+        if (findBlock(fileContent, id) === null) dangling.push(id);
+    }
+    return dangling;
+}
+
+//# sourceMappingURL=markers.js.map

package/dist/lib/markers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/markers.ts"],"sourcesContent":["/**\n * Argos managed-block primitives for Markdown files.\n *\n * Block format:\n *   <!-- argos:managed id=\"<id>\" v=\"<version>\" -->\n *   ...content...\n *   <!-- argos:managed end id=\"<id>\" -->\n *\n * HARD RULE: never modify anything outside argos markers. Foreign file\n * content (anything the user wrote, or another tool's own markers) is\n * untouchable — every function here only reads/writes inside its own\n * `id`'s block boundaries.\n *\n * KNOWN LIMITATION: ownership here is purely text-pattern based — anything\n * that quotes the exact marker comment text (e.g. `<!-- argos:managed id=\"x\"\n * v=\"1\" -->`) inside otherwise-foreign content is indistinguishable from a\n * real Argos block and can be spoofed or accidentally matched. This is a\n * deliberate tradeoff for staying dependency-free; the mitigation is that\n * every mutation site backs up the file before touching it (see\n * `createBackup` usage in `init.ts`/`adopt.ts`), so a bad match is always\n * recoverable.\n */\n\nconst OPEN_PREFIX = '<!-- argos:managed id=\"';\nconst CLOSE_PREFIX = '<!-- argos:managed end id=\"';\n\nfunction escapeRegex(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction openMarker(id: string, version: string): string {\n  return `<!-- argos:managed id=\"${id}\" v=\"${version}\" -->`;\n}\n\nfunction closeMarker(id: string): string {\n  return `${CLOSE_PREFIX}${id}\" -->`;\n}\n\ninterface BlockMatch {\n  openStart: number;\n  openEnd: number;\n  closeStart: number;\n  closeEnd: number;\n  version: string | null;\n  content: string;\n}\n\n/** Find the first block with `id` starting at or after `fromIndex`. */\nfunction findBlockFrom(fileContent: string, id: string, fromIndex: number): BlockMatch | null {\n  const openRegex = new RegExp(\n    `${escapeRegex(OPEN_PREFIX)}${escapeRegex(id)}\"(?:\\\\s+v=\"([^\"]*)\")?\\\\s*-->`,\n    \"g\",\n  );\n  openRegex.lastIndex = fromIndex;\n  const openMatch = openRegex.exec(fileContent);\n  if (!openMatch) return null;\n\n  const close = closeMarker(id);\n  const openEnd = openMatch.index + openMatch[0].length;\n  const closeStart = fileContent.indexOf(close, openEnd);\n  if (closeStart < 0) return null;\n\n  const rawContent = fileContent.slice(openEnd, closeStart);\n  const content = rawContent.replace(/^\\n/, \"\").replace(/\\n$/, \"\");\n\n  return {\n    openStart: openMatch.index,\n    openEnd,\n    closeStart,\n    closeEnd: closeStart + close.length,\n    version: openMatch[1] ?? null,\n    content,\n  };\n}\n\nfunction findBlock(fileContent: string, id: string): BlockMatch | null {\n  return findBlockFrom(fileContent, id, 0);\n}\n\n/** Find every block with `id`, in document order. Duplicates included. */\nfunction findAllBlocks(fileContent: string, id: string): BlockMatch[] {\n  const blocks: BlockMatch[] = [];\n  let fromIndex = 0;\n  for (;;) {\n    const match = findBlockFrom(fileContent, id, fromIndex);\n    if (!match) break;\n    blocks.push(match);\n    fromIndex = match.closeEnd;\n  }\n  return blocks;\n}\n\nexport interface InjectBlockResult {\n  content: string;\n  /** Count of duplicate blocks (beyond the first) removed by this call. */\n  healedDuplicates: number;\n}\n\n/**\n * Insert or update a managed block by id, self-healing duplicate blocks left\n * behind by crash residue (e.g. a process killed mid-write that appended a\n * second block instead of replacing the first).\n * - No existing block with this id → append at the end, separated by a\n *   blank line from whatever precedes it.\n * - One or more existing blocks with this id → replace the FIRST one's open\n *   marker (version) and body in place, and remove every other block sharing\n *   the id; everything else before/after is untouched.\n */\nexport function injectBlockDetailed(\n  fileContent: string,\n  id: string,\n  version: string,\n  content: string,\n): InjectBlockResult {\n  const block = `${openMarker(id, version)}\\n${content}\\n${closeMarker(id)}`;\n  const matches = findAllBlocks(fileContent, id);\n\n  if (matches.length === 0) {\n    if (fileContent.length === 0) return { content: `${block}\\n`, healedDuplicates: 0 };\n    const sep = fileContent.endsWith(\"\\n\\n\") ? \"\" : fileContent.endsWith(\"\\n\") ? \"\\n\" : \"\\n\\n\";\n    return { content: `${fileContent}${sep}${block}\\n`, healedDuplicates: 0 };\n  }\n\n  const first = matches[0]!;\n\n  // Drop every duplicate after the first, from the end backwards so offsets\n  // computed against the original `fileContent` (including `first`'s, which\n  // always sit before every duplicate) stay valid throughout.\n  let healed = fileContent;\n  for (let i = matches.length - 1; i >= 1; i--) {\n    const dup = matches[i]!;\n    let endCut = dup.closeEnd;\n    if (healed[endCut] === \"\\n\") endCut++;\n    let startCut = dup.openStart;\n    if (healed.slice(0, startCut).endsWith(\"\\n\\n\")) startCut -= 1;\n    healed = healed.slice(0, startCut) + healed.slice(endCut);\n  }\n\n  const result = healed.slice(0, first.openStart) + block + healed.slice(first.closeEnd);\n  return { content: result, healedDuplicates: matches.length - 1 };\n}\n\n/** String-only convenience wrapper over `injectBlockDetailed` for existing call sites. */\nexport function injectBlock(fileContent: string, id: string, version: string, content: string): string {\n  return injectBlockDetailed(fileContent, id, version, content).content;\n}\n\n/**\n * Remove a managed block by id. No-op if the block does not exist.\n * Also removes a single trailing newline so removal doesn't leave a\n * double-blank line behind.\n */\nexport function removeBlock(fileContent: string, id: string): string {\n  const match = findBlock(fileContent, id);\n  if (!match) return fileContent;\n\n  let endCut = match.closeEnd;\n  if (fileContent[endCut] === \"\\n\") endCut++;\n\n  // Collapse the blank-line separator injectBlock adds before an appended\n  // block, so removing a cleanly-appended block restores the original bytes\n  // instead of leaving a stray blank line behind.\n  let startCut = match.openStart;\n  if (fileContent.slice(0, startCut).endsWith(\"\\n\\n\")) startCut -= 1;\n\n  return fileContent.slice(0, startCut) + fileContent.slice(endCut);\n}\n\nexport interface ListedBlock {\n  id: string;\n  version: string | null;\n}\n\n/** Enumerate every managed block found in `fileContent`, in document order. */\nexport function listBlocks(fileContent: string): ListedBlock[] {\n  const openRegex = new RegExp(\n    `${escapeRegex(OPEN_PREFIX)}([^\"]+)\"(?:\\\\s+v=\"([^\"]*)\")?\\\\s*-->`,\n    \"g\",\n  );\n  const blocks: ListedBlock[] = [];\n  for (const m of fileContent.matchAll(openRegex)) {\n    blocks.push({ id: m[1]!, version: m[2] ?? null });\n  }\n  return blocks;\n}\n\n/**\n * Ids of every block whose OPEN marker in `fileContent` has no matching\n * CLOSE marker anywhere in the file — a dangling/unclosed block, usually\n * crash residue or hand-edited corruption. `listBlocks` alone can't answer\n * this: it only scans for open markers and doesn't verify a close exists\n * (see its implementation above), which is exactly why a dangling block\n * still shows up as \"present\" there. Callers that need to remove blocks\n * (see `removeBlock`) must guard against this: a dangling id makes\n * `removeBlock` a no-op forever, since there is nothing valid to cut.\n */\nexport function listDanglingBlockIds(fileContent: string): string[] {\n  const ids = new Set(listBlocks(fileContent).map((b) => b.id));\n  const dangling: string[] = [];\n  for (const id of ids) {\n    if (findBlock(fileContent, id) === null) dangling.push(id);\n  }\n  return dangling;\n}\n"],"names":["OPEN_PREFIX","CLOSE_PREFIX","escapeRegex","value","replace","openMarker","id","version","closeMarker","findBlockFrom","fileContent","fromIndex","openRegex","RegExp","lastIndex","openMatch","exec","close","openEnd","index","length","closeStart","indexOf","rawContent","slice","content","openStart","closeEnd","findBlock","findAllBlocks","blocks","match","push","injectBlockDetailed","block","matches","healedDuplicates","sep","endsWith","first","healed","i","dup","endCut","startCut","result","injectBlock","removeBlock","listBlocks","m","matchAll","listDanglingBlockIds","ids","Set","map","b","dangling"],"mappings":"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"}

package/dist/lib/navori-import.d.ts

@@ -0,0 +1,42 @@
+export declare const NAVORI_CONFIG_FILENAME = "navori.config.json";
+/** Refuse to parse foreign input larger than this — unsanitized host-repo content. */
+export declare const NAVORI_CONFIG_MAX_BYTES = 1000000;
+export interface NaviorImport {
+    name?: string;
+    qualityGate?: {
+        fast?: string;
+        full?: string;
+    };
+    project?: {
+        criticalAreas?: string[];
+        legacyPaths?: string[];
+    };
+    workspace?: string;
+    branchBase?: string;
+    prTarget?: string;
+}
+/**
+ * Discriminated read result for `navori.config.json`. Per "lo no visto se
+ * declara": a present-but-broken file must never collapse silently into
+ * "absent" — callers need to be able to tell the two apart and warn.
+ */
+export type NaviorImportResult = {
+    kind: "absent";
+} | {
+    kind: "imported";
+    data: NaviorImport;
+} | {
+    kind: "unreadable";
+    error: string;
+};
+/** True when a `navori.config.json` exists in `dir` (harness coexistence). */
+export declare function hasNaviorConfig(dir: string): boolean;
+/**
+ * Best-effort import of `navori.config.json` fields Argos also models. This
+ * is a foreign file with its own (unvalidated) shape — read leniently, take
+ * only the fields we recognize, and never throw on unexpected shapes. A
+ * present file that can't be read/parsed/used is reported as `"unreadable"`,
+ * never silently treated as `"absent"`.
+ */
+export declare function readNaviorConfig(dir: string): NaviorImportResult;
+//# sourceMappingURL=navori-import.d.ts.map

package/dist/lib/navori-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navori-import.d.ts","sourceRoot":"","sources":["../../src/lib/navori-import.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAE3D,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,UAAY,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAgDhE"}

package/dist/lib/navori-import.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+export const NAVORI_CONFIG_FILENAME = "navori.config.json";
+/** Refuse to parse foreign input larger than this — unsanitized host-repo content. */ export const NAVORI_CONFIG_MAX_BYTES = 1_000_000;
+/** True when a `navori.config.json` exists in `dir` (harness coexistence). */ export function hasNaviorConfig(dir) {
+    return existsSync(join(dir, NAVORI_CONFIG_FILENAME));
+}
+/**
+ * Best-effort import of `navori.config.json` fields Argos also models. This
+ * is a foreign file with its own (unvalidated) shape — read leniently, take
+ * only the fields we recognize, and never throw on unexpected shapes. A
+ * present file that can't be read/parsed/used is reported as `"unreadable"`,
+ * never silently treated as `"absent"`.
+ */ export function readNaviorConfig(dir) {
+    const path = join(dir, NAVORI_CONFIG_FILENAME);
+    if (!existsSync(path)) return {
+        kind: "absent"
+    };
+    try {
+        if (statSync(path).size > NAVORI_CONFIG_MAX_BYTES) {
+            return {
+                kind: "unreadable",
+                error: `navori.config.json excede el máximo permitido de ${NAVORI_CONFIG_MAX_BYTES} bytes`
+            };
+        }
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof raw !== "object" || raw === null) {
+            return {
+                kind: "unreadable",
+                error: "navori.config.json no es un objeto JSON"
+            };
+        }
+        const obj = raw;
+        const result = {};
+        if (typeof obj.name === "string") result.name = obj.name;
+        if (typeof obj.workspace === "string") result.workspace = obj.workspace;
+        if (typeof obj.branchBase === "string") result.branchBase = obj.branchBase;
+        if (typeof obj.prTarget === "string") result.prTarget = obj.prTarget;
+        if (typeof obj.qualityGate === "object" && obj.qualityGate !== null) {
+            const qg = obj.qualityGate;
+            result.qualityGate = {
+                fast: typeof qg.fast === "string" ? qg.fast : undefined,
+                full: typeof qg.full === "string" ? qg.full : undefined
+            };
+        }
+        if (typeof obj.project === "object" && obj.project !== null) {
+            const project = obj.project;
+            result.project = {
+                criticalAreas: Array.isArray(project.criticalAreas) ? project.criticalAreas.filter((v)=>typeof v === "string") : undefined,
+                legacyPaths: Array.isArray(project.legacyPaths) ? project.legacyPaths.filter((v)=>typeof v === "string") : undefined
+            };
+        }
+        return {
+            kind: "imported",
+            data: result
+        };
+    } catch (err) {
+        return {
+            kind: "unreadable",
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+
+//# sourceMappingURL=navori-import.js.map

package/dist/lib/navori-import.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/navori-import.ts"],"sourcesContent":["import { existsSync, readFileSync, statSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nexport const NAVORI_CONFIG_FILENAME = \"navori.config.json\";\n\n/** Refuse to parse foreign input larger than this — unsanitized host-repo content. */\nexport const NAVORI_CONFIG_MAX_BYTES = 1_000_000;\n\nexport interface NaviorImport {\n  name?: string;\n  qualityGate?: { fast?: string; full?: string };\n  project?: { criticalAreas?: string[]; legacyPaths?: string[] };\n  workspace?: string;\n  branchBase?: string;\n  prTarget?: string;\n}\n\n/**\n * Discriminated read result for `navori.config.json`. Per \"lo no visto se\n * declara\": a present-but-broken file must never collapse silently into\n * \"absent\" — callers need to be able to tell the two apart and warn.\n */\nexport type NaviorImportResult =\n  | { kind: \"absent\" }\n  | { kind: \"imported\"; data: NaviorImport }\n  | { kind: \"unreadable\"; error: string };\n\n/** True when a `navori.config.json` exists in `dir` (harness coexistence). */\nexport function hasNaviorConfig(dir: string): boolean {\n  return existsSync(join(dir, NAVORI_CONFIG_FILENAME));\n}\n\n/**\n * Best-effort import of `navori.config.json` fields Argos also models. This\n * is a foreign file with its own (unvalidated) shape — read leniently, take\n * only the fields we recognize, and never throw on unexpected shapes. A\n * present file that can't be read/parsed/used is reported as `\"unreadable\"`,\n * never silently treated as `\"absent\"`.\n */\nexport function readNaviorConfig(dir: string): NaviorImportResult {\n  const path = join(dir, NAVORI_CONFIG_FILENAME);\n  if (!existsSync(path)) return { kind: \"absent\" };\n\n  try {\n    if (statSync(path).size > NAVORI_CONFIG_MAX_BYTES) {\n      return {\n        kind: \"unreadable\",\n        error: `navori.config.json excede el máximo permitido de ${NAVORI_CONFIG_MAX_BYTES} bytes`,\n      };\n    }\n\n    const raw: unknown = JSON.parse(readFileSync(path, \"utf-8\"));\n    if (typeof raw !== \"object\" || raw === null) {\n      return { kind: \"unreadable\", error: \"navori.config.json no es un objeto JSON\" };\n    }\n    const obj = raw as Record<string, unknown>;\n\n    const result: NaviorImport = {};\n    if (typeof obj.name === \"string\") result.name = obj.name;\n    if (typeof obj.workspace === \"string\") result.workspace = obj.workspace;\n    if (typeof obj.branchBase === \"string\") result.branchBase = obj.branchBase;\n    if (typeof obj.prTarget === \"string\") result.prTarget = obj.prTarget;\n\n    if (typeof obj.qualityGate === \"object\" && obj.qualityGate !== null) {\n      const qg = obj.qualityGate as Record<string, unknown>;\n      result.qualityGate = {\n        fast: typeof qg.fast === \"string\" ? qg.fast : undefined,\n        full: typeof qg.full === \"string\" ? qg.full : undefined,\n      };\n    }\n\n    if (typeof obj.project === \"object\" && obj.project !== null) {\n      const project = obj.project as Record<string, unknown>;\n      result.project = {\n        criticalAreas: Array.isArray(project.criticalAreas)\n          ? project.criticalAreas.filter((v): v is string => typeof v === \"string\")\n          : undefined,\n        legacyPaths: Array.isArray(project.legacyPaths)\n          ? project.legacyPaths.filter((v): v is string => typeof v === \"string\")\n          : undefined,\n      };\n    }\n\n    return { kind: \"imported\", data: result };\n  } catch (err) {\n    return { kind: \"unreadable\", error: err instanceof Error ? err.message : String(err) };\n  }\n}\n"],"names":["existsSync","readFileSync","statSync","join","NAVORI_CONFIG_FILENAME","NAVORI_CONFIG_MAX_BYTES","hasNaviorConfig","dir","readNaviorConfig","path","kind","size","error","raw","JSON","parse","obj","result","name","workspace","branchBase","prTarget","qualityGate","qg","fast","undefined","full","project","criticalAreas","Array","isArray","filter","v","legacyPaths","data","err","Error","message","String"],"mappings":"AAAA,SAASA,UAAU,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,UAAU;AAC7D,SAASC,IAAI,QAAQ,YAAY;AAEjC,OAAO,MAAMC,yBAAyB,qBAAqB;AAE3D,oFAAoF,GACpF,OAAO,MAAMC,0BAA0B,UAAU;AAqBjD,4EAA4E,GAC5E,OAAO,SAASC,gBAAgBC,GAAW;IACzC,OAAOP,WAAWG,KAAKI,KAAKH;AAC9B;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,iBAAiBD,GAAW;IAC1C,MAAME,OAAON,KAAKI,KAAKH;IACvB,IAAI,CAACJ,WAAWS,OAAO,OAAO;QAAEC,MAAM;IAAS;IAE/C,IAAI;QACF,IAAIR,SAASO,MAAME,IAAI,GAAGN,yBAAyB;YACjD,OAAO;gBACLK,MAAM;gBACNE,OAAO,CAAC,iDAAiD,EAAEP,wBAAwB,MAAM,CAAC;YAC5F;QACF;QAEA,MAAMQ,MAAeC,KAAKC,KAAK,CAACd,aAAaQ,MAAM;QACnD,IAAI,OAAOI,QAAQ,YAAYA,QAAQ,MAAM;YAC3C,OAAO;gBAAEH,MAAM;gBAAcE,OAAO;YAA0C;QAChF;QACA,MAAMI,MAAMH;QAEZ,MAAMI,SAAuB,CAAC;QAC9B,IAAI,OAAOD,IAAIE,IAAI,KAAK,UAAUD,OAAOC,IAAI,GAAGF,IAAIE,IAAI;QACxD,IAAI,OAAOF,IAAIG,SAAS,KAAK,UAAUF,OAAOE,SAAS,GAAGH,IAAIG,SAAS;QACvE,IAAI,OAAOH,IAAII,UAAU,KAAK,UAAUH,OAAOG,UAAU,GAAGJ,IAAII,UAAU;QAC1E,IAAI,OAAOJ,IAAIK,QAAQ,KAAK,UAAUJ,OAAOI,QAAQ,GAAGL,IAAIK,QAAQ;QAEpE,IAAI,OAAOL,IAAIM,WAAW,KAAK,YAAYN,IAAIM,WAAW,KAAK,MAAM;YACnE,MAAMC,KAAKP,IAAIM,WAAW;YAC1BL,OAAOK,WAAW,GAAG;gBACnBE,MAAM,OAAOD,GAAGC,IAAI,KAAK,WAAWD,GAAGC,IAAI,GAAGC;gBAC9CC,MAAM,OAAOH,GAAGG,IAAI,KAAK,WAAWH,GAAGG,IAAI,GAAGD;YAChD;QACF;QAEA,IAAI,OAAOT,IAAIW,OAAO,KAAK,YAAYX,IAAIW,OAAO,KAAK,MAAM;YAC3D,MAAMA,UAAUX,IAAIW,OAAO;YAC3BV,OAAOU,OAAO,GAAG;gBACfC,eAAeC,MAAMC,OAAO,CAACH,QAAQC,aAAa,IAC9CD,QAAQC,aAAa,CAACG,MAAM,CAAC,CAACC,IAAmB,OAAOA,MAAM,YAC9DP;gBACJQ,aAAaJ,MAAMC,OAAO,CAACH,QAAQM,WAAW,IAC1CN,QAAQM,WAAW,CAACF,MAAM,CAAC,CAACC,IAAmB,OAAOA,MAAM,YAC5DP;YACN;QACF;QAEA,OAAO;YAAEf,MAAM;YAAYwB,MAAMjB;QAAO;IAC1C,EAAE,OAAOkB,KAAK;QACZ,OAAO;YAAEzB,MAAM;YAAcE,OAAOuB,eAAeC,QAAQD,IAAIE,OAAO,GAAGC,OAAOH;QAAK;IACvF;AACF"}