toolfactory 0.1.1

package/dist/commands.test.js

@@ -0,0 +1,215 @@
+/**
+ * The command layer's own behaviour: the step runner behind `gate`/`package`, the `gh`
+ * invocations `init --repo` makes (dry-run only — `gh` is not installed here and
+ * api.github.com is unreachable, so the shape is proved, never the call), and what `init`
+ * leaves behind in a real directory.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import * as commands from "./commands.js";
+import { createRepo } from "./hosts/github.js";
+import { assertNoSensitiveArgument, defaultSurfaces, ToolConfigSchema, } from "./model.js";
+import { RELOAD } from "./surfaces/agents.js";
+function project(surfaces) {
+    return {
+        root: "/repo",
+        tool: {
+            schemaVersion: 1,
+            identity: "plugin.json",
+            binding: "typescript",
+            surfaces,
+            bundle: { runtime: "package" },
+            tests: { examples: {} },
+        },
+        identity: { name: "probe", version: "0.1.0", description: "A probe tool" },
+        identityExtra: {},
+        operations: [],
+        toolfactoryVersion: "0.1.0",
+    };
+}
+const environment = { ...process.env };
+afterEach(() => {
+    process.env = { ...environment };
+});
+describe("runSteps", () => {
+    it("runs in order, skips CI-only provisioning, and stops at the first failure", () => {
+        const { steps } = commands.runSteps(tmpdir(), [
+            { name: "first", run: "true" },
+            { name: "provisioning", run: "exit 1", when: "ci" },
+            { name: "boom", run: "exit 3" },
+            { name: "never", run: "true" },
+        ]);
+        expect(steps.map((step) => [step.name, step.ok])).toEqual([
+            ["first", true],
+            ["boom", false],
+        ]);
+        expect(steps.every((step) => step.durationMs >= 0)).toBe(true);
+    });
+});
+describe("createRepo", () => {
+    it("dry-runs the exact gh invocations: private, from the checkout, one topic per surface", () => {
+        expect(createRepo(project(["skill", "mcp", "openclaw-native", "cli"]), {
+            slug: "GoatInAHat/probe",
+            dryRun: true,
+        })).toEqual({
+            repository: "GoatInAHat/probe",
+            visibility: "private",
+            topics: ["agent-skill", "mcp-server", "openclaw-plugin", "toolfactory"],
+            commands: [
+                'gh repo create GoatInAHat/probe --private --description "A probe tool" --source . --remote origin --push',
+                "gh repo edit GoatInAHat/probe --add-topic agent-skill,mcp-server,openclaw-plugin,toolfactory",
+            ],
+            dryRun: true,
+        });
+    });
+    it("makes the repository public only when asked", () => {
+        const { commands: lines } = createRepo(project(["mcp"]), {
+            slug: "GoatInAHat/probe",
+            public: true,
+            dryRun: true,
+        });
+        expect(lines[0]).toContain("--public");
+        expect(lines[0]).not.toContain("--private");
+    });
+});
+describe("init", () => {
+    it("initialises a git repository, commits, and reports the reload line of this harness", () => {
+        const dir = mkdtempSync(join(tmpdir(), "toolfactory-init-"));
+        process.env.CLAUDECODE = "1";
+        // No git identity, as on a CI runner: the first commit must still land.
+        process.env.GIT_CONFIG_GLOBAL = "/dev/null";
+        process.env.GIT_CONFIG_SYSTEM = "/dev/null";
+        // `setup: false`: `.agents/setup` installs dependencies, which belongs to the end-to-end
+        // proof in a real project, not to a unit test.
+        const result = commands.init({
+            root: dir,
+            name: "probe",
+            binding: "typescript",
+            surfaces: ["cli"],
+            repo: "GoatInAHat/probe",
+            dryRun: true,
+            setup: false,
+        });
+        expect(existsSync(join(dir, ".git"))).toBe(true);
+        expect(execFileSync("git", ["log", "--format=%s"], { cwd: dir, encoding: "utf8" }).trim()).toBe("toolfactory init");
+        expect(result.repository?.commands[0]).toBe("gh repo create GoatInAHat/probe --private --source . --remote origin --push");
+        // Nothing ran: no remote, and no live-tests bootstrap without a declared credential.
+        expect(execFileSync("git", ["remote"], { cwd: dir, encoding: "utf8" }).trim()).toBe("");
+        expect(result.repository?.secrets).toEqual([]);
+        expect(result.nextSteps[1]).toBe(RELOAD.find((row) => row.harness === "Claude Code")?.line);
+        expect(result.nextSteps[2]).toContain("src/ops.ts");
+        // `keywords` defaults to `[name]` — Kiro Powers and Agent Plugins key activation off it —
+        // and lands in the scaffolded identity file (`package.json`, here) like the rest of identity.
+        expect(JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).keywords).toEqual(["probe"]);
+        // Asked for nothing, init selects the skills-first minimum; host plugins are opt-in.
+        expect(defaultSurfaces("python")).toEqual(["skill", "agent-plugins", "mcp", "cli", "pypi"]);
+    });
+    it("creates an instruction-only Codex plugin without a generated runtime", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "toolfactory-instructions-"));
+        const result = commands.init({
+            root: dir,
+            name: "paper-viz",
+            binding: "typescript",
+            runtime: "none",
+            surfaces: ["skill", "codex"],
+            git: false,
+            setup: false,
+        });
+        expect(existsSync(join(dir, "package.json"))).toBe(false);
+        expect(existsSync(join(dir, "src/toolfactory/mcp.ts"))).toBe(false);
+        expect(existsSync(join(dir, "mcp.json"))).toBe(false);
+        expect(JSON.parse(readFileSync(join(dir, ".codex-plugin/plugin.json"), "utf8"))).not.toHaveProperty("mcpServers");
+        expect(readFileSync(join(dir, "skills/paper-viz/SKILL.md"), "utf8")).not.toContain("No operations yet");
+        expect(result.nextSteps[2]).toContain("SKILL.md");
+        await expect(commands.check(dir)).resolves.toBeDefined();
+    });
+    it("refuses runtime none with a surface that needs an executable payload", () => {
+        expect(() => ToolConfigSchema.parse({
+            schemaVersion: 1,
+            identity: "plugin.json",
+            binding: "typescript",
+            runtime: "none",
+            surfaces: ["skill", "mcp"],
+        })).toThrow(/skill and codex surfaces/);
+    });
+});
+describe("secrets", () => {
+    it("inventories the tool's sensitive keys and the registries' tokens — presence only, never a value", () => {
+        const dir = mkdtempSync(join(tmpdir(), "toolfactory-secrets-"));
+        writeFileSync(join(dir, ".env"), "API_KEY=canary-3f9a\n");
+        const target = project(["cli", "npm"]);
+        target.root = dir;
+        target.tool.config = {
+            type: "object",
+            properties: {
+                api_key: {
+                    type: "string",
+                    "x-toolfactory": { sensitive: true, url: "https://example.com/keys" },
+                },
+            },
+            required: ["api_key"],
+        };
+        const report = commands.secretsReport(target);
+        expect(report.secrets.map((secret) => secret.name)).toEqual(["API_KEY", "NPM_TOKEN"]);
+        expect(report.secrets[0]).toMatchObject({
+            kind: "config",
+            required: true,
+            local: true,
+            url: "https://example.com/keys",
+        });
+        expect(report.secrets[1]).toMatchObject({
+            kind: "release",
+            required: false,
+            local: false,
+            needs: ["npm"],
+        });
+        expect(JSON.stringify(report)).not.toContain("canary-3f9a");
+    });
+    it("refuses an operation input named like a sensitive config key", () => {
+        const login = {
+            name: "login",
+            inputSchema: { type: "object", properties: { password: { type: "string" } } },
+            requires: [],
+        };
+        expect(() => assertNoSensitiveArgument({ properties: { password: { type: "string", "x-toolfactory": { sensitive: true } } } }, [login])).toThrow(/"login" declares an input named "password"/);
+    });
+});
+describe("unpublish", () => {
+    it("diffs tool.json against the previous tag and retracts what a dropped surface published", () => {
+        const dir = mkdtempSync(join(tmpdir(), "toolfactory-unpublish-"));
+        process.env.GIT_CONFIG_GLOBAL = "/dev/null";
+        process.env.GIT_CONFIG_SYSTEM = "/dev/null";
+        commands.init({
+            root: dir,
+            name: "probe",
+            binding: "typescript",
+            surfaces: ["cli", "npm"],
+            dryRun: true,
+            setup: false,
+        });
+        const git = (...args) => execFileSync("git", args, {
+            cwd: dir,
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                GIT_AUTHOR_NAME: "t",
+                GIT_AUTHOR_EMAIL: "t@example.com",
+                GIT_COMMITTER_NAME: "t",
+                GIT_COMMITTER_EMAIL: "t@example.com",
+            },
+        });
+        git("tag", "v0.1.0");
+        const toolPath = join(dir, "dev.toolfactory", "tool.json");
+        const tool = JSON.parse(readFileSync(toolPath, "utf8"));
+        tool.surfaces = tool.surfaces.filter((surface) => surface !== "npm");
+        writeFileSync(toolPath, JSON.stringify(tool, null, 2));
+        git("commit", "-qam", "drop npm");
+        git("tag", "v0.2.0");
+        const result = commands.unpublish(dir, { dryRun: true });
+        expect(result.dropped).toEqual(["npm"]);
+        expect(result.steps.some((step) => step.run.includes("npm deprecate probe@'*'"))).toBe(true);
+    });
+});

package/dist/e2e.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/e2e.test.js

@@ -0,0 +1,124 @@
+/**
+ * Real end-to-end: init a fresh tool, introspect the real kernel over stdio, build,
+ * check for drift, and run the generated CLI as a user would. Skips when this repo's
+ * own node_modules isn't around to symlink in (no dependencies to run against).
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, symlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import * as commands from "./commands.js";
+const repoRoot = join(fileURLToPath(new URL(".", import.meta.url)), "..");
+const repoNodeModules = join(repoRoot, "node_modules");
+describe.skipIf(!existsSync(repoNodeModules))("end-to-end: init -> introspect -> build -> check -> run", () => {
+    it("scaffolds a real tool, snapshots its kernel, builds clean, and answers a real CLI call", {
+        timeout: 120_000,
+    }, async () => {
+        const dir = mkdtempSync(join(tmpdir(), "toolfactory-e2e-"));
+        symlinkSync(repoNodeModules, join(dir, "node_modules"), "dir");
+        const surfaces = ["skill", "agent-plugins", "claude", "mcp", "cli", "npm"];
+        const init = commands.init({
+            root: dir,
+            name: "hello",
+            binding: "typescript",
+            surfaces,
+            setup: false,
+        });
+        expect(init.written).toContain("dev.toolfactory/tool.json");
+        expect(init.written).toContain("src/ops.ts");
+        const snapshot = await commands.introspect(dir);
+        expect(snapshot.ops.tools.map((t) => t.name)).toEqual(["echo"]);
+        const echo = snapshot.ops.tools[0];
+        expect(echo.inputSchema.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
+        expect(echo.outputSchema?.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
+        commands.build(dir);
+        await expect(commands.check(dir)).resolves.toBeDefined();
+        const opsOnDisk = JSON.parse(readFileSync(join(dir, "dev.toolfactory/ops.json"), "utf8"));
+        expect(opsOnDisk.tools.map((t) => t.name)).toEqual(["echo"]);
+        const output = execFileSync(process.execPath, ["--import", "tsx", "src/toolfactory/cli.ts", "echo", "--text", "hi"], { cwd: dir, encoding: "utf8" });
+        expect(JSON.parse(output)).toEqual({ text: "hi" });
+    });
+});
+/** Every file in the tree except the test's own scaffolding, as path → content (a link's target). */
+function tree(root, dir = root) {
+    const files = {};
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name === ".git")
+            continue;
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            Object.assign(files, tree(root, path));
+        else if (entry.isSymbolicLink())
+            files[relative(root, path)] = readlinkSync(path);
+        else
+            files[relative(root, path)] = readFileSync(path, "utf8");
+    }
+    return files;
+}
+function scratch() {
+    const dir = mkdtempSync(join(tmpdir(), "toolfactory-confluence-"));
+    symlinkSync(repoNodeModules, join(dir, "node_modules"), "dir");
+    return dir;
+}
+/** The one thing a projector may never write: a paragraph, in the body a region file leaves alone. */
+const PROSE_ANCHOR = "Explain here when an agent should reach for this tool";
+const PROSE = "Reach for it when a demo needs a real tool, not a mock.";
+function authorProse(root) {
+    const path = join(root, "skills/hello/SKILL.md");
+    const text = readFileSync(path, "utf8");
+    writeFileSync(path, text.replace(PROSE_ANCHOR, `${PROSE}\n\n${PROSE_ANCHOR}`));
+}
+function setSurfaces(root, surfaces) {
+    const path = join(root, "dev.toolfactory/tool.json");
+    writeFileSync(path, `${JSON.stringify({ ...JSON.parse(readFileSync(path, "utf8")), surfaces }, null, 2)}\n`);
+}
+/**
+ * Confluence: a tool that got where it is by editing, toggling and adopting is byte-identical to
+ * one generated from its `tool.json` in a single step. Every generated file therefore carries its
+ * own inverse — an orphan its deletion, a merge file the keys the lock records — and the drift
+ * gate is complete: a clean `check` means the tree is exactly what a fresh build would write.
+ */
+describe.skipIf(!existsSync(repoNodeModules))("confluence: a walked tree equals a fresh one", () => {
+    it("converges on the same tree as init + build of the final tool.json", {
+        timeout: 180_000,
+    }, async () => {
+        const identity = {
+            name: "hello",
+            binding: "typescript",
+            repository: "https://github.com/toolfactory/hello",
+        };
+        const start = ["skill", "cli", "npm", "mcp-registry"];
+        const end = ["skill", "cli", "npm"];
+        const walked = scratch();
+        commands.init({ ...identity, root: walked, surfaces: start, setup: false });
+        await commands.introspect(walked);
+        setSurfaces(walked, end);
+        commands.build(walked);
+        // The region inverse: deselecting `skill` empties its regions instead of deleting the file
+        // the author writes prose in, and re-selecting refills the markers the strip preserved.
+        authorProse(walked);
+        setSurfaces(walked, end.filter((id) => id !== "skill"));
+        expect(commands.build(walked).result.stripped).toEqual(["skills/hello/SKILL.md"]);
+        const husk = readFileSync(join(walked, "skills/hello/SKILL.md"), "utf8");
+        expect(husk).toContain(PROSE);
+        expect(husk).toContain("<!-- tf:operations --><!-- /tf:operations -->");
+        expect(husk).not.toContain("## Operations");
+        expect(lstatSync(join(walked, ".agents/skills/hello"), { throwIfNoEntry: false })).toBeUndefined();
+        await expect(commands.check(walked)).resolves.toBeDefined();
+        setSurfaces(walked, end);
+        commands.build(walked);
+        commands.adopt(walked, "COVERAGE.md");
+        writeFileSync(join(walked, "COVERAGE.md"), "hand-written while adopted\n");
+        commands.build(walked);
+        commands.unadopt(walked, "COVERAGE.md");
+        commands.build(walked);
+        const fresh = scratch();
+        commands.init({ ...identity, root: fresh, surfaces: end, setup: false });
+        await commands.introspect(fresh);
+        authorProse(fresh);
+        commands.build(fresh);
+        expect(tree(walked)).toEqual(tree(fresh));
+    });
+});

package/dist/hosts/browser.d.ts

@@ -0,0 +1,10 @@
+import type { Project } from "../model.js";
+export declare const DRIFT_ENTRY: string;
+/**
+ * Drift lines (empty means the generator still writes what BROWSER_SCAFFOLD pins) and the icons
+ * copied into the project because it had none.
+ */
+export declare function mirrorScaffold(project: Project): {
+    drift: string[];
+    seeded: string[];
+};

package/dist/hosts/browser.js

@@ -0,0 +1,94 @@
+/**
+ * The I/O half of the browser-extension surface: §8 C2, "mirror scaffolds by execution, not
+ * transcription". Runs the real `wxt init` into a temp directory and checks that everything it
+ * writes still agrees with BROWSER_SCAFFOLD, so an upstream template change is inherited on the
+ * next toolfactory release instead of silently rotting in a constant.
+ *
+ * The same run also seeds the project's placeholder icon set. Those five PNGs are WXT's binary
+ * files, not toolfactory's, and a pure `plan()` can only emit text — so they are copied out of
+ * the fresh scaffold when the project is missing them, exactly as the shadcn CLI (not the web
+ * surface) writes the components under `web/src/components/ui/`.
+ *
+ * Runnable as a script (`node dist/hosts/browser.js <root>`) because that is how the surface's
+ * `validate()` step reaches it: one Command like every other validator.
+ */
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { argv, exit, stderr, stdout } from "node:process";
+import { fileURLToPath } from "node:url";
+import { loadProject } from "../project/load.js";
+import { BROWSER_SCAFFOLD, HOST_DIR, WXT_PIN } from "../surfaces/browser-extension.js";
+export const DRIFT_ENTRY = fileURLToPath(import.meta.url);
+/** Where WXT's auto-detection looks for the icon set, and therefore where the scaffold writes it. */
+const ICON_DIR = "public/icon";
+function differs(label, upstream, pinned) {
+    return JSON.stringify(upstream) === JSON.stringify(pinned)
+        ? []
+        : [`${label}: \`wxt init\` and BROWSER_SCAFFOLD no longer agree`];
+}
+/**
+ * Drift lines (empty means the generator still writes what BROWSER_SCAFFOLD pins) and the icons
+ * copied into the project because it had none.
+ */
+export function mirrorScaffold(project) {
+    const directory = mkdtempSync(join(tmpdir(), "toolfactory-browser-"));
+    const probe = join(directory, "probe");
+    // Prefer the wxt the extension pins as a devDependency over a fresh download.
+    const pinned = join(project.root, HOST_DIR, "node_modules/.bin/wxt");
+    try {
+        execFileSync(existsSync(pinned) ? pinned : "npx", [
+            ...(existsSync(pinned) ? [] : ["--yes", `wxt@${WXT_PIN}`]),
+            "init",
+            probe,
+            "--template",
+            BROWSER_SCAFFOLD.template,
+            "--pm",
+            BROWSER_SCAFFOLD.packageManager,
+        ], { stdio: "pipe" });
+        const scaffold = (path) => readFileSync(join(probe, path), "utf8");
+        const packageJson = JSON.parse(scaffold("package.json"));
+        const icons = join(project.root, HOST_DIR, ICON_DIR);
+        const seeded = BROWSER_SCAFFOLD.icons.flatMap((size) => {
+            const name = `${size}.png`;
+            if (!existsSync(join(probe, ICON_DIR, name)))
+                return [];
+            if (existsSync(join(icons, name)))
+                return [];
+            mkdirSync(icons, { recursive: true });
+            copyFileSync(join(probe, ICON_DIR, name), join(icons, name));
+            return [`${ICON_DIR}/${name}`];
+        });
+        return {
+            drift: [
+                ...["scripts", "dependencies", "devDependencies"].flatMap((key) => differs(`package.json ${key}`, packageJson[key], BROWSER_SCAFFOLD.packageJson[key])),
+                ...(scaffold("tsconfig.json") === BROWSER_SCAFFOLD.tsconfig
+                    ? []
+                    : ["tsconfig.json: the template no longer writes what BROWSER_SCAFFOLD.tsconfig pins"]),
+                ...(scaffold(".gitignore") === BROWSER_SCAFFOLD.gitignore
+                    ? []
+                    : [".gitignore: the template no longer writes what BROWSER_SCAFFOLD.gitignore pins"]),
+                ...BROWSER_SCAFFOLD.icons.flatMap((size) => existsSync(join(probe, ICON_DIR, `${size}.png`))
+                    ? []
+                    : [`${ICON_DIR}/${size}.png: the template no longer ships this icon`]),
+            ],
+            seeded,
+        };
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+}
+if (argv[1] === DRIFT_ENTRY) {
+    const { drift, seeded } = mirrorScaffold(loadProject(argv[2] ?? "."));
+    for (const path of seeded)
+        stdout.write(`copied WXT's ${path} into ${HOST_DIR}\n`);
+    if (drift.length) {
+        stderr.write(`the wxt scaffold drifted upstream; update BROWSER_SCAFFOLD in src/surfaces/browser-extension.ts:\n${drift
+            .map((line) => `  ${line}`)
+            .join("\n")}\n`);
+        exit(1);
+    }
+    stdout.write(`wxt init still matches src/surfaces/browser-extension.ts\n`);
+}

package/dist/hosts/github.d.ts

@@ -0,0 +1,66 @@
+import type { Project, SurfaceId } from "../model.js";
+/** The GitHub environment the generated `live` job deploys to. */
+export declare const LIVE_ENVIRONMENT = "live-tests";
+export interface BootstrapOptions {
+    /** `owner/repo` to prepare; the default is the identity file's repository URL. */
+    repository?: string;
+    /** GitHub logins that must approve a live run. Empty leaves the environment ungated. */
+    reviewers?: string[];
+    /** Where the secret values come from; defaults to `<root>/.env`. */
+    envFile?: string;
+    /**
+     * Names the release registries consume, at repository scope — `registries(project)`'s union,
+     * passed in so this file stays a `gh` driver and the table stays in `project/gate.ts`.
+     */
+    releaseSecrets?: string[];
+    /** The one-time human steps to print at the end; `manualSteps(project)`'s list. */
+    manual?: string[];
+    /** Print the `gh` invocations instead of running them. */
+    dryRun?: boolean;
+}
+export interface BootstrapResult {
+    /** `owner/repo`, from the identity file's repository URL. */
+    repository: string;
+    environment: string;
+    reviewers: string[];
+    /** Names of the secrets written, in `gh` order. Never their values. */
+    secrets: string[];
+    /** Declared names with no value in `.env`: reported, never fatal — the rest of the run still lands. */
+    missing: string[];
+    /** Every `gh` invocation, in order, as it is (or would be) run. */
+    commands: string[];
+    /** The one-time human steps no API can do, each with its URL. */
+    manual: string[];
+    dryRun: boolean;
+}
+/** `owner/repo` from a GitHub URL or `git@` remote. */
+export declare function githubSlug(repository: string | undefined): string | undefined;
+export declare function bootstrapRepo(project: Project, options?: BootstrapOptions): BootstrapResult;
+/**
+ * One GitHub topic per selected surface, so a repository `init` creates is discoverable as what
+ * it actually ships. Surfaces that only package the same tool (`cli`, `npm`, `pypi`, `web`,
+ * `clawhub`, `workflows`) name no ecosystem and get none.
+ */
+export declare const SURFACE_TOPICS: Partial<Record<SurfaceId, string>>;
+export interface CreateRepoOptions {
+    /** `owner/name` of the repository to create. */
+    slug: string;
+    /** Public instead of the private default. */
+    public?: boolean;
+    /** Print the `gh` invocations instead of running them. */
+    dryRun?: boolean;
+}
+export interface CreateRepoResult {
+    repository: string;
+    visibility: "private" | "public";
+    topics: string[];
+    /** Every `gh` invocation, in order, as it is (or would be) run. */
+    commands: string[];
+    dryRun: boolean;
+}
+/**
+ * Create the repository from the checkout and push it: `gh repo create --source --remote --push`,
+ * private unless asked otherwise, then one `gh repo edit --add-topic` for the selected surfaces.
+ * `gh` is the only GitHub client (§8 C1); nothing here talks to the API directly.
+ */
+export declare function createRepo(project: Project, options: CreateRepoOptions): CreateRepoResult;