zyrk 0.3.8 → 0.3.9

package/{src/cli/npm-delegate.ts → dist/cli/npm-delegate.js}

@@ -16,14 +16,11 @@
  * operate outside zyrk's dependency management. Global installs are never
  * delegated (F-018); see parse.ts.
  */
-
 import { spawn } from "node:child_process";
-import { ZyrkError } from "../errors.ts";
-import { closeCode } from "../util/proc.ts";
-
+import { ZyrkError } from "../errors.js";
+import { closeCode } from "../util/proc.js";
 /** Delegated command, its aliases collapsed, plus help text. */
-const DELEGATED_COMMANDS: ReadonlyArray<readonly [readonly string[], string]> =
-  [
+const DELEGATED_COMMANDS = [
     [["publish"], "Publish the current package to the registry (via npm)."],
     [["unpublish"], "Remove a published version from the registry (via npm)."],
     [["access"], "Manage package access and visibility (via npm)."],
@@ -36,62 +33,36 @@ const DELEGATED_COMMANDS: ReadonlyArray<readonly [readonly string[], string]> =
     [["whoami"], "Show the authenticated registry username (via npm)."],
     [["ping"], "Check registry authentication and reachability (via npm)."],
     [["pack"], "Create a tarball from the current package (via npm)."],
-  ];
-
-export const DELEGATED_COMMAND_NAMES: ReadonlySet<string> = new Set(
-  DELEGATED_COMMANDS.flatMap(([names]) => names),
-);
-
-export function isDelegatedCommand(command: string): boolean {
-  return DELEGATED_COMMAND_NAMES.has(command);
+];
+export const DELEGATED_COMMAND_NAMES = new Set(DELEGATED_COMMANDS.flatMap(([names]) => names));
+export function isDelegatedCommand(command) {
+    return DELEGATED_COMMAND_NAMES.has(command);
 }
-
-export function delegatedHelpLines(): string[] {
-  return DELEGATED_COMMANDS.map(
-    ([names, description]) =>
-      `  ${names.join(", ").padEnd(22, " ")}${description}`,
-  );
+export function delegatedHelpLines() {
+    return DELEGATED_COMMANDS.map(([names, description]) => `  ${names.join(", ").padEnd(22, " ")}${description}`);
 }
-
-export type DelegateOptions = {
-  command: string;
-  /** Raw tokens after the command, verbatim (may include --json, --, -g). */
-  args: readonly string[];
-  env: NodeJS.ProcessEnv;
-  stderr: { write(chunk: string): unknown };
-};
-
 /**
  * Exec `npm <command> <args...>` with inherited stdio. Resolves with the
  * child exit code, or 128 plus the signal number when signaled (the shell
  * convention), so callers observe the same termination. Rejects with
  * ZYRK_NPM_UNAVAILABLE when npm cannot be launched.
  */
-export async function delegateToNpm(options: DelegateOptions): Promise<number> {
-  options.stderr.write(
-    `zyrk: delegating \`zyrk ${options.command}\` to npm; zyrk does not implement publishing or registry authentication.\n`,
-  );
-  return new Promise((resolve, reject) => {
-    const child = spawn("npm", [options.command, ...options.args], {
-      env: options.env,
-      stdio: "inherit",
+export async function delegateToNpm(options) {
+    options.stderr.write(`zyrk: delegating \`zyrk ${options.command}\` to npm; zyrk does not implement publishing or registry authentication.\n`);
+    return new Promise((resolve, reject) => {
+        const child = spawn("npm", [options.command, ...options.args], {
+            env: options.env,
+            stdio: "inherit",
+        });
+        child.on("error", (error) => {
+            reject(new ZyrkError("ZYRK_NPM_UNAVAILABLE", "zyrk could not launch npm for an explicitly delegated command.", {
+                detail: { command: options.command },
+                remedy: "Install Node.js with npm on PATH, or run the npm command directly.",
+                cause: error,
+            }));
+        });
+        child.on("close", (code, signal) => {
+            resolve(closeCode(code, signal));
+        });
     });
-    child.on("error", (error) => {
-      reject(
-        new ZyrkError(
-          "ZYRK_NPM_UNAVAILABLE",
-          "zyrk could not launch npm for an explicitly delegated command.",
-          {
-            detail: { command: options.command },
-            remedy:
-              "Install Node.js with npm on PATH, or run the npm command directly.",
-            cause: error,
-          },
-        ),
-      );
-    });
-    child.on("close", (code, signal) => {
-      resolve(closeCode(code, signal));
-    });
-  });
 }

package/dist/cli/parse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Minimal argv parsing for the zyrk CLI (SPEC 15).
+ *
+ * zyrk takes no global configuration file of its own here: flags are parsed
+ * per invocation. `--json` anywhere before the `--` separator selects the
+ * machine-readable envelope. Everything after `--` belongs to the requested
+ * user command (SPEC 15.3.1: flags following the separator for `run`/`exec`
+ * remain user arguments, never zyrk options).
+ */
+export type ParsedArgs = {
+    help: boolean;
+    version: boolean;
+    /** The requested command, or undefined when none was given. */
+    command: string | undefined;
+    /** Everything that is not the command, `--json`, or `--help`/`--version`. */
+    commandArgs: string[];
+    /** Raw tokens after the command token, verbatim, for npm delegation. */
+    argsAfterCommand: string[];
+    /**
+     * Non-zyrk tokens placed before the command token, in order. Delegation
+     * forwards these too: a leading protective flag such as `--dry-run`
+     * belongs to npm, and dropping it would silently change what runs (S05).
+     */
+    argsBeforeCommand: string[];
+    json: boolean;
+};
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/**
+ * Detect global-install mode before any work happens.
+ *
+ * Exact tokens `-g` and `--global` in any position, plus the `--global=true`
+ * spelling, select global mode; `install`/`add` take no `--` payload, so
+ * tokens after a separator are still zyrk's. Explicit local selections
+ * (`--no-global`, `--global=false`) do not trigger. zyrk defines no
+ * configuration that selects global-install mode, so the only remaining
+ * channel is the environment npm itself documents: `npm_config_global=true`
+ * is honored as a fail-safe, never as a silent conversion.
+ */
+export declare function isGlobalInstallRequest(command: string, commandArgs: readonly string[], env: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=parse.d.ts.map

package/dist/cli/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/cli/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,6EAA6E;IAC7E,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CAkD7D;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,GAAG,EAAE,MAAM,CAAC,UAAU,GACrB,OAAO,CAOT"}

package/dist/cli/parse.js

@@ -0,0 +1,78 @@
+/**
+ * Minimal argv parsing for the zyrk CLI (SPEC 15).
+ *
+ * zyrk takes no global configuration file of its own here: flags are parsed
+ * per invocation. `--json` anywhere before the `--` separator selects the
+ * machine-readable envelope. Everything after `--` belongs to the requested
+ * user command (SPEC 15.3.1: flags following the separator for `run`/`exec`
+ * remain user arguments, never zyrk options).
+ */
+export function parseArgs(argv) {
+    const parsed = {
+        help: false,
+        version: false,
+        command: undefined,
+        commandArgs: [],
+        argsAfterCommand: [],
+        argsBeforeCommand: [],
+        json: false,
+    };
+    let separator = false;
+    let commandIndex = -1;
+    argv.forEach((token, index) => {
+        if (separator) {
+            parsed.commandArgs.push(token);
+            return;
+        }
+        if (token === "--") {
+            separator = true;
+            parsed.commandArgs.push(token);
+            return;
+        }
+        if (token === "--json") {
+            parsed.json = true;
+            return;
+        }
+        if (parsed.command === undefined &&
+            (token === "--help" || token === "-h")) {
+            parsed.help = true;
+            return;
+        }
+        if (parsed.command === undefined &&
+            (token === "--version" || token === "-v")) {
+            parsed.version = true;
+            return;
+        }
+        if (parsed.command === undefined && !token.startsWith("-")) {
+            parsed.command = token;
+            commandIndex = index;
+            return;
+        }
+        if (parsed.command === undefined)
+            parsed.argsBeforeCommand.push(token);
+        parsed.commandArgs.push(token);
+    });
+    if (commandIndex >= 0)
+        parsed.argsAfterCommand = argv.slice(commandIndex + 1);
+    return parsed;
+}
+/** Commands whose global-install mode zyrk rejects (SPEC 15.3.1, 22.3). */
+const GLOBAL_INSTALL_COMMANDS = new Set(["install", "i", "add"]);
+/**
+ * Detect global-install mode before any work happens.
+ *
+ * Exact tokens `-g` and `--global` in any position, plus the `--global=true`
+ * spelling, select global mode; `install`/`add` take no `--` payload, so
+ * tokens after a separator are still zyrk's. Explicit local selections
+ * (`--no-global`, `--global=false`) do not trigger. zyrk defines no
+ * configuration that selects global-install mode, so the only remaining
+ * channel is the environment npm itself documents: `npm_config_global=true`
+ * is honored as a fail-safe, never as a silent conversion.
+ */
+export function isGlobalInstallRequest(command, commandArgs, env) {
+    if (!GLOBAL_INSTALL_COMMANDS.has(command))
+        return false;
+    if (env.npm_config_global === "true")
+        return true;
+    return commandArgs.some((token) => token === "-g" || token === "--global" || token === "--global=true");
+}

package/dist/commands/dependencies.d.ts

@@ -0,0 +1,12 @@
+import type { RegistryClient } from "../fetch/registry.ts";
+import type { Store } from "../store/layout.ts";
+import { type InstallResult } from "../install/run.ts";
+export type DependencyCommand = "add" | "remove" | "update" | "import";
+export declare function runDependencyCommand(options: {
+    command: DependencyCommand;
+    args: readonly string[];
+    projectDir: string;
+    store: Store;
+    registry: RegistryClient;
+}): Promise<InstallResult>;
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/commands/dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../../src/commands/dependencies.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAavE,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,cAAc,CAAC;CAC1B,GAAG,OAAO,CAAC,aAAa,CAAC,CA0HzB"}

package/dist/commands/dependencies.js

@@ -0,0 +1,118 @@
+/** Parse dependency edits; the installer owns resolution and atomic publication. */
+import npa from "npm-package-arg";
+import { ZyrkError } from "../errors.js";
+import { packageName } from "../install/lock.js";
+import { installProject, } from "../install/run.js";
+function usage(command, reason) {
+    return new ZyrkError("ZYRK_USAGE", `Cannot ${command} dependencies: ${reason}.`, {
+        remedy: "Use add <spec...>, remove <name...>, update [--latest] [name...], or import --from npm; review zyrk --help for supported options.",
+    });
+}
+export async function runDependencyCommand(options) {
+    const { command } = options;
+    const install = {
+        projectDir: options.projectDir,
+        store: options.store,
+        registry: options.registry,
+    };
+    const names = [];
+    let from;
+    let latest = false;
+    let positional = false;
+    for (let i = 0; i < options.args.length; i++) {
+        const arg = options.args[i];
+        if (!positional && arg === "--") {
+            positional = true;
+            continue;
+        }
+        if (!positional && arg.startsWith("-")) {
+            switch (arg) {
+                case "-D":
+                case "--save-dev":
+                    if (command !== "add")
+                        throw usage(command, "--save-dev is only valid for add");
+                    install.saveDev = true;
+                    break;
+                case "-O":
+                case "--save-optional":
+                    if (command !== "add")
+                        throw usage(command, "--save-optional is only valid for add");
+                    install.saveOptional = true;
+                    break;
+                case "-E":
+                case "--save-exact":
+                    if (command !== "add" && command !== "update")
+                        throw usage(command, "--save-exact is only valid for add or update");
+                    install.saveExact = true;
+                    break;
+                case "--latest":
+                    if (command !== "update")
+                        throw usage(command, "--latest is only valid for update");
+                    latest = true;
+                    break;
+                case "--ignore-scripts":
+                    install.ignoreScripts = true;
+                    break;
+                case "--lockfile-only":
+                    install.lockfileOnly = true;
+                    break;
+                case "--from":
+                    if (command !== "import" || from !== undefined)
+                        throw usage(command, "unexpected --from option");
+                    from = options.args[++i];
+                    if (from === undefined)
+                        throw usage(command, "--from requires npm");
+                    break;
+                default:
+                    if (arg.startsWith("--from=") &&
+                        command === "import" &&
+                        from === undefined) {
+                        from = arg.slice(7);
+                        break;
+                    }
+                    if (command === "add" &&
+                        ["-g", "--global", "--global=true"].includes(arg))
+                        throw new ZyrkError("ZYRK_GLOBAL_INSTALL_UNSUPPORTED", "Cannot install global dependencies through zyrk.", { remedy: "Run npm install --global directly instead." });
+                    throw usage(command, "an unsupported option was supplied");
+            }
+        }
+        else
+            names.push(arg);
+    }
+    if (install.saveDev && install.saveOptional)
+        throw usage(command, "development and optional dependency groups conflict");
+    switch (command) {
+        case "add":
+            if (!names.length)
+                throw usage(command, "at least one package specification is required");
+            for (const name of names) {
+                try {
+                    const parsed = npa(name);
+                    if (!parsed.name ||
+                        !packageName(parsed.name) ||
+                        !["version", "range", "tag", "alias"].includes(parsed.type))
+                        throw new Error("unsupported");
+                }
+                catch {
+                    throw usage(command, "a registry package specification is invalid");
+                }
+            }
+            install.specs = names;
+            break;
+        case "remove":
+        case "update":
+            if (command === "remove" && !names.length)
+                throw usage(command, "at least one direct dependency name is required");
+            if (names.some((name) => !packageName(name)))
+                throw usage(command, "expected direct dependency names without versions");
+            install.mutation =
+                command === "remove" ? { remove: names } : { update: names, latest };
+            break;
+        case "import":
+            if (from !== "npm" || names.length)
+                throw usage(command, "import requires --from npm and no package arguments");
+            install.importNpm = true;
+            break;
+    }
+    return installProject(install);
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,15 @@
+export type DeployCommandOptions = {
+    command: "deploy" | "docker";
+    args: readonly string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdout: {
+        write(chunk: string): unknown;
+    };
+    stderr: {
+        write(chunk: string): unknown;
+    };
+    json?: boolean;
+};
+export declare function runDeployCommand(options: DeployCommandOptions): Promise<number>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AA8CA,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAwEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAmUjB"}