toolfactory 0.1.1 → 0.2.0

package/dist/distribution/native.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import { nativeInstallLines, nativePackageConfigSchema, nativePackageSteps, nativePublishJobs, nativeRegistryRows, } from "./native.js";
+function project(entries, surfaces = entries.map((entry) => entry.id)) {
+    return {
+        root: "/repo",
+        tool: {
+            schemaVersion: 1,
+            identity: "package.json",
+            binding: "typescript",
+            surfaces: surfaces,
+            bundle: { runtime: "package" },
+            tests: { examples: {} },
+            nativePackages: entries,
+        },
+        identity: { name: "tool", version: "1.2.3", repository: "https://github.com/acme/tool" },
+        identityExtra: {},
+        operations: [],
+        toolfactoryVersion: "0.1.0",
+    };
+}
+const cargo = {
+    id: "cargo",
+    path: "native/cli",
+    identity: "Cargo.toml",
+    name: "acme-cli",
+    versionCommand: "cargo pkgid | sed 's/.*@//'",
+};
+describe("native package configuration", () => {
+    it("requires the package path, authored identity, and registry identity", () => {
+        expect(() => nativePackageConfigSchema.parse({ id: "cargo", path: "native" })).toThrow();
+        expect(nativePackageConfigSchema.parse(cargo)).toEqual(cargo);
+    });
+    it("rejects a selected registry with no config or duplicate configuration", () => {
+        expect(() => nativePackageSteps(project([], ["cargo"]))).toThrow(/requires exactly one/);
+        expect(() => nativePackageSteps(project([cargo, cargo]))).toThrow(/repeats/);
+    });
+    it("packages authored crates and checks their version against the release", () => {
+        const steps = nativePackageSteps(project([cargo]));
+        expect(steps.map((step) => step.name)).toEqual([
+            "cargo version matches release",
+            "Cargo crate",
+        ]);
+        expect(steps[0]?.run).toContain("= '1.2.3'");
+        expect(steps[1]?.run).toContain("cargo package --manifest-path 'native/cli/Cargo.toml'");
+        expect(steps[1]?.run).toContain("--target-dir 'dist/native-build/cargo'");
+        expect(steps[1]?.run).not.toContain("/repo");
+    });
+    it("reads structured Cargo metadata and the raw MSBuild version", () => {
+        const cargoDefault = {
+            id: "cargo",
+            path: "native/cli",
+            identity: "Cargo.toml",
+            name: "acme-cli",
+        };
+        const nuget = {
+            id: "nuget",
+            path: "dotnet",
+            identity: "Tool.csproj",
+            name: "Acme.Tool",
+        };
+        const steps = nativePackageSteps(project([cargoDefault, nuget]));
+        expect(steps[0]?.run).toContain("cargo metadata --no-deps --format-version 1 --manifest-path 'Cargo.toml'");
+        expect(steps[0]?.run).toContain("JSON.parse(s).packages.find");
+        expect(steps[2]?.run).toContain("dotnet msbuild 'Tool.csproj' -nologo -getProperty:Version");
+        expect(steps[2]?.run).not.toContain("sed -n");
+    });
+    it("leaves VCS-discovered Packagist and Go modules for the final release tag", () => {
+        const entries = [
+            {
+                id: "packagist",
+                path: ".",
+                identity: "composer.json",
+                name: "acme/tool",
+            },
+            {
+                id: "go-module",
+                path: ".",
+                identity: "go.mod",
+                name: "github.com/acme/tool",
+            },
+        ];
+        expect(nativePackageSteps(project(entries))).toEqual([]);
+        expect(nativeInstallLines(project(entries))).toEqual([
+            "`composer require acme/tool`",
+            "`go get github.com/acme/tool@v1.2.3`",
+        ]);
+    });
+    it("uses direct upstream publishing commands and exposes only their actual credentials", () => {
+        const entries = [
+            cargo,
+            {
+                id: "nuget",
+                path: "dotnet",
+                identity: "Tool.csproj",
+                name: "Acme.Tool",
+                versionCommand: "dotnet msbuild -getProperty:Version Tool.csproj",
+            },
+        ];
+        const jobs = nativePublishJobs(project(entries), "release-assets", "${{ needs.gate.outputs.sha }}");
+        expect(jobs["publish-cargo"]?.steps).toContainEqual(expect.objectContaining({ run: expect.stringContaining("cargo publish") }));
+        expect(jobs["publish-nuget"]?.steps).toContainEqual(expect.objectContaining({ run: expect.stringContaining("dotnet nuget push") }));
+        expect(jobs["publish-nuget"]?.steps).toContainEqual(expect.objectContaining({
+            uses: "actions/setup-dotnet@v5",
+            with: { "dotnet-version": "8.0.x" },
+        }));
+        expect(nativeRegistryRows(project(entries)).map((row) => row.secrets)).toEqual([
+            ["CARGO_REGISTRY_TOKEN"],
+            ["NUGET_API_KEY"],
+        ]);
+        expect(jobs["publish-cargo"]?.needs).toEqual(["gate", "package"]);
+        expect(jobs["publish-cargo"]?.if).toBe("needs.gate.outputs.cargo == 'true'");
+        expect(jobs["publish-cargo"]?.steps).not.toContainEqual(expect.objectContaining({ uses: "dtolnay/rust-toolchain@stable" }));
+    });
+    it("builds a gem from its package directory before moving the resulting asset", () => {
+        const steps = nativePackageSteps(project([
+            {
+                id: "rubygems",
+                path: "native/ruby",
+                identity: "acme.gemspec",
+                name: "acme",
+                versionCommand: "ruby -e 'puts 1.2.3'",
+            },
+        ]));
+        expect(steps[1]?.run).toContain("(cd 'native/ruby' && gem build --strict 'acme.gemspec')");
+        expect(steps[1]?.run).toContain("mv 'native/ruby/acme-1.2.3.gem'");
+    });
+});

package/dist/distribution/system.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Operating-system package managers consume authored native artifacts and packaging metadata.
+ * This is intentionally not a cross-language compiler or a launcher generator.
+ */
+import { z } from "zod";
+import type { Project, Surface } from "../model.js";
+import type { GateStep, Registry } from "../project/gate.js";
+export declare const SYSTEM_PACKAGE_IDS: readonly ["homebrew", "winget", "scoop", "chocolatey", "apt", "rpm"];
+export type SystemPackageId = (typeof SYSTEM_PACKAGE_IDS)[number];
+export declare const systemPackageConfigSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
+    }>;
+    path: z.ZodString;
+    identity: z.ZodString;
+    name: z.ZodString;
+    versionCommand: z.ZodString;
+    buildCommand: z.ZodOptional<z.ZodString>;
+    buildDependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    asset: z.ZodOptional<z.ZodString>;
+    tap: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    bucketName: z.ZodOptional<z.ZodString>;
+    catalogPath: z.ZodOptional<z.ZodString>;
+    ppa: z.ZodOptional<z.ZodString>;
+    coprProject: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SystemPackageConfig = z.infer<typeof systemPackageConfigSchema>;
+export declare const systemPackageSurfaces: Surface[];
+/** Required CLI preflight for compatible local runs; native CI jobs install their own tooling. */
+export declare function systemToolchainSteps(project: Project, options?: {
+    include?: boolean;
+}): GateStep[];
+/** Build actual package artifacts or stage the authored catalog submission, all at portable paths. */
+export declare function systemPackageSteps(project: Project, options?: {
+    include?: boolean;
+    local?: boolean;
+}): GateStep[];
+export declare function systemRegistryRows(project: Project): Registry[];
+type Job = Record<string, unknown>;
+/**
+ * Native runner jobs. The generic Ubuntu gate/package workflow must not execute OS surface steps;
+ * it waits for these jobs and downloads each `system-<id>` artifact into dist/release/system/<id>.
+ */
+export declare function systemPackageJobs(project: Project, releaseSha: string): Record<string, Job>;
+/**
+ * Publish only after the GitHub release exists. Homebrew taps and Scoop buckets are ordinary
+ * author-controlled Git repositories; WinGet remains a reviewed microsoft/winget-pkgs submission.
+ */
+export declare function systemPublishJobs(project: Project, artifactDir: string, _releaseSha: string): Record<string, Job>;
+export declare function systemInstallLines(project: Project): string[];
+export {};