rowork 0.1.0

package/dist/commands/make.js

@@ -0,0 +1,181 @@
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { ensureFlameworkPath, generateFile, toClassBase, withSuffix } from "../core/generate.js";
+import { defineCommand, } from "../plugins/api.js";
+import { listStats } from "../core/project-index.js";
+import { answered, prompts, requireInteractive } from "../ui/prompt.js";
+import { askStatLink, resolveStats, serviceMembers } from "./links.js";
+const NAME_ARGUMENT = {
+    name: "name",
+    description: "name of the class, e.g. Inventory (omit it for the guided version)",
+    required: false,
+};
+const FORCE_OPTION = { flags: "-f, --force", description: "overwrite the file if it exists" };
+export function requireProject(context, command) {
+    if (context.projectRoot === undefined || context.config === undefined) {
+        throw new RoworkError(`\`rowork ${command}\` must run inside a Rowork project.`, {
+            hint: "No usable rowork.json found here or in any parent directory. Create a project with `rowork start`.",
+        });
+    }
+    return { root: context.projectRoot, config: context.config };
+}
+/** Validates a name typed in a prompt, using the same rules as the command line. */
+export function validateName(value) {
+    try {
+        toClassBase((value ?? "").trim());
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof RoworkError ? error.message : String(error);
+    }
+}
+/**
+ * The name from the command line, or, in a terminal with none given, from a
+ * question. `undefined` guided means the caller should also ask its other
+ * questions.
+ */
+export async function nameOrAsk(context, command, message, placeholder) {
+    const given = context.args["name"];
+    if (typeof given === "string")
+        return { name: given, guided: false };
+    requireInteractive(command, `rowork ${command} <name>`);
+    const name = answered(await prompts.text({ message, placeholder, validate: validateName })).trim();
+    return { name, guided: true };
+}
+/**
+ * Generates one Flamework class, then makes sure the matching runtime entry
+ * point scans its directory so the class is actually picked up.
+ */
+function generate(options) {
+    const { context } = options;
+    const { root, config } = requireProject(context, options.command);
+    const base = toClassBase(options.name);
+    const className = withSuffix(base, options.suffix);
+    const directory = options.directory(config);
+    const written = generateFile({
+        projectRoot: root,
+        directory,
+        fileName: `${className}.ts`,
+        template: options.template,
+        variables: { className, ...options.extraVariables?.(base) },
+        force: context.options["force"] === true,
+    });
+    context.logger.success(`Created ${options.kind} ${className} (${written ?? directory})`);
+    const runtime = resolveProjectPath(root, join(config.paths.source, options.side, `runtime.${options.side}.ts`));
+    if (ensureFlameworkPath(runtime, directory, context.logger)) {
+        context.logger.step(`registered ${directory} in runtime.${options.side}.ts`);
+    }
+}
+export const makeServiceCommand = defineCommand({
+    name: "make:service",
+    guided: true,
+    description: "Create a service file (server logic) in the right place and register it with Flamework.",
+    arguments: [NAME_ARGUMENT],
+    options: [
+        { flags: "--uses <values>", description: "saved values it uses, comma separated (e.g. kills,coins): injected for you" },
+        FORCE_OPTION,
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "make:service");
+        const { name, guided } = await nameOrAsk(context, "make:service", "What is the service called?", "Inventory");
+        // "Link it to...?": the saved values this service works with, injected for you.
+        const typed = typeof context.options["uses"] === "string"
+            ? context.options["uses"]
+            : guided
+                ? await askStatLink(root, config, "Does it use saved values? Type their names, separated by commas.", false)
+                : undefined;
+        const linked = typed === undefined ? [] : resolveStats(listStats(root, config), typed, "try again");
+        const injected = serviceMembers(root, config, linked);
+        generate({
+            context,
+            command: "make:service",
+            name,
+            kind: "service",
+            suffix: "Service",
+            template: "service",
+            side: "server",
+            directory: (cfg) => cfg.paths.services,
+            extraVariables: () => ({ imports: injected.imports, members: injected.members }),
+        });
+        if (linked.length > 0)
+            context.logger.step(`linked to ${linked.map((stat) => stat.name).join(", ")}: injected in the constructor`);
+    },
+});
+export const makeControllerCommand = defineCommand({
+    name: "make:controller",
+    guided: true,
+    description: "Create a controller file (client logic) in the right place and register it with Flamework.",
+    arguments: [NAME_ARGUMENT],
+    options: [FORCE_OPTION],
+    async run(context) {
+        requireProject(context, "make:controller");
+        const { name } = await nameOrAsk(context, "make:controller", "What is the controller called?", "Camera");
+        generate({
+            context,
+            command: "make:controller",
+            name,
+            kind: "controller",
+            suffix: "Controller",
+            template: "controller",
+            side: "client",
+            directory: (config) => config.paths.controllers,
+        });
+    },
+});
+export const makeComponentCommand = defineCommand({
+    name: "make:component",
+    guided: true,
+    description: "Create a component file (behaviour for tagged objects) in the right place and register it with Flamework.",
+    arguments: [NAME_ARGUMENT],
+    options: [
+        { flags: "--side <side>", description: "server (default) or client" },
+        { flags: "--tag <tag>", description: "CollectionService tag (default: the name)" },
+        FORCE_OPTION,
+    ],
+    async run(context) {
+        requireProject(context, "make:component");
+        const { name, guided } = await nameOrAsk(context, "make:component", "What is the component called?", "Door");
+        let side = context.options["side"] ?? "server";
+        let tag = context.options["tag"];
+        if (guided) {
+            side = answered(await prompts.select({
+                message: "Where does it run?",
+                options: [
+                    { value: "server", label: "Server", hint: "game rules, data, anything players must not cheat" },
+                    { value: "client", label: "Client", hint: "visuals, input, UI" },
+                ],
+                initialValue: "server",
+            }));
+            tag = answered(await prompts.text({
+                message: "Which tag makes it attach to an instance?",
+                placeholder: toClassBase(name),
+                defaultValue: toClassBase(name),
+                validate: (value) => /^[A-Za-z0-9_.-]*$/.test(value ?? "") ? undefined : "Letters, digits, _ - . only.",
+            }));
+        }
+        if (side !== "server" && side !== "client") {
+            throw new RoworkError(`Unknown side \`${String(side)}\`.`, {
+                hint: "Use --side server or --side client.",
+            });
+        }
+        if (typeof tag === "string" && !/^[A-Za-z0-9_.-]+$/.test(tag)) {
+            throw new RoworkError(`\`${tag}\` is not a valid tag.`, {
+                hint: "Use letters, digits, `_`, `-` or `.`.",
+            });
+        }
+        const chosenSide = side;
+        generate({
+            context,
+            command: "make:component",
+            name,
+            kind: "component",
+            suffix: "Component",
+            template: "component",
+            side: chosenSide,
+            directory: (config) => `${config.paths.source}/${chosenSide}/components`,
+            extraVariables: (base) => ({ tag: typeof tag === "string" && tag !== "" ? tag : base }),
+        });
+    },
+});
+//# sourceMappingURL=make.js.map

package/dist/commands/next-steps.d.ts

@@ -0,0 +1,5 @@
+import type { ScaffoldResult } from "../core/scaffold.js";
+import type { Logger } from "../plugins/api.js";
+/** Same closing message for `init` and `start`, so they can never drift apart. */
+export declare function printNextSteps(logger: Logger, directory: string, result: ScaffoldResult): void;
+//# sourceMappingURL=next-steps.d.ts.map

package/dist/commands/next-steps.js

@@ -0,0 +1,18 @@
+import pc from "picocolors";
+/** Same closing message for `init` and `start`, so they can never drift apart. */
+export function printNextSteps(logger, directory, result) {
+    logger.blank();
+    logger.success(`${result.displayName} is ready.`);
+    logger.blank();
+    logger.info("Next steps:");
+    logger.info(`  cd ${directory}`);
+    if (!result.installed)
+        logger.info("  npm install");
+    if (result.lintPending)
+        logger.info("  rowork add lint, rowork add format   (they need npm: run them after npm install)");
+    if (!result.toolchainReady)
+        logger.info("  rokit install");
+    logger.info(`  ${pc.bold("rowork dev")}`);
+    logger.blank();
+}
+//# sourceMappingURL=next-steps.js.map

package/dist/commands/start.d.ts

@@ -0,0 +1,2 @@
+export declare const startCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/start.js

@@ -0,0 +1,144 @@
+import { resolve } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { findExecutable } from "../core/toolchain.js";
+import { assertValidProjectName, toPascalCase } from "../core/naming.js";
+import { resolveTarget, scaffoldProject } from "../core/scaffold.js";
+import { isVinegarInstalled, needsStudioSetup, setupStudio } from "../core/studio.js";
+import { installModulesByName } from "../core/modules.js";
+import { coreModules } from "../modules/index.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, isInteractive, prompts } from "../ui/prompt.js";
+import { printNextSteps } from "./next-steps.js";
+export const startCommand = defineCommand({
+    name: "start",
+    guided: true,
+    description: "Guided setup: answer a few questions and get a ready-to-run project.",
+    options: [{ flags: "--path <dir>", description: "parent directory to create the project in" }],
+    async run(context) {
+        if (!isInteractive()) {
+            throw new RoworkError("`rowork start` is interactive and needs a terminal.", {
+                hint: "In scripts and CI use `rowork init <name>` with its flags instead.",
+            });
+        }
+        prompts.intro(pc.bgCyan(pc.black(" rowork ")) + pc.dim(`  v${context.roworkVersion}`));
+        const name = answered(await prompts.text({
+            message: "What is your game called?",
+            placeholder: "MyGame",
+            validate(value) {
+                try {
+                    assertValidProjectName((value ?? "").trim());
+                }
+                catch (error) {
+                    return error instanceof RoworkError ? error.message : String(error);
+                }
+                return undefined;
+            },
+        })).trim();
+        const parent = resolve(context.cwd, typeof context.options["path"] === "string"
+            ? context.options["path"]
+            : answered(await prompts.text({
+                message: "Where should it be created?",
+                initialValue: ".",
+                defaultValue: ".",
+            })));
+        // Fail on an existing directory now, not after five more questions.
+        try {
+            resolveTarget({ name, parent, force: false });
+        }
+        catch (error) {
+            prompts.cancel(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        const examples = answered(await prompts.confirm({
+            message: "Include an example service and controller?",
+            initialValue: true,
+        }));
+        const git = answered(await prompts.confirm({ message: "Initialise a git repository?", initialValue: true }));
+        const install = answered(await prompts.confirm({
+            message: "Install npm dependencies now? (roblox-ts, Flamework)",
+            initialValue: true,
+        }));
+        // Ready-made features, chosen up front. They install npm packages, so they need npm.
+        let features = [];
+        if (install) {
+            features = answered(await prompts.multiselect({
+                message: "Which ready-made features do you want from the start? (space to tick, enter to confirm. You can add more later with `rowork add`)",
+                // The linter and the formatter are not offered: they are always included.
+                options: coreModules
+                    .filter((module) => module.name !== "lint" && module.name !== "format")
+                    .map((module) => ({ value: module.name, label: module.title, hint: module.description })),
+                required: false,
+            }));
+        }
+        const rokitFound = findExecutable("rokit", context.cwd) !== undefined;
+        let rokit = true;
+        let installRokit = false;
+        if (rokitFound) {
+            rokit = answered(await prompts.confirm({
+                message: "Install the pinned Roblox toolchain with Rokit? (Rojo)",
+                initialValue: true,
+            }));
+        }
+        else {
+            installRokit = answered(await prompts.confirm({
+                message: "Rokit (the Roblox toolchain manager, provides Rojo) is not installed. Download and install it for you? (from github.com/rojo-rbx/rokit into ~/.rokit)",
+                initialValue: true,
+            }));
+            rokit = installRokit;
+        }
+        // Studio has no Linux build: offer Vinegar, which runs the real one.
+        const studio = needsStudioSetup() && !isVinegarInstalled()
+            ? answered(await prompts.confirm({
+                message: "Roblox Studio has no Linux version. Install Vinegar, which runs it through Wine? (Flatpak, current user only)",
+                initialValue: true,
+            }))
+            : false;
+        prompts.note([
+            `Name       ${toPascalCase(name)}`,
+            `Location   ${resolve(parent, name)}`,
+            `Examples   ${examples ? "yes" : "no"}`,
+            `Git        ${git ? "yes" : "no"}`,
+            `npm        ${install ? "install" : "skip"}`,
+            `Quality    ${install ? "linter (ESLint) and formatter (Prettier) included" : "skipped (needs npm)"}`,
+            `Features   ${features.length > 0 ? features.join(", ") : install ? "none" : "skipped (needs npm)"}`,
+            ...(studio ? ["Studio     install Vinegar"] : []),
+            `Rokit      ${installRokit ? "install Rokit, then the toolchain" : rokit ? "install the toolchain" : "skip"}`,
+        ].join("\n"), "Summary");
+        if (!answered(await prompts.confirm({ message: "Create it?", initialValue: true }))) {
+            prompts.cancel("Cancelled, nothing was created.");
+            return;
+        }
+        prompts.log.step("Scaffolding");
+        const result = await scaffoldProject({
+            name,
+            parent,
+            install,
+            lint: true,
+            format: true,
+            rokit,
+            installRokit,
+            git,
+            examples,
+            force: false,
+            roworkVersion: context.roworkVersion,
+        }, context.logger);
+        if (features.length > 0 && result.installed) {
+            prompts.log.step("Adding features");
+            await installModulesByName(context, result.target, features);
+        }
+        if (studio) {
+            try {
+                await setupStudio({ logger: context.logger, projectRoot: result.target, plugin: true });
+            }
+            catch (error) {
+                // The project is already created: a Studio problem must not undo that.
+                context.logger.warn(`Studio setup did not finish: ${error instanceof Error ? error.message : String(error)}`);
+                context.logger.info("Retry with `rowork studio:setup`.");
+            }
+        }
+        printNextSteps(context.logger, name, result);
+        prompts.outro("Happy building.");
+    },
+});
+//# sourceMappingURL=start.js.map

package/dist/commands/studio.d.ts

@@ -0,0 +1,3 @@
+export declare const studioCommand: import("../plugins/api.js").CommandDefinition;
+export declare const studioSetupCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=studio.d.ts.map

package/dist/commands/studio.js

@@ -0,0 +1,45 @@
+import { RoworkError } from "../cli/errors.js";
+import { isVinegarInstalled, launchStudio, needsStudioSetup, setupStudio, } from "../core/studio.js";
+import { defineCommand } from "../plugins/api.js";
+function requireLinux(command) {
+    if (!needsStudioSetup()) {
+        throw new RoworkError(`\`rowork ${command}\` is only needed on Linux.`, {
+            hint: "Roblox Studio runs natively on Windows and macOS: install it from roblox.com/create.",
+        });
+    }
+}
+export const studioCommand = defineCommand({
+    name: "studio",
+    description: "Launch Roblox Studio on Linux (through Vinegar).",
+    run(context) {
+        requireLinux("studio");
+        if (!isVinegarInstalled()) {
+            throw new RoworkError("Vinegar (Roblox Studio for Linux) is not installed.", {
+                hint: "Run `rowork studio:setup` first.",
+            });
+        }
+        launchStudio();
+        context.logger.success("Launching Roblox Studio through Vinegar.");
+        context.logger.info("The first launch downloads Studio, and you sign in to Roblox in the browser.");
+    },
+});
+export const studioSetupCommand = defineCommand({
+    name: "studio:setup",
+    description: "Install Roblox Studio for Linux (Vinegar) and the Rojo plugin.",
+    options: [{ flags: "--no-plugin", description: "skip installing the Rojo plugin" }],
+    async run(context) {
+        requireLinux("studio:setup");
+        const result = await setupStudio({
+            logger: context.logger,
+            projectRoot: context.projectRoot,
+            plugin: context.options["plugin"] !== false,
+        });
+        context.logger.blank();
+        context.logger.success("Vinegar is ready.");
+        context.logger.info("Next: `rowork studio` to launch it, then `rowork dev` in your project.");
+        if (!result.pluginInstalled && context.options["plugin"] !== false) {
+            context.logger.info("The Rojo plugin will be installed by re-running `rowork studio:setup` after the first launch.");
+        }
+    },
+});
+//# sourceMappingURL=studio.js.map

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare const updateCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/update.js

@@ -0,0 +1,173 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import pc from "picocolors";
+import { RoworkError } from "../cli/errors.js";
+import { run as runBinary } from "../core/exec.js";
+import { pinnedTypescriptVersion } from "../core/scaffold.js";
+import { findStoreRojoPlugin, findStudioDataDirectories, installRojoPlugin, isVinegarInstalled, needsStudioSetup, warnAboutStorePlugin, } from "../core/studio.js";
+import { findExecutable } from "../core/toolchain.js";
+import { baseVersion, latestNpmVersion, latestRojoVersion, readRojoPin, writeRojoPin, } from "../core/versions.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, isInteractive, prompts } from "../ui/prompt.js";
+import { requireProject } from "./make.js";
+export const updateCommand = defineCommand({
+    name: "update",
+    description: "Move the project to the latest Rojo, npm packages and Studio plugin.",
+    guided: true,
+    options: [
+        { flags: "--dry-run", description: "show what would change and change nothing" },
+        { flags: "--yes", description: "do not ask for confirmation" },
+        { flags: "--no-npm", description: "leave the npm packages alone" },
+        { flags: "--no-build", description: "do not compile afterwards to check the result" },
+    ],
+    async run(context) {
+        const { root } = requireProject(context, "update");
+        const { logger } = context;
+        // ---- what is behind
+        const rojoNow = readRojoPin(root);
+        const rojoLatest = await latestRojoVersion();
+        const rojoBehind = rojoNow !== undefined && rojoLatest !== undefined && rojoNow !== rojoLatest;
+        const npmChanges = [];
+        if (context.options["npm"] !== false) {
+            const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+            const groups = [
+                [manifest.dependencies, false],
+                [manifest.devDependencies, true],
+            ];
+            for (const [packages, dev] of groups) {
+                for (const [name, range] of Object.entries(packages ?? {})) {
+                    // roblox-ts pins one exact TypeScript and patches it: it is set from roblox-ts below.
+                    if (name === "typescript")
+                        continue;
+                    const latest = latestNpmVersion(name);
+                    if (latest !== undefined && baseVersion(range) !== latest) {
+                        npmChanges.push({ name, from: baseVersion(range), to: latest, dev });
+                    }
+                }
+            }
+        }
+        if (rojoLatest === undefined)
+            logger.warn("Could not look up the latest Rojo (is GitHub reachable?): skipping it.");
+        if (!rojoBehind && npmChanges.length === 0) {
+            logger.success("Everything is already up to date.");
+            return;
+        }
+        logger.info(pc.bold("Updates available:"));
+        if (rojoBehind)
+            logger.step(`Rojo  ${pc.dim(rojoNow ?? "")} -> ${pc.green(rojoLatest ?? "")}  (rokit.toml, and the Studio plugin)`);
+        for (const change of npmChanges)
+            logger.step(`${change.name}  ${pc.dim(change.from)} -> ${pc.green(change.to)}`);
+        logger.blank();
+        if (context.options["dryRun"] === true) {
+            logger.info("Dry run: nothing was changed.");
+            return;
+        }
+        if (context.options["yes"] !== true) {
+            if (!isInteractive()) {
+                throw new RoworkError("`rowork update` asks for confirmation.", {
+                    hint: "Outside a terminal, add --yes (and --dry-run first to preview).",
+                });
+            }
+            const confirmed = answered(await prompts.confirm({
+                message: "Apply these updates? (commit or back up your project first: `git diff` shows what changed)",
+                initialValue: true,
+            }));
+            if (!confirmed) {
+                prompts.cancel("Nothing changed.");
+                return;
+            }
+        }
+        // ---- Rojo
+        // All or nothing. A pin that names a Rojo that is not installed breaks
+        // `rowork dev` (the Rokit shim has nothing to run), so the pin only stays
+        // changed if the install worked, and the Studio plugin, which must match
+        // the server, is only touched then too.
+        let rojoMoved = false;
+        if (rojoBehind && rojoLatest !== undefined && rojoNow !== undefined) {
+            writeRojoPin(root, rojoLatest);
+            const rokit = findExecutable("rokit", root);
+            if (rokit === undefined) {
+                // No Rokit means no shim to break: keep the pin, the user installs later.
+                rojoMoved = true;
+                logger.step(`rokit.toml now pins Rojo ${rojoLatest}`);
+                logger.warn("Rokit was not found: install it, then run `rokit install` to get the new Rojo.");
+            }
+            else {
+                try {
+                    await runBinary(rokit, ["trust", "rojo-rbx/rojo"], { cwd: root, stdio: "ignore" });
+                    await runBinary(rokit, ["install"], { cwd: root });
+                    rojoMoved = true;
+                    logger.step(`Rojo ${rojoLatest} installed and pinned in rokit.toml`);
+                }
+                catch {
+                    writeRojoPin(root, rojoNow);
+                    logger.warn(`Could not install Rojo ${rojoLatest} (usually a network problem): kept ${rojoNow}, so your project still works.`);
+                    logger.info("Run `rowork update` again later. The Studio plugin was left as it is, to keep matching your Rojo.");
+                    process.exitCode = 1;
+                }
+            }
+        }
+        // ---- npm packages
+        if (npmChanges.length > 0) {
+            for (const dev of [false, true]) {
+                const names = npmChanges.filter((change) => change.dev === dev).map((change) => `${change.name}@latest`);
+                if (names.length === 0)
+                    continue;
+                logger.step(`installing ${names.length} ${dev ? "dev " : ""}package${names.length > 1 ? "s" : ""} (npm)`);
+                await runBinary("npm", ["install", ...(dev ? ["--save-dev"] : []), ...names], { cwd: root });
+            }
+            // roblox-ts may now want a different TypeScript.
+            const typescript = pinnedTypescriptVersion(root);
+            if (typescript !== undefined) {
+                await runBinary("npm", ["install", "--save-dev", `typescript@${typescript}`], { cwd: root });
+            }
+        }
+        // ---- Studio plugin: it must match the Rojo server
+        if (rojoMoved) {
+            if (needsStudioSetup()) {
+                const directories = findStudioDataDirectories();
+                if (isVinegarInstalled() && directories.length > 0) {
+                    try {
+                        await installRojoPlugin(directories, root, logger);
+                        logger.info("Restart Studio to load the new plugin.");
+                        if (findStoreRojoPlugin() !== undefined)
+                            warnAboutStorePlugin(logger);
+                    }
+                    catch (error) {
+                        logger.warn(`Could not update the Rojo plugin: ${error instanceof Error ? error.message : String(error)}. Run \`rowork studio:setup\`.`);
+                    }
+                }
+                else {
+                    logger.warn("Studio's Rojo plugin was not updated (Studio has not been launched yet). Run `rowork studio:setup` after launching it.");
+                }
+            }
+            else if (findExecutable("rojo", root) !== undefined) {
+                try {
+                    await runBinary("rojo", ["plugin", "install"], { cwd: root });
+                    logger.info("Restart Studio to load the new plugin.");
+                }
+                catch {
+                    logger.warn("`rojo plugin install` did not finish. Run it yourself, then restart Studio.");
+                }
+            }
+        }
+        // ---- did it break anything?
+        if (context.options["build"] !== false && npmChanges.length > 0) {
+            logger.step("compiling to check the updated packages");
+            try {
+                await runBinary("npm", ["run", "build"], { cwd: root });
+                logger.success("Updated, and the project still compiles.");
+            }
+            catch {
+                logger.blank();
+                logger.warn("The project does not compile with the updated packages.");
+                logger.info("A newer package changed something. `git diff package.json` shows what moved; `git checkout package.json package-lock.json && npm install` goes back.");
+                process.exitCode = 1;
+            }
+        }
+        else {
+            logger.success("Updated.");
+        }
+    },
+});
+//# sourceMappingURL=update.js.map

package/dist/commands/wire.d.ts

@@ -0,0 +1,2 @@
+export declare const wireCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=wire.d.ts.map

package/dist/commands/wire.js

@@ -0,0 +1,34 @@
+import { applyPendingIntegrations, pendingIntegrations } from "../core/modules.js";
+import { syncAgentDocs } from "../core/agent-docs.js";
+import { loadConfig } from "../core/config.js";
+import { defineCommand } from "../plugins/api.js";
+import { requireProject } from "./make.js";
+export const wireCommand = defineCommand({
+    name: "wire",
+    description: "Connect the installed modules that work together (done automatically by `rowork add`).",
+    options: [{ flags: "--dry-run", description: "list what would be wired and change nothing" }],
+    async run(context) {
+        const { root, config } = requireProject(context, "wire");
+        const pending = pendingIntegrations(config);
+        if (pending.length === 0) {
+            context.logger.info("Everything that can be wired together already is.");
+            return;
+        }
+        if (context.options["dryRun"] === true) {
+            for (const integration of pending) {
+                context.logger.step(`${integration.title}: ${integration.description} (${integration.modules.join(" + ")})`);
+            }
+            context.logger.info("Dry run: nothing was changed.");
+            return;
+        }
+        const applied = await applyPendingIntegrations(context, root);
+        if (applied.length > 0) {
+            syncAgentDocs(root, loadConfig(root), context.roworkVersion);
+            context.logger.success(`Wired: ${applied.join(", ")}.`);
+        }
+        else {
+            process.exitCode = 1;
+        }
+    },
+});
+//# sourceMappingURL=wire.js.map

package/dist/core/agent-docs.d.ts

@@ -0,0 +1,23 @@
+import type { RoworkConfig } from "../plugins/api.js";
+export declare const AGENTS_FILE = "AGENTS.md";
+export declare const CLAUDE_FILE = "CLAUDE.md";
+/**
+ * The block Rowork owns in AGENTS.md.
+ *
+ * Built from live data (the registered commands, the installed modules) so it
+ * cannot drift from what the project really offers. It is written for two
+ * readers at once: a person learning the project, and an AI about to change it.
+ */
+export declare function renderManagedSection(config: RoworkConfig, roworkVersion: string): string;
+/**
+ * Creates or refreshes AGENTS.md (and a CLAUDE.md that points to it).
+ *
+ * Only the block between the markers is rewritten: anything the user wrote
+ * around it stays. An existing CLAUDE.md is never touched. Claude Code reads
+ * CLAUDE.md and most other agents read AGENTS.md, so one file holds the content
+ * and the other imports it.
+ */
+export declare function syncAgentDocs(projectRoot: string, config: RoworkConfig, roworkVersion: string): string[];
+/** Removes the Rowork block when leaving Rowork; deletes files that held nothing else. */
+export declare function removeAgentDocs(projectRoot: string): string[];
+//# sourceMappingURL=agent-docs.d.ts.map