@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/cjs/ultramodern-workspace/write-workspace.cjs

@@ -0,0 +1,232 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCompactUltramodernConfig: ()=>createCompactUltramodernConfig,
+    generateUltramodernWorkspace: ()=>generateUltramodernWorkspace,
+    writeApp: ()=>external_write_app_cjs_namespaceObject.writeApp
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_ultramodern_release_cohort_cjs_namespaceObject = require("../ultramodern-release-cohort.cjs");
+const transaction_cjs_namespaceObject = require("./add-vertical/transaction.cjs");
+const external_app_files_cjs_namespaceObject = require("./app-files.cjs");
+const external_bridge_config_cjs_namespaceObject = require("./bridge-config.cjs");
+const external_contracts_cjs_namespaceObject = require("./contracts.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_fs_io_cjs_namespaceObject = require("./fs-io.cjs");
+const external_generation_result_cjs_namespaceObject = require("./generation-result.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_overlays_cjs_namespaceObject = require("./overlays.cjs");
+const external_package_json_cjs_namespaceObject = require("./package-json.cjs");
+const external_package_source_cjs_namespaceObject = require("./package-source.cjs");
+const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const external_workspace_scripts_cjs_namespaceObject = require("./workspace-scripts.cjs");
+const external_write_app_cjs_namespaceObject = require("./write-app.cjs");
+const external_zerops_cjs_namespaceObject = require("./zerops.cjs");
+function hasExplicitInstallRequest(options) {
+    return void 0 !== options.packageSource && 'workspace' !== options.packageSource.strategy;
+}
+function writeSharedPackages(targetDir, scope) {
+    for (const sharedPackage of external_descriptors_cjs_namespaceObject.sharedPackages){
+        (0, external_fs_io_cjs_namespaceObject.writeJson)(targetDir, `${sharedPackage.directory}/package.json`, (0, external_package_json_cjs_namespaceObject.createSharedPackage)(scope, sharedPackage.id, sharedPackage.description));
+        (0, external_fs_io_cjs_namespaceObject.writeJson)(targetDir, `${sharedPackage.directory}/tsconfig.json`, (0, external_package_json_cjs_namespaceObject.createSharedPackageTsConfig)(sharedPackage.directory));
+    }
+    (0, external_fs_io_cjs_namespaceObject.writeFile)(targetDir, 'packages/shared-contracts/src/index.ts', (0, external_package_json_cjs_namespaceObject.createSharedContractsIndex)());
+    (0, external_fs_io_cjs_namespaceObject.writeFile)(targetDir, 'packages/shared-design-tokens/src/index.ts', `export const sharedDesignTokens = {
+  color: {
+    accent: '#2f8f68',
+    foreground: '#133225',
+    surface: '#f6fbf7',
+  },
+} as const;
+`);
+    (0, external_fs_io_cjs_namespaceObject.writeFile)(targetDir, 'packages/shared-design-tokens/src/tokens.css', (0, external_app_files_cjs_namespaceObject.createSharedDesignTokensCss)());
+}
+function createCompactRootPackageJson(scope, packageSource, remotes, bridge) {
+    const rootPackage = (0, external_package_json_cjs_namespaceObject.createRootPackageJson)(scope, packageSource, remotes, bridge);
+    if (rootPackage.modernjs?.packageSource && 'object' == typeof rootPackage.modernjs.packageSource) rootPackage.modernjs.packageSource.config = `./${external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}`;
+    return rootPackage;
+}
+function createCompactUltramodernConfig(scope, modernVersion, packageSource, apps = [
+    (0, external_descriptors_cjs_namespaceObject.createShellHost)()
+], enableTailwind = true, bridge, additionalShells = [], primaryShell) {
+    const config = (0, external_contracts_cjs_namespaceObject.createUltramodernConfig)(scope, modernVersion, packageSource, apps, enableTailwind, bridge, additionalShells, primaryShell);
+    if (config.packageSource && 'object' == typeof config.packageSource && !Array.isArray(config.packageSource)) delete config.packageSource.metadata;
+    return config;
+}
+function writePnpmWorkspacePackages(targetDir, bridge) {
+    if (!bridge) return;
+    const pnpmWorkspacePath = `${targetDir}/pnpm-workspace.yaml`;
+    const pnpmWorkspace = external_node_fs_default().readFileSync(pnpmWorkspacePath, 'utf-8');
+    const packages = [
+        'apps/*',
+        'verticals/*',
+        'packages/*',
+        ...bridge.workspacePackages.map((entry)=>entry.pattern)
+    ];
+    const renderedPackages = packages.map((pattern)=>`  - ${pattern}`).join('\n');
+    (0, external_fs_io_cjs_namespaceObject.writeFileReplacing)(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\r?\n(?: {2}- .+\r?\n)+/u, `packages:\n${renderedPackages}\n`));
+}
+function generateUltramodernWorkspace(options) {
+    const result = (0, transaction_cjs_namespaceObject.runFreshWorkspaceTransaction)(options.targetDir, (stagingRoot)=>generateUltramodernWorkspaceInPlace({
+            ...options,
+            targetDir: stagingRoot
+        }, options.targetDir));
+    return result;
+}
+function generateUltramodernWorkspaceInPlace(options, logicalWorkspaceRoot = options.targetDir) {
+    const beforeFiles = (0, external_generation_result_cjs_namespaceObject.createFileSnapshot)(options.targetDir);
+    const scope = (0, external_naming_cjs_namespaceObject.toPackageScope)(options.packageName);
+    let packageSource;
+    let releaseCohort;
+    if ((0, external_ultramodern_release_cohort_cjs_namespaceObject.isCreatePackageSourceCheckout)()) {
+        if (hasExplicitInstallRequest(options)) throw new Error('A local @modern-js/ultramodern-create source checkout cannot satisfy an explicit install package source. Use workspace mode locally or run the packed published package with its authenticated release cohort projection.');
+        packageSource = (0, external_package_source_cjs_namespaceObject.resolvePackageSource)({
+            ...options,
+            packageSource: {
+                strategy: 'workspace'
+            }
+        });
+    } else {
+        packageSource = (0, external_package_source_cjs_namespaceObject.resolvePackageSource)(options);
+        if ('install' === packageSource.strategy) releaseCohort = (0, external_ultramodern_release_cohort_cjs_namespaceObject.readCreateReleaseCohort)();
+    }
+    const bridge = (0, external_bridge_config_cjs_namespaceObject.normalizeUltramodernBridgeConfig)(options.bridge);
+    const enableTailwind = false !== options.enableTailwind;
+    const initialVerticals = [];
+    const createdApps = [
+        (0, external_descriptors_cjs_namespaceObject.createShellHost)(initialVerticals),
+        ...initialVerticals
+    ];
+    (0, external_naming_cjs_namespaceObject.assertUniqueTailwindPrefixes)([
+        external_descriptors_cjs_namespaceObject.shellApp,
+        ...initialVerticals
+    ]);
+    external_node_fs_default().mkdirSync(options.targetDir, {
+        recursive: true
+    });
+    const minimumReleaseAgeExclude = (0, external_policy_cjs_namespaceObject.renderMinimumReleaseAgeExclude)({
+        packageSource,
+        releaseCohort
+    });
+    const workspacePackageLinkingPolicy = (0, external_package_source_cjs_namespaceObject.resolveWorkspacePackageLinkingPolicy)(packageSource);
+    const excludedRootTemplates = new Set([
+        external_ultramodern_release_cohort_cjs_namespaceObject.RELEASE_COHORT_PROJECTION_PATH
+    ]);
+    if (false === options.generateAgentFiles) {
+        excludedRootTemplates.add('AGENTS.md.handlebars');
+        excludedRootTemplates.add('CLAUDE.md.handlebars');
+    }
+    (0, external_fs_io_cjs_namespaceObject.copyRootTemplate)(options.targetDir, {
+        packageName: options.packageName,
+        packageScope: scope,
+        nodeVersion: external_versions_cjs_namespaceObject.NODE_VERSION,
+        pnpmVersion: external_versions_cjs_namespaceObject.PNPM_VERSION,
+        nodeFetchVersion: external_versions_cjs_namespaceObject.NODE_FETCH_VERSION,
+        drizzleOrmVersion: external_versions_cjs_namespaceObject.DRIZZLE_ORM_VERSION,
+        effectVersion: external_versions_cjs_namespaceObject.EFFECT_VERSION,
+        effectVitestVersion: external_versions_cjs_namespaceObject.EFFECT_VITEST_VERSION,
+        i18nextVersion: external_versions_cjs_namespaceObject.I18NEXT_VERSION,
+        moduleFederationVersion: external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION,
+        msgpackrVersion: external_versions_cjs_namespaceObject.MSGPACKR_VERSION,
+        zodVersion: external_versions_cjs_namespaceObject.ZOD_VERSION,
+        tanstackHistoryVersion: external_versions_cjs_namespaceObject.TANSTACK_HISTORY_VERSION,
+        tanstackRouterCoreVersion: external_versions_cjs_namespaceObject.TANSTACK_ROUTER_CORE_VERSION,
+        tanstackRouterVersion: external_versions_cjs_namespaceObject.TANSTACK_ROUTER_VERSION,
+        typescriptVersion: external_versions_cjs_namespaceObject.TYPESCRIPT_VERSION,
+        wranglerVersion: external_versions_cjs_namespaceObject.WRANGLER_VERSION,
+        minimumReleaseAgeExcludeYaml: 0 === minimumReleaseAgeExclude.length ? ' []' : `\n${minimumReleaseAgeExclude.map((selector)=>`  - '${selector}'`).join('\n')}`,
+        workspacePackageLinkingYaml: Object.entries(workspacePackageLinkingPolicy).map(([key, value])=>`${key}: ${String(value)}\n`).join(''),
+        tailwindEnabled: String(enableTailwind)
+    }, excludedRootTemplates);
+    if (releaseCohort) (0, external_ultramodern_release_cohort_cjs_namespaceObject.copyCreateReleaseCohort)(options.targetDir);
+    writePnpmWorkspacePackages(options.targetDir, bridge);
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'package.json', createCompactRootPackageJson(scope, packageSource, initialVerticals, bridge));
+    if (initialVerticals.length > 0) (0, external_fs_io_cjs_namespaceObject.writeFile)(options.targetDir, 'zerops.yaml', `${(0, external_zerops_cjs_namespaceObject.createZeropsYaml)(scope, createdApps)}\n`);
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'tsconfig.base.json', (0, external_package_json_cjs_namespaceObject.createTsConfigBase)());
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'tsconfig.json', (0, external_package_json_cjs_namespaceObject.createRootTsConfig)(createdApps));
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'topology/reference-topology.json', (0, external_contracts_cjs_namespaceObject.createTopology)(scope, initialVerticals));
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'topology/ownership.json', (0, external_contracts_cjs_namespaceObject.createOwnership)(scope, initialVerticals));
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, 'topology/local-overlays/development.json', (0, external_contracts_cjs_namespaceObject.createDevelopmentOverlay)(scope, initialVerticals));
+    (0, external_fs_io_cjs_namespaceObject.writeJson)(options.targetDir, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH, createCompactUltramodernConfig(scope, options.modernVersion, packageSource, createdApps, enableTailwind, bridge));
+    (0, external_write_app_cjs_namespaceObject.writeApp)(options.targetDir, scope, external_descriptors_cjs_namespaceObject.shellApp, packageSource, enableTailwind, initialVerticals, bridge);
+    for (const remote of initialVerticals)(0, external_write_app_cjs_namespaceObject.writeApp)(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals, bridge);
+    writeSharedPackages(options.targetDir, scope);
+    (0, external_workspace_scripts_cjs_namespaceObject.writeGeneratedWorkspaceScripts)(options.targetDir, scope, enableTailwind, initialVerticals, releaseCohort);
+    const preliminaryAfterFiles = (0, external_generation_result_cjs_namespaceObject.createFileSnapshot)(options.targetDir);
+    const preliminaryDiff = (0, external_generation_result_cjs_namespaceObject.diffFileSnapshots)(beforeFiles, preliminaryAfterFiles);
+    const preliminaryResult = (0, external_generation_result_cjs_namespaceObject.createGenerationResult)({
+        operation: 'workspace',
+        workspaceRoot: logicalWorkspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps,
+        createdPaths: preliminaryDiff.createdPaths,
+        rewrittenPaths: preliminaryDiff.rewrittenPaths
+    });
+    (0, external_overlays_cjs_namespaceObject.runCodeSmithOverlays)({
+        workspaceRoot: options.targetDir,
+        overlays: options.overlays,
+        result: preliminaryResult
+    });
+    (0, external_fs_io_cjs_namespaceObject.formatGeneratedWorkspaceFiles)(options.targetDir);
+    const afterFiles = (0, external_generation_result_cjs_namespaceObject.createFileSnapshot)(options.targetDir);
+    const { createdPaths, rewrittenPaths } = (0, external_generation_result_cjs_namespaceObject.diffFileSnapshots)(beforeFiles, afterFiles);
+    return (0, external_generation_result_cjs_namespaceObject.createGenerationResult)({
+        operation: 'workspace',
+        workspaceRoot: logicalWorkspaceRoot,
+        packageScope: scope,
+        packageSource,
+        createdApps,
+        createdPaths,
+        rewrittenPaths
+    });
+}
+exports.createCompactUltramodernConfig = __webpack_exports__.createCompactUltramodernConfig;
+exports.generateUltramodernWorkspace = __webpack_exports__.generateUltramodernWorkspace;
+exports.writeApp = __webpack_exports__.writeApp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCompactUltramodernConfig",
+    "generateUltramodernWorkspace",
+    "writeApp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/zerops.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createZeropsYaml: ()=>createZeropsYaml
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const zeropsNodeRuntime = `nodejs@${external_versions_cjs_namespaceObject.NODE_VERSION.split('.')[0]}`;
+function quoteYamlString(value) {
+    return `'${value.replace(/'/gu, "''")}'`;
+}
+function quoteShellValue(value) {
+    return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+function readinessPath(app) {
+    if (!(0, external_descriptors_cjs_namespaceObject.appHasApi)(app)) return '/';
+    return `${(0, external_descriptors_cjs_namespaceObject.resolveApiPrefix)(app)}/${(0, external_descriptors_cjs_namespaceObject.resolveApiStem)(app)}/readiness`;
+}
+function hasHttpReadiness(app) {
+    return !(0, external_descriptors_cjs_namespaceObject.appHasApi)(app) || 'rest' === (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(app);
+}
+function createZeropsService(scope, app) {
+    const runtimeDirectory = `.zerops/runtime/${app.id}`;
+    const appPackageName = (0, external_naming_cjs_namespaceObject.packageName)(scope, app.packageSuffix);
+    const commands = [
+        'curl https://mise.run | sh',
+        '~/.local/bin/mise install',
+        '~/.local/bin/mise exec -- pnpm install --frozen-lockfile',
+        `~/.local/bin/mise exec -- pnpm --filter ${quoteShellValue(appPackageName)} run build`,
+        `~/.local/bin/mise exec -- pnpm run zerops:materialize -- --app ${quoteShellValue(app.id)} --package ${quoteShellValue(appPackageName)} --package-dir ${quoteShellValue(app.directory)}`,
+        `cp ${quoteShellValue('topology/reference-topology.json')} ${quoteShellValue(`${runtimeDirectory}/topology.json`)}`,
+        `cp ${quoteShellValue('topology/local-overlays/development.json')} ${quoteShellValue(`${runtimeDirectory}/local-overlay.json`)}`
+    ];
+    return [
+        `  - setup: ${quoteYamlString(app.id)}`,
+        '    build:',
+        `      base: ${quoteYamlString(zeropsNodeRuntime)}`,
+        '      buildCommands:',
+        '        - |',
+        ...commands.map((command)=>`          ${command}`),
+        '      deployFiles:',
+        `        - ${quoteYamlString(runtimeDirectory)}`,
+        '    deploy:',
+        '      temporaryShutdown: false',
+        ...hasHttpReadiness(app) ? [
+            '      readinessCheck:',
+            '        httpGet:',
+            `          port: ${app.port}`,
+            `          path: ${quoteYamlString(readinessPath(app))}`,
+            '        failureTimeout: 120',
+            '        retryPeriod: 10'
+        ] : [],
+        '    run:',
+        `      base: ${quoteYamlString(zeropsNodeRuntime)}`,
+        '      ports:',
+        `        - port: ${app.port}`,
+        '          protocol: TCP',
+        '          httpSupport: true',
+        '      envVariables:',
+        '        NODE_ENV: production',
+        `        ${app.portEnv}: ${quoteYamlString(String(app.port))}`,
+        `        ULTRAMODERN_ZEROPS_SERVICE: ${quoteYamlString(app.id)}`,
+        `      start: cd ${quoteShellValue(runtimeDirectory)} && npm run serve`
+    ].join('\n');
+}
+function createZeropsYaml(scope, apps) {
+    return [
+        '# Generated by Modern.js UltraModern workspace tooling.',
+        '# Zerops runs each full-stack MicroVertical as a package-owned Node service.',
+        'zerops:',
+        ...apps.map((app)=>createZeropsService(scope, app))
+    ].join('\n\n');
+}
+exports.createZeropsYaml = __webpack_exports__.createZeropsYaml;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createZeropsYaml"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/agent-files.js

@@ -0,0 +1,47 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+const CLAUDE_IMPORT = '@AGENTS.md';
+const markers = (name)=>({
+        begin: `<!-- BEGIN:${name} -->`,
+        end: `<!-- END:${name} -->`
+    });
+function applyAgentsMd(targetDir, block, markerName) {
+    const { begin, end } = markers(markerName);
+    const file = node_path.join(targetDir, 'AGENTS.md');
+    if (!node_fs.existsSync(file)) {
+        node_fs.writeFileSync(file, `${block}\n`, 'utf-8');
+        return 'created';
+    }
+    const content = node_fs.readFileSync(file, 'utf-8');
+    const from = content.indexOf(begin);
+    const to = content.indexOf(end);
+    if (-1 !== from && -1 !== to && to > from) {
+        const next = content.slice(0, from) + block + content.slice(to + end.length);
+        if (next === content) return 'unchanged';
+        node_fs.writeFileSync(file, next, 'utf-8');
+        return 'updated';
+    }
+    const rest = content.replace(/^\s*/, '');
+    node_fs.writeFileSync(file, rest ? `${block}\n\n${rest}` : `${block}\n`, 'utf-8');
+    return 'added';
+}
+function applyClaudeMd(targetDir) {
+    const file = node_path.join(targetDir, 'CLAUDE.md');
+    if (!node_fs.existsSync(file)) {
+        node_fs.writeFileSync(file, `${CLAUDE_IMPORT}\n`, 'utf-8');
+        return 'created';
+    }
+    const content = node_fs.readFileSync(file, 'utf-8');
+    if (content.split('\n').some((line)=>line.trim() === CLAUDE_IMPORT)) return 'unchanged';
+    node_fs.writeFileSync(file, `${CLAUDE_IMPORT}\n\n${content.replace(/^\s*/, '')}`, 'utf-8');
+    return 'linked';
+}
+function applyAgentFiles(options) {
+    const { targetDir, block, markerName } = options;
+    if (!node_fs.existsSync(targetDir)) throw new Error(`target directory does not exist: ${targetDir}`);
+    return {
+        agents: applyAgentsMd(targetDir, block, markerName),
+        claude: applyClaudeMd(targetDir)
+    };
+}
+export { applyAgentFiles };

package/dist/esm/agents-md.js

@@ -0,0 +1,50 @@
+import node_fs from "node:fs";
+import { applyAgentFiles } from "./agent-files.js";
+import { BUNDLED_SINCE, DOCS_PATH, buildBlock, isModernProject, resolveVersion, supportsBundledDocs } from "./docs-location.js";
+import { i18n, localeKeys } from "./locale/index.js";
+const MARKER_NAME = 'modernjs-agent-rules';
+const AGENTS_MESSAGES = {
+    created: localeKeys.agentsCmd.created,
+    updated: localeKeys.agentsCmd.updatedBlock,
+    added: localeKeys.agentsCmd.addedBlock,
+    unchanged: localeKeys.agentsCmd.unchanged
+};
+const CLAUDE_MESSAGES = {
+    created: localeKeys.agentsCmd.created,
+    linked: localeKeys.agentsCmd.linked,
+    unchanged: localeKeys.agentsCmd.unchanged
+};
+function runAgentsMd(_templateDir, targetDir) {
+    if (!node_fs.existsSync(targetDir)) {
+        console.error(i18n.t(localeKeys.agentsCmd.targetNotFound, {
+            dir: targetDir
+        }));
+        process.exit(1);
+    }
+    if (!isModernProject(targetDir)) {
+        console.error(i18n.t(localeKeys.agentsCmd.notAProject));
+        process.exit(1);
+    }
+    const version = resolveVersion(targetDir);
+    if (!supportsBundledDocs(version)) return void console.log(i18n.t(localeKeys.agentsCmd.unsupportedVersion, {
+        version: version ?? 'unknown',
+        since: BUNDLED_SINCE
+    }));
+    const block = buildBlock(MARKER_NAME);
+    const result = applyAgentFiles({
+        targetDir,
+        block,
+        markerName: MARKER_NAME
+    });
+    console.log(i18n.t(AGENTS_MESSAGES[result.agents], {
+        file: 'AGENTS.md'
+    }));
+    console.log(i18n.t(CLAUDE_MESSAGES[result.claude], {
+        file: 'CLAUDE.md'
+    }));
+    console.log('');
+    console.log(i18n.t(localeKeys.agentsCmd.done, {
+        location: DOCS_PATH
+    }));
+}
+export { runAgentsMd };