toolfactory 0.1.2 → 0.2.0

package/dist/distribution/system.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import { systemPackageConfigSchema, systemPackageJobs, systemPackageSteps, systemPublishJobs, systemRegistryRows, } from "./system.js";
+function project(entries, surfaces = entries.map((entry) => entry.id)) {
+    return {
+        root: "/local/never-in-output",
+        tool: {
+            schemaVersion: 1,
+            identity: "package.json",
+            binding: "typescript",
+            surfaces: surfaces,
+            bundle: { runtime: "package" },
+            tests: { examples: {} },
+            systemPackages: entries,
+        },
+        identity: { name: "tool", version: "1.2.3" },
+        identityExtra: {},
+        operations: [],
+        toolfactoryVersion: "0.1.0",
+    };
+}
+const choco = {
+    id: "chocolatey",
+    path: "packaging/choco",
+    identity: "tool.nuspec",
+    name: "tool",
+    versionCommand: "node -p \"require('./tool.nuspec.version.json').version\"",
+};
+describe("system packages", () => {
+    it("requires real catalog/repository configuration", () => {
+        expect(() => systemPackageConfigSchema.parse({ ...choco, id: "apt" })).toThrow(/PPA/);
+        expect(() => systemPackageConfigSchema.parse({
+            id: "scoop",
+            path: "packaging/scoop",
+            identity: "tool.json",
+            name: "tool",
+            versionCommand: "Get-Content VERSION",
+            buildCommand: "./build.ps1",
+            asset: "../tool.zip",
+            bucket: "acme/scoop-bucket",
+            bucketName: "acme",
+            catalogPath: "bucket/tool.json",
+        })).toThrow(/path must stay/);
+        expect(() => systemPackageSteps(project([], ["chocolatey"]))).toThrow(/exactly one/);
+    });
+    it("packages with checkout-relative paths", () => {
+        const steps = systemPackageSteps(project([choco]), { local: false });
+        expect(steps.at(-1)?.run).toContain("choco pack 'packaging/choco/tool.nuspec'");
+        expect(steps.at(-1)?.run).not.toContain("/local/never-in-output");
+    });
+    it("stages a non-root WinGet manifest directory and Debian source changes portably", () => {
+        const winget = {
+            id: "winget",
+            path: "packaging/winget",
+            identity: "manifests/a/acme/tool/1.2.3",
+            name: "Acme.Tool",
+            versionCommand: "cat VERSION",
+            buildCommand: "./build-installer.ps1",
+            asset: "dist/tool.msi",
+        };
+        const apt = {
+            id: "apt",
+            path: "packaging/debian/source",
+            identity: "debian/control",
+            name: "tool",
+            versionCommand: "dpkg-parsechangelog -S Version | cut -d- -f1",
+            ppa: "acme/tool",
+            buildDependencies: ["debhelper"],
+        };
+        const steps = systemPackageSteps(project([winget, apt]), { local: false });
+        expect(steps.find((step) => step.name === "WinGet catalog submission")?.run).toContain("test -d 'packaging/winget/manifests/a/acme/tool/1.2.3'");
+        const debian = steps.find((step) => step.name === "Debian source package")?.run;
+        expect(debian).toContain("find 'packaging/debian/source/..'");
+        expect(debian).toContain("'dist/release/system/apt'");
+        expect(debian).not.toContain("../dist/release");
+    });
+    it("gates direct jobs and commits author-controlled Homebrew metadata after release", () => {
+        const brew = {
+            id: "homebrew",
+            path: "packaging/brew",
+            identity: "tool.rb",
+            name: "tool",
+            versionCommand: "grep VERSION tool.rb",
+            buildCommand: "make release-archive",
+            asset: "dist/tool.tar.gz",
+            tap: "acme/homebrew-tap",
+            catalogPath: "Formula/tool.rb",
+        };
+        const jobs = systemPublishJobs(project([choco, brew]), "release-assets", "${{ needs.gate.outputs.sha }}");
+        expect(jobs["publish-chocolatey"]?.if).toBe("needs.gate.outputs.chocolatey == 'true'");
+        expect(jobs["publish-homebrew"]?.needs).toEqual(["gate", "release"]);
+        expect(JSON.stringify(jobs["publish-homebrew"])).toContain("git -C .system-catalog push");
+        expect(JSON.stringify(jobs["publish-homebrew"])).toContain("system-homebrew");
+        expect(JSON.stringify(jobs["publish-homebrew"])).toContain("toolfactory-postrelease/tap");
+        expect(JSON.stringify(jobs["publish-chocolatey"])).toContain("system-chocolatey");
+        expect(JSON.stringify(jobs)).not.toContain("/local/never-in-output");
+        expect(systemRegistryRows(project([choco])).at(0)?.secrets).toEqual(["CHOCOLATEY_API_KEY"]);
+    });
+    it("uses dedicated native runners and upload names instead of the Ubuntu package job", () => {
+        const brew = {
+            id: "homebrew",
+            path: "packaging/brew",
+            identity: "tool.rb",
+            name: "tool",
+            versionCommand: "grep VERSION tool.rb",
+            buildCommand: "make release-archive",
+            asset: "dist/tool.tar.gz",
+            tap: "acme/homebrew-tap",
+            catalogPath: "Formula/tool.rb",
+        };
+        const jobs = systemPackageJobs(project([choco, brew]), "${{ github.sha }}");
+        expect(jobs["system-homebrew"]?.["runs-on"]).toBe("macos-latest");
+        expect(jobs["system-chocolatey"]?.["runs-on"]).toBe("windows-latest");
+        expect(JSON.stringify(jobs["system-chocolatey"])).toContain("system-chocolatey");
+        expect(JSON.stringify(jobs)).not.toContain("/local/never-in-output");
+    });
+});

package/dist/e2e.test.js

@@ -119,6 +119,12 @@ describe.skipIf(!existsSync(repoNodeModules))("confluence: a walked tree equals
         await commands.introspect(fresh);
         authorProse(fresh);
         commands.build(fresh);
-        expect(tree(walked)).toEqual(tree(fresh));
+        const walkedTree = tree(walked);
+        // Deselecting a region surface preserves its author-owned scaffold, including an empty
+        // Docker ignore file. All managed bytes still converge with the freshly generated tree.
+        expect(walkedTree[".dockerignore"]).toContain("# tf:dockerignore# /tf:dockerignore");
+        expect(walkedTree[".dockerignore"]).not.toContain("node_modules/");
+        delete walkedTree[".dockerignore"];
+        expect(walkedTree).toEqual(tree(fresh));
     });
 });

package/dist/hosts/openclaw.js

@@ -56,9 +56,13 @@ function missing(scaffold, ours, path, skip) {
 }
 function planned(files, path) {
     const file = files.find((candidate) => candidate.path === `${HOST_DIR}/${path}`);
-    if (file?.kind !== "file")
+    if (!file)
         throw new Error(`the openclaw surface no longer plans ${path}`);
-    return file.content;
+    if (file.kind === "file")
+        return file.content;
+    if (file.kind === "merge" && file.format === "json")
+        return JSON.stringify(file.patch, null, 2);
+    throw new Error(`the openclaw surface no longer plans ${path} as JSON`);
 }
 /** Human-readable drift lines; empty means the generator still mirrors upstream. */
 export function scaffoldDrift(project) {

package/dist/hosts/vscode.d.ts

@@ -0,0 +1 @@
+export declare function scaffoldDrift(): string[];

package/dist/hosts/vscode.js

@@ -0,0 +1,67 @@
+/** Verify the extension scaffold against Microsoft's generator, without touching the checkout. */
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { argv } from "node:process";
+import { fileURLToPath } from "node:url";
+import { ESBUILD, ESLINT, GITIGNORE, IGNORE, LAUNCH, TASKS, VSCODE_GENERATOR, VSCODE_SCAFFOLD, } from "../surfaces/vscode-scaffold.js";
+export function scaffoldDrift() {
+    const root = mkdtempSync(join(tmpdir(), "toolfactory-vscode-scaffold-"));
+    const target = join(root, "probe");
+    try {
+        execFileSync("npx", [
+            "--yes",
+            "--package",
+            "yo",
+            "--package",
+            `generator-code@${VSCODE_GENERATOR}`,
+            "--",
+            "yo",
+            "code",
+            target,
+            "--extensionType",
+            "ts",
+            "--extensionDisplayName",
+            "ToolFactory Probe",
+            "--extensionId",
+            "tf-probe",
+            "--extensionDescription",
+            "ToolFactory scaffold probe",
+            "--pkgManager",
+            "npm",
+            "--bundler",
+            "esbuild",
+            "--gitInit",
+            "false",
+            "--skip-install",
+            "--skipOpen",
+            "--quick",
+        ], { stdio: "pipe", cwd: root });
+        const pkg = JSON.parse(readFileSync(join(target, "package.json"), "utf8"));
+        const drift = Object.entries(VSCODE_SCAFFOLD)
+            .filter(([key, expected]) => JSON.stringify(pkg[key]) !== JSON.stringify(expected))
+            .map(([key]) => `package.json ${key}`);
+        for (const [path, expected] of [
+            ["esbuild.js", ESBUILD],
+            ["eslint.config.mjs", ESLINT],
+            [".vscodeignore", IGNORE],
+            [".gitignore", GITIGNORE],
+            [".vscode/launch.json", LAUNCH],
+            [".vscode/tasks.json", TASKS],
+        ]) {
+            if (readFileSync(join(target, path), "utf8") !== expected)
+                drift.push(path);
+        }
+        return drift;
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+if (argv[1] === fileURLToPath(import.meta.url)) {
+    const drift = scaffoldDrift();
+    if (drift.length)
+        throw new Error(`VS Code scaffold drifted: ${drift.join(", ")}`);
+    process.stdout.write("VS Code scaffold matches generator-code.\n");
+}

package/dist/model.d.ts

@@ -10,7 +10,7 @@ import { z } from "zod";
 export declare const CAPABILITIES: readonly ["net", "fs", "shell", "secret", "browser", "model", "user-input", "channel"];
 export type Capability = (typeof CAPABILITIES)[number];
 export declare const PORTABLE_CAPABILITIES: ReadonlySet<Capability>;
-export declare const SURFACE_IDS: readonly ["skill", "agent-plugins", "claude", "codex", "cursor", "mcp", "mcp-registry", "cli", "npm", "pypi", "openclaw-native", "hermes-native", "clawhub", "web", "dsh", "workflows", "agents", "readme", "gemini", "mcpb", "browser-extension"];
+export declare const SURFACE_IDS: readonly ["skill", "agent-plugins", "claude", "codex", "cursor", "mcp", "mcp-registry", "cli", "npm", "pypi", "openclaw-native", "hermes-native", "clawhub", "web", "dsh", "workflows", "agents", "readme", "gemini", "mcpb", "browser-extension", "vscode-extension", "cargo", "nuget", "maven-central", "rubygems", "packagist", "go-module", "homebrew", "winget", "scoop", "chocolatey", "apt", "rpm"];
 export type SurfaceId = (typeof SURFACE_IDS)[number];
 export declare const BINDINGS: readonly ["typescript", "python"];
 export type Binding = (typeof BINDINGS)[number];
@@ -41,6 +41,12 @@ export declare const ToolConfigSchema: z.ZodObject<{
         none: "none";
     }>>;
     surfaces: z.ZodArray<z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
         skill: "skill";
         "agent-plugins": "agent-plugins";
         claude: "claude";
@@ -62,6 +68,13 @@ export declare const ToolConfigSchema: z.ZodObject<{
         gemini: "gemini";
         mcpb: "mcpb";
         "browser-extension": "browser-extension";
+        "vscode-extension": "vscode-extension";
+        cargo: "cargo";
+        nuget: "nuget";
+        "maven-central": "maven-central";
+        rubygems: "rubygems";
+        packagist: "packagist";
+        "go-module": "go-module";
     }>>;
     kernel: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -99,6 +112,48 @@ export declare const ToolConfigSchema: z.ZodObject<{
     hermes: z.ZodOptional<z.ZodObject<{
         toolset: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    vscode: z.ZodOptional<z.ZodObject<{
+        publisher: z.ZodOptional<z.ZodString>;
+        marketplace: z.ZodDefault<z.ZodBoolean>;
+        openvsx: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    nativePackages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            cargo: "cargo";
+            nuget: "nuget";
+            "maven-central": "maven-central";
+            rubygems: "rubygems";
+            packagist: "packagist";
+            "go-module": "go-module";
+        }>;
+        path: z.ZodString;
+        identity: z.ZodString;
+        name: z.ZodString;
+        versionCommand: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    systemPackages: z.ZodOptional<z.ZodArray<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>>>;
     openclaw: z.ZodOptional<z.ZodObject<{
         registers: z.ZodOptional<z.ZodArray<z.ZodObject<{
             api: z.ZodString;
@@ -183,10 +238,15 @@ export interface RegionFile {
 export interface MergeFile {
     kind: "merge";
     path: string;
-    format: "json" | "toml";
+    format: "json" | "toml" | "yaml";
     patch: Record<string, unknown>;
     /** Dotted paths inside `patch` whose object toolfactory owns whole: replaced, never merged. */
     owned?: string[];
+    /**
+     * Arrays whose entries are shared by a stable identifier. Toolfactory replaces only entries it
+     * previously wrote, preserves the author's other entries, and rejects an id collision.
+     */
+    keyedArrays?: Record<string, string>;
 }
 export type PlannedFile = FullFile | RegionFile | MergeFile;
 export interface Command {

package/dist/model.js

@@ -7,6 +7,9 @@
  * rest is derived and written in-tree, tracked by a lock file.
  */
 import { z } from "zod";
+import { NATIVE_PACKAGE_IDS, nativePackageConfigSchema } from "./distribution/native.js";
+import { SYSTEM_PACKAGE_IDS, systemPackageConfigSchema } from "./distribution/system.js";
+import { vscodeConfigSchema } from "./surfaces/vscode-extension.js";
 export const CAPABILITIES = [
     "net",
     "fs",
@@ -45,6 +48,9 @@ export const SURFACE_IDS = [
     "gemini",
     "mcpb",
     "browser-extension",
+    "vscode-extension",
+    ...NATIVE_PACKAGE_IDS,
+    ...SYSTEM_PACKAGE_IDS,
 ];
 export const BINDINGS = ["typescript", "python"];
 /**
@@ -146,6 +152,9 @@ export const ToolConfigSchema = z
         .optional()
         .describe("Privacy-policy URLs of the services this tool talks to; Anthropic's Connectors Directory submission requires them in the MCPB manifest."),
     hermes: z.object({ toolset: z.string().optional() }).optional(),
+    vscode: vscodeConfigSchema.optional(),
+    nativePackages: z.array(nativePackageConfigSchema).optional(),
+    systemPackages: z.array(systemPackageConfigSchema).optional(),
     openclaw: z
         .object({
         registers: z

package/dist/ops.d.ts

@@ -16,6 +16,12 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
         none: "none";
     }>>;
     surfaces: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
         skill: "skill";
         "agent-plugins": "agent-plugins";
         claude: "claude";
@@ -37,6 +43,13 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
         gemini: "gemini";
         mcpb: "mcpb";
         "browser-extension": "browser-extension";
+        "vscode-extension": "vscode-extension";
+        cargo: "cargo";
+        nuget: "nuget";
+        "maven-central": "maven-central";
+        rubygems: "rubygems";
+        packagist: "packagist";
+        "go-module": "go-module";
     }>>>;
     description: z.ZodOptional<z.ZodString>;
     license: z.ZodOptional<z.ZodString>;
@@ -86,6 +99,12 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
 }, z.core.$strip>> | import("./toolfactory/types.js").Operation<z.ZodObject<{
     root: z.ZodDefault<z.ZodString>;
     surface: z.ZodOptional<z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
         skill: "skill";
         "agent-plugins": "agent-plugins";
         claude: "claude";
@@ -107,6 +126,13 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
         gemini: "gemini";
         mcpb: "mcpb";
         "browser-extension": "browser-extension";
+        "vscode-extension": "vscode-extension";
+        cargo: "cargo";
+        nuget: "nuget";
+        "maven-central": "maven-central";
+        rubygems: "rubygems";
+        packagist: "packagist";
+        "go-module": "go-module";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
     outcomes: z.ZodArray<z.ZodObject<{
@@ -138,6 +164,12 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
 }, z.core.$strip>> | import("./toolfactory/types.js").Operation<z.ZodObject<{
     root: z.ZodDefault<z.ZodString>;
     surface: z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
         skill: "skill";
         "agent-plugins": "agent-plugins";
         claude: "claude";
@@ -159,6 +191,13 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
         gemini: "gemini";
         mcpb: "mcpb";
         "browser-extension": "browser-extension";
+        "vscode-extension": "vscode-extension";
+        cargo: "cargo";
+        nuget: "nuget";
+        "maven-central": "maven-central";
+        rubygems: "rubygems";
+        packagist: "packagist";
+        "go-module": "go-module";
     }>;
 }, z.core.$strip>, z.ZodObject<{
     adopted: z.ZodArray<z.ZodString>;
@@ -209,6 +248,12 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
 }, z.core.$strip>, z.ZodObject<{
     from: z.ZodOptional<z.ZodString>;
     dropped: z.ZodArray<z.ZodEnum<{
+        homebrew: "homebrew";
+        winget: "winget";
+        scoop: "scoop";
+        chocolatey: "chocolatey";
+        apt: "apt";
+        rpm: "rpm";
         skill: "skill";
         "agent-plugins": "agent-plugins";
         claude: "claude";
@@ -230,6 +275,13 @@ export declare const operations: (import("./toolfactory/types.js").Operation<z.Z
         gemini: "gemini";
         mcpb: "mcpb";
         "browser-extension": "browser-extension";
+        "vscode-extension": "vscode-extension";
+        cargo: "cargo";
+        nuget: "nuget";
+        "maven-central": "maven-central";
+        rubygems: "rubygems";
+        packagist: "packagist";
+        "go-module": "go-module";
     }>>;
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;

package/dist/project/apply.d.ts

@@ -23,7 +23,7 @@ export declare function deepMerge(base: Record<string, unknown>, patch: Record<s
 /** The values a merge file owns, read back out of a document; an owned object comes back whole. */
 export declare function pickPatch(document: Record<string, unknown>, patch: Record<string, unknown>, owned?: string[], prefix?: string): Record<string, unknown>;
 /** The dotted paths a patch writes: one per leaf value, and one per object it owns whole. */
-export declare function patchKeys(patch: Record<string, unknown>, owned?: string[], prefix?: string): string[];
+export declare function patchKeys(patch: Record<string, unknown>, owned?: string[], keyedArrays?: Record<string, string>, prefix?: string): string[];
 /** Uninstall dotted paths from a document, pruning the objects the removal empties. */
 export declare function removeKeys(document: Record<string, unknown>, keys: readonly string[]): boolean;
 /** The content toolfactory manages, as one string for hashing and comparison. */