@habitat-ai/cli 0.5.2 → 0.5.4

package/README.md

@@ -0,0 +1,42 @@
+# `@habitat-ai/cli`
+
+Habitat's Oclif CLI and native Nx integration. The package owns the portable
+repository preset, Habitat policy projection, and the public `habitat` command.
+
+## Create A Repository
+
+Nx invokes the package's Bun-only `preset` generator while creating the workspace:
+
+```sh
+bunx create-nx-workspace@23.1.1 my-workspace \
+  --preset=@habitat-ai/cli \
+  --packageManager=bun
+```
+
+Nx initializes Git after the preset returns. Activate the repository hooks once
+that boundary exists:
+
+```sh
+cd my-workspace
+bunx nx generate @habitat-ai/cli:init --no-interactive
+```
+
+The preset creates generic Bun, Nx, TypeScript, Biome, and Habitat scheduler
+configuration. It does not copy blueprints, select product policy, or author the
+repository's `AGENTS.md` hierarchy.
+
+## Adopt An Existing Bun Nx Repository
+
+```sh
+bunx nx add @habitat-ai/cli --no-interactive
+```
+
+`nx add` invokes `init`. Existing nonempty hooks and unrelated Nx/Codex
+configuration remain consumer-owned. A Bun repository may additionally invoke the
+`preset` generator to adopt the portable repository spine.
+
+Later package releases use ordinary Nx migrations:
+
+```sh
+bunx nx migrate @habitat-ai/cli@latest
+```

package/dist/generators/init.js

@@ -1,16 +1,14 @@
 import { execSync } from "node:child_process";
-import { detectPackageManager, getPackageManagerCommand, installPackagesTask, runTasksInSerial, } from "@nx/devkit";
+import { getPackageManagerCommand, installPackagesTask, runTasksInSerial, } from "@nx/devkit";
 import { initializeHabitatConsumer } from "../nx/initialization.js";
+import { assertHabitatBunConsumer } from "../nx/repository-preset.js";
 import { habitatConsumerBinding } from "../nx-generators.js";
 /** Initializes the installed Habitat package inside one Nx consumer. */
 export default function initializeHabitat(tree) {
-    const packageManager = detectPackageManager(tree.root);
-    if (packageManager === "yarn") {
-        throw new Error("Habitat Husky initialization supports npm, pnpm, and Bun consumers.");
-    }
+    assertHabitatBunConsumer(tree);
     const result = initializeHabitatConsumer(tree, habitatConsumerBinding);
     const activateHusky = () => {
-        const command = `${getPackageManagerCommand(packageManager).exec} husky`;
+        const command = `${getPackageManagerCommand("bun").exec} husky`;
         execSync(command, {
             cwd: tree.root,
             stdio: "inherit",
@@ -18,5 +16,5 @@ export default function initializeHabitat(tree) {
     };
     if (!result.packageChanged)
         return activateHusky;
-    return runTasksInSerial(() => installPackagesTask(tree), activateHusky);
+    return runTasksInSerial(() => installPackagesTask(tree, false, "", "bun"), activateHusky);
 }

package/dist/generators/preset.d.ts

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+import { type HabitatRepositoryPresetOptions } from "../nx/repository-preset.js";
+/** Creates Habitat's portable Bun/Nx repository spine before Git initialization. */
+export default function createHabitatRepository(tree: Tree, options: HabitatRepositoryPresetOptions): GeneratorCallback | undefined;

package/dist/generators/preset.js

@@ -0,0 +1,10 @@
+import { installPackagesTask } from "@nx/devkit";
+import { initializeHabitatBunRepository, } from "../nx/repository-preset.js";
+import { habitatConsumerBinding } from "../nx-generators.js";
+/** Creates Habitat's portable Bun/Nx repository spine before Git initialization. */
+export default function createHabitatRepository(tree, options) {
+    const result = initializeHabitatBunRepository(tree, habitatConsumerBinding, options);
+    if (!result.packageChanged)
+        return undefined;
+    return () => installPackagesTask(tree, false, "", "bun");
+}

package/dist/nx/initialization.d.ts

@@ -1,4 +1,4 @@
-import { type PluginConfiguration, type Tree } from "@nx/devkit";
+import { type NxJsonConfiguration, type PluginConfiguration, type Tree } from "@nx/devkit";
 import { type Static, Type } from "typebox";
 declare const HookGroupSchema: Type.TObject<{
     _habitat: Type.TOptional<Type.TObject<{
@@ -21,6 +21,10 @@ declare const HabitatOwnedHookGroupSchema: Type.TObject<{
 }>;
 type HookGroup = Static<typeof HookGroupSchema>;
 type HabitatOwnedHookGroup = Static<typeof HabitatOwnedHookGroupSchema>;
+type PlannedValue<T> = Readonly<{
+    changed: boolean;
+    value: T;
+}>;
 /** App-owned identities and exact predecessor states consumed by native Nx initialization. */
 export type HabitatConsumerBinding = Readonly<{
     defaultCheckScript: string;
@@ -53,4 +57,6 @@ export type HabitatInitializationResult = Readonly<{
 export declare function initializeHabitatConsumer(tree: Tree, binding: HabitatConsumerBinding): HabitatInitializationResult;
 /** Removes only Habitat's named hook group while preserving installed Nx integration. */
 export declare function removeHabitatHook(tree: Tree, binding: HabitatConsumerBinding): void;
+/** Plans the one package-owned Nx plugin registration without mutating a Tree. */
+export declare function planHabitatNxRegistration(nxJson: NxJsonConfiguration, binding: HabitatConsumerBinding): PlannedValue<NxJsonConfiguration>;
 export {};

package/dist/nx/initialization.js

@@ -82,7 +82,7 @@ export function initializeHabitatConsumer(tree, binding) {
     const nxJson = requireNxJson(tree);
     const hooks = readHooks(tree);
     const packageJson = readPackage(tree);
-    const nxPlan = planNxInitialization(nxJson, binding);
+    const nxPlan = planHabitatNxRegistration(nxJson, binding);
     const hookPlan = planHookInitialization(hooks, binding);
     const packagePlan = planPackageInitialization(packageJson, binding);
     const gitHookPlan = planGitHookInitialization(tree, binding.gitHook);
@@ -129,7 +129,8 @@ function readPackage(tree) {
     }
     return input;
 }
-function planNxInitialization(nxJson, binding) {
+/** Plans the one package-owned Nx plugin registration without mutating a Tree. */
+export function planHabitatNxRegistration(nxJson, binding) {
     const plugins = nxJson.plugins ?? [];
     const matches = plugins.filter((plugin) => hasPluginIdentity(plugin, binding.nxPlugin) ||
         binding.predecessorNxPlugins.some((predecessor) => hasPluginIdentity(plugin, typeof predecessor === "string" ? predecessor : predecessor.plugin)));

package/dist/nx/repository-preset.d.ts

@@ -0,0 +1,22 @@
+import { type Tree } from "@nx/devkit";
+import { type HabitatConsumerBinding } from "./initialization.js";
+/** Nx options consumed by the portable Habitat repository preset. */
+export type HabitatRepositoryPresetOptions = Readonly<{
+    packageManager: string;
+}>;
+/** Reports whether dependency installation must follow repository generation. */
+export type HabitatRepositoryPresetResult = Readonly<{
+    packageChanged: boolean;
+}>;
+/**
+ * Admits package-owned initialization only for the canonical Bun consumer shape.
+ * The check runs before the generator plans package, Nx, hook, or policy changes.
+ */
+export declare function assertHabitatBunConsumer(tree: Tree): void;
+/**
+ * Converges one repository on Habitat's portable Bun/Nx configuration.
+ *
+ * Product inventory, policy selections, documentation routers, aliases, release
+ * policy, and hosted CI remain consumer-owned and are never generated here.
+ */
+export declare function initializeHabitatBunRepository(tree: Tree, binding: HabitatConsumerBinding, options: HabitatRepositoryPresetOptions): HabitatRepositoryPresetResult;

package/dist/nx/repository-preset.js

@@ -0,0 +1,530 @@
+import { isDeepStrictEqual } from "node:util";
+import { getProjects, readJson, readNxJson, updateNxJson, writeJson, } from "@nx/devkit";
+import { Type } from "typebox";
+import { Validator } from "typebox/schema";
+import { planHabitatNxRegistration } from "./initialization.js";
+const PACKAGE_PATH = "package.json";
+const HABITAT_PROJECT_PATH = "scripts/habitat/project.json";
+const TYPESCRIPT_CONFIG_PATH = "tsconfig.base.json";
+const ALTERNATE_PACKAGE_MANAGER_PATHS = [
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "yarn.lock",
+];
+const BUN_VERSION = "1.3.14";
+const BIOME_VERSION = "2.5.3";
+const NX_VERSION = "23.1.1";
+const RootPackageSchema = Type.Object({
+    private: Type.Optional(Type.Boolean({ description: "Whether the repository root is excluded from publication." })),
+    type: Type.Optional(Type.String({ description: "Module system selected by the repository root." })),
+    packageManager: Type.Optional(Type.String({ description: "Package manager and version selected by the repository root." })),
+    workspaces: Type.Optional(Type.Array(Type.String(), { description: "Bun workspace roots owned by the repository." })),
+    scripts: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Root command faces delegated to the Nx scheduler.",
+    })),
+    devDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Development tools installed at the repository root.",
+    })),
+    dependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Runtime dependencies installed at the repository root.",
+    })),
+    optionalDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Optional dependencies installed at the repository root.",
+    })),
+    peerDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Peer dependencies declared by the repository root.",
+    })),
+    overrides: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
+        description: "Root dependency versions overridden during Bun resolution.",
+    })),
+    resolutions: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
+        description: "Root dependency versions selected during Bun resolution.",
+    })),
+    patchedDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Dependency patches applied by Bun during installation.",
+    })),
+    nx: Type.Optional(Type.Object({
+        includedScripts: Type.Optional(Type.Array(Type.String(), {
+            description: "Root scripts intentionally projected into the Nx project graph.",
+        })),
+    }, { additionalProperties: true, description: "Nx root package projection controls." })),
+}, { additionalProperties: true, description: "Bun Nx repository package metadata." });
+const TypeScriptConfigSchema = Type.Object({
+    compilerOptions: Type.Optional(Type.Object({
+        types: Type.Optional(Type.Array(Type.String(), {
+            description: "Ambient type packages loaded by the repository compiler.",
+        })),
+    }, {
+        additionalProperties: true,
+        description: "Compiler foundation and consumer-specific TypeScript options.",
+    })),
+}, { additionalProperties: true });
+const HabitatProjectSchema = Type.Object({
+    name: Type.Literal("habitat", {
+        description: "Canonical Nx identity for repository-wide Habitat policy tasks.",
+    }),
+    root: Type.Literal("scripts/habitat", {
+        description: "Canonical owner root for repository-wide Habitat policy tasks.",
+    }),
+    tags: Type.Tuple([Type.Literal("type:tool"), Type.Literal("role:architecture-policy")], {
+        description: "Canonical Nx classification for the Habitat policy owner.",
+    }),
+    targets: Type.Record(Type.String(), Type.Unknown(), {
+        description: "Nx tasks owned by the repository-wide Habitat policy project.",
+    }),
+}, { additionalProperties: true });
+const packageValidator = new Validator({}, RootPackageSchema);
+const habitatProjectValidator = new Validator({}, HabitatProjectSchema);
+const typescriptConfigValidator = new Validator({}, TypeScriptConfigSchema);
+const standardWorkspaces = [
+    "apps/*",
+    "services/*",
+    "packages/*",
+    "resources/*",
+    "plugins/cli/topics/*",
+    "plugins/web/*",
+    "plugins/server/api/*",
+    "plugins/async/workflows/*",
+    "plugins/async/schedules/*",
+];
+const standardScripts = {
+    build: "nx run-many -t build",
+    check: "nx run-many -t check",
+    ci: "nx run-many -t build,check,test",
+    "ci:affected": "nx affected -t build,check,test",
+    format: "nx run habitat:format",
+    lint: "nx run habitat:lint",
+    test: "nx run-many -t test",
+    typecheck: "nx run-many -t typecheck",
+};
+const standardDevDependencies = {
+    "@biomejs/biome": BIOME_VERSION,
+    "@types/node": "24.13.3",
+    "bun-types": BUN_VERSION,
+    nx: NX_VERSION,
+    typescript: "5.9.3",
+};
+const standardNamedInputs = {
+    default: ["{projectRoot}/**/*", "!{projectRoot}/dist/**", "!{projectRoot}/coverage/**"],
+    production: [
+        "default",
+        "!{projectRoot}/test/**",
+        "!{projectRoot}/**/*.test.*",
+        "!{projectRoot}/**/*.spec.*",
+    ],
+    bunToolchain: ["{workspaceRoot}/package.json", "{workspaceRoot}/bun.lock"],
+    typescriptRuntime: ["{workspaceRoot}/tsconfig.base.json", "{workspaceRoot}/bun.lock"],
+};
+const nativeNxPresetNamedInputs = {
+    default: ["{projectRoot}/**/*", "sharedGlobals"],
+    production: ["default"],
+};
+const standardTargetDefaults = {
+    build: {
+        cache: true,
+        dependsOn: ["^build"],
+        inputs: ["production", "^production", "typescriptRuntime"],
+        outputs: ["{projectRoot}/dist"],
+    },
+    check: {
+        cache: false,
+        dependsOn: [
+            { projects: ["habitat"], target: "lint" },
+            "typecheck",
+            "verify",
+            "check:policy",
+            "^check",
+        ],
+        outputs: [],
+    },
+    test: {
+        cache: true,
+        dependsOn: ["^build"],
+        inputs: ["default", "^default", "typescriptRuntime"],
+        outputs: [],
+    },
+    typecheck: {
+        cache: true,
+        dependsOn: ["^build"],
+        inputs: ["default", "^default", "typescriptRuntime"],
+        outputs: [],
+    },
+    verify: {
+        cache: false,
+        dependsOn: ["build", "^build"],
+        outputs: [],
+    },
+};
+const bunfig = `env = false
+
+[install]
+linker = "isolated"
+# Registry versions remain registry consumers; source relationships opt in with workspace:*.
+linkWorkspacePackages = false
+`;
+const standardTypeScriptCompilerOptions = {
+    target: "ES2022",
+    module: "ESNext",
+    moduleResolution: "Bundler",
+    lib: ["ES2022"],
+    strict: true,
+    skipLibCheck: true,
+    types: ["bun-types", "node"],
+};
+/**
+ * Admits package-owned initialization only for the canonical Bun consumer shape.
+ * The check runs before the generator plans package, Nx, hook, or policy changes.
+ */
+export function assertHabitatBunConsumer(tree) {
+    assertBunRepositoryArtifacts(tree);
+    const packageJson = readRootPackage(tree);
+    const requiredManager = `bun@${BUN_VERSION}`;
+    if (packageJson.packageManager !== requiredManager) {
+        throw new Error(`Habitat initialization requires packageManager '${requiredManager}'; received '${packageJson.packageManager}'.`);
+    }
+    const nxPackageManager = requireNxJson(tree).cli?.packageManager;
+    if (nxPackageManager !== undefined && nxPackageManager !== "bun") {
+        throw new Error(`Habitat initialization requires Nx package manager 'bun'; received '${nxPackageManager}'.`);
+    }
+}
+const biomeConfig = jsonDocument({
+    $schema: `https://biomejs.dev/schemas/${BIOME_VERSION}/schema.json`,
+    vcs: {
+        enabled: true,
+        clientKind: "git",
+        useIgnoreFile: true,
+    },
+    files: {
+        ignoreUnknown: true,
+        includes: [
+            "**",
+            "!**/node_modules/**",
+            "!**/dist/**",
+            "!**/coverage/**",
+            "!.nx/**",
+            "!.habitat/cache/**",
+            "!**/.tmp/**",
+        ],
+    },
+    formatter: {
+        enabled: true,
+        useEditorconfig: true,
+        formatWithErrors: false,
+        indentStyle: "space",
+        indentWidth: 2,
+        lineWidth: 100,
+        lineEnding: "lf",
+    },
+    linter: {
+        enabled: true,
+        rules: {
+            preset: "none",
+            correctness: {
+                noConstAssign: "error",
+                noSelfAssign: "error",
+                noUnreachable: "error",
+                noUnreachableSuper: "error",
+                noUnsafeFinally: "error",
+                noUnsafeOptionalChaining: "error",
+                useIsNan: "error",
+                useValidTypeof: "error",
+            },
+            suspicious: {
+                noDebugger: "error",
+                noDuplicateCase: "error",
+                noDuplicateClassMembers: "error",
+                noDuplicateJsxProps: "error",
+                noDuplicateObjectKeys: "error",
+                noDuplicateParameters: "error",
+                noFallthroughSwitchClause: "error",
+                noGlobalIsFinite: "error",
+                noGlobalIsNan: "error",
+                noSparseArray: "error",
+                noWith: "error",
+                useGetterReturn: "error",
+            },
+        },
+    },
+    javascript: {
+        formatter: {
+            quoteStyle: "double",
+            semicolons: "always",
+            trailingCommas: "es5",
+        },
+    },
+    assist: {
+        enabled: true,
+        actions: {
+            source: {
+                organizeImports: "on",
+            },
+        },
+    },
+});
+const habitatProjectDocument = {
+    $schema: "../../node_modules/nx/schemas/project-schema.json",
+    name: "habitat",
+    root: "scripts/habitat",
+    tags: ["type:tool", "role:architecture-policy"],
+    targets: {
+        lint: {
+            executor: "nx:run-commands",
+            cache: true,
+            inputs: [
+                "{workspaceRoot}/**/*.{js,mjs,jsx,cjs,ts,mts,cts,tsx,json,jsonld,webapp,webmanifest,jsonc,code-snippets,code-workspace,sublime-build,sublime-commands,sublime-completions,sublime-keymap,sublime-macro,sublime-menu,sublime-mousemap,sublime-project,sublime-settings,sublime-theme,sublime-workspace,sublime_metrics,sublime_session,css,graphqls,graphql,gql,html,svg,astro,vue,svelte,grit}",
+                "{workspaceRoot}/**/{.all-contributorsrc,.arcconfig,.auto-changelog,.bowerrc,.c8rc,.htmlhintrc,.imgbotconfig,.jslintrc,.nycrc,.tern-config,.tern-project,.vuerc,.watchmanconfig,.ember-cli,.jscsrc,.jshintrc,.babelrc,.hintrc,.swcrc,mcmod.info}",
+                "{workspaceRoot}/.editorconfig",
+                "{workspaceRoot}/.gitignore",
+                "{workspaceRoot}/biome.json",
+                "bunToolchain",
+            ],
+            outputs: [],
+            options: {
+                command: "biome lint --diagnostic-level=error .",
+            },
+        },
+        format: {
+            executor: "nx:run-commands",
+            cache: false,
+            options: {
+                command: "biome format --write .",
+            },
+        },
+        check: {
+            executor: "nx:noop",
+            cache: false,
+            outputs: [],
+        },
+    },
+};
+const habitatProject = jsonDocument(habitatProjectDocument);
+/**
+ * Converges one repository on Habitat's portable Bun/Nx configuration.
+ *
+ * Product inventory, policy selections, documentation routers, aliases, release
+ * policy, and hosted CI remain consumer-owned and are never generated here.
+ */
+export function initializeHabitatBunRepository(tree, binding, options) {
+    assertBunManager(options.packageManager);
+    assertBunRepositoryArtifacts(tree);
+    const packageJson = readRootPackage(tree);
+    assertBunPackage(packageJson);
+    assertCanonicalTextFoundation(tree);
+    assertHabitatProjectAuthority(tree);
+    const typescriptConfig = readTypeScriptConfig(tree);
+    const nxJson = requireNxJson(tree);
+    const nxRegistration = planHabitatNxRegistration(nxJson, binding);
+    const nextPackage = planRootPackage(packageJson);
+    const nextNx = planNxJson(nxRegistration.value);
+    const nextTypeScriptConfig = planTypeScriptConfig(typescriptConfig);
+    const files = plannedTextFiles(tree);
+    if (!isDeepStrictEqual(packageJson, nextPackage))
+        writeJson(tree, PACKAGE_PATH, nextPackage);
+    if (!isDeepStrictEqual(nxJson, nextNx))
+        updateNxJson(tree, nextNx);
+    if (!isDeepStrictEqual(typescriptConfig, nextTypeScriptConfig)) {
+        writeJson(tree, TYPESCRIPT_CONFIG_PATH, nextTypeScriptConfig);
+    }
+    for (const file of files)
+        tree.write(file.path, file.contents);
+    return { packageChanged: !isDeepStrictEqual(packageJson, nextPackage) };
+}
+function readRootPackage(tree) {
+    if (!tree.exists(PACKAGE_PATH)) {
+        throw new Error("Habitat repository generation requires package.json.");
+    }
+    const input = readJson(tree, PACKAGE_PATH);
+    if (!packageValidator.Check(input)) {
+        throw new Error("package.json is not a supported Bun Nx repository document.");
+    }
+    return input;
+}
+function requireNxJson(tree) {
+    const nxJson = readNxJson(tree);
+    if (nxJson === null) {
+        throw new Error("Habitat repository generation requires nx.json.");
+    }
+    return nxJson;
+}
+function readTypeScriptConfig(tree) {
+    if (!tree.exists(TYPESCRIPT_CONFIG_PATH) || isEmptyTextFile(tree, TYPESCRIPT_CONFIG_PATH)) {
+        return undefined;
+    }
+    const input = readJson(tree, TYPESCRIPT_CONFIG_PATH);
+    if (!typescriptConfigValidator.Check(input)) {
+        throw new Error(`${TYPESCRIPT_CONFIG_PATH} is not a supported TypeScript configuration.`);
+    }
+    return input;
+}
+function assertBunManager(packageManager) {
+    if (packageManager !== "bun") {
+        throw new Error(`Habitat repository preset requires Bun; received '${packageManager}'.`);
+    }
+}
+function assertBunRepositoryArtifacts(tree) {
+    const alternate = ALTERNATE_PACKAGE_MANAGER_PATHS.find((path) => tree.exists(path));
+    if (alternate !== undefined) {
+        throw new Error(`Habitat repository preset refuses alternate package-manager artifact '${alternate}'.`);
+    }
+}
+function assertCanonicalTextFoundation(tree) {
+    for (const [path, canonical] of [
+        ["biome.json", biomeConfig],
+        ["bunfig.toml", bunfig],
+    ]) {
+        if (!tree.exists(path) || isEmptyTextFile(tree, path))
+            continue;
+        if (tree.read(path, "utf8") !== canonical) {
+            throw new Error(`Habitat repository preset found incompatible foundation file '${path}'.`);
+        }
+    }
+}
+function assertBunPackage(packageJson) {
+    const requiredManager = `bun@${BUN_VERSION}`;
+    if (packageJson.packageManager !== undefined && packageJson.packageManager !== requiredManager) {
+        throw new Error(`Habitat repository preset requires packageManager '${requiredManager}'; received '${packageJson.packageManager}'.`);
+    }
+    if (packageJson.private === false) {
+        throw new Error("Habitat repository preset requires a private workspace root.");
+    }
+    if (packageJson.type !== undefined && packageJson.type !== "module") {
+        throw new Error("Habitat repository preset requires an ESM workspace root.");
+    }
+    const conflictingScript = packageJson.nx?.includedScripts?.find((script) => Object.hasOwn(standardScripts, script));
+    if (conflictingScript !== undefined) {
+        throw new Error(`Habitat repository preset requires nx.includedScripts to exclude scheduler script '${conflictingScript}'.`);
+    }
+    for (const [name, command] of Object.entries(standardScripts)) {
+        const existing = packageJson.scripts?.[name];
+        if (existing !== undefined && existing !== command) {
+            throw new Error(`Habitat repository preset found incompatible root scheduler script '${name}'.`);
+        }
+    }
+    for (const [name, version] of Object.entries(standardDevDependencies)) {
+        for (const bucket of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+            if (packageJson[bucket]?.[name] !== undefined) {
+                throw new Error(`Habitat repository preset requires tool dependency '${name}' in devDependencies.`);
+            }
+        }
+        const existing = packageJson.devDependencies?.[name];
+        if (existing !== undefined && existing !== version) {
+            throw new Error(`Habitat repository preset found incompatible tool dependency '${name}@${existing}'.`);
+        }
+        for (const control of ["overrides", "resolutions"]) {
+            const selected = packageJson[control]?.[name];
+            if (selected !== undefined && selected !== version) {
+                throw new Error(`Habitat repository preset found incompatible ${control} selection for tool '${name}'.`);
+            }
+        }
+        const patched = Object.keys(packageJson.patchedDependencies ?? {}).find((specifier) => specifier === name || specifier.startsWith(`${name}@`));
+        if (patched !== undefined) {
+            throw new Error(`Habitat repository preset refuses patched foundation tool '${patched}'.`);
+        }
+    }
+}
+function assertHabitatProjectAuthority(tree) {
+    const emptyHabitatProject = isEmptyTextFile(tree, HABITAT_PROJECT_PATH);
+    const projects = getProjects(emptyHabitatProject ? withoutHabitatProject(tree) : tree);
+    const project = projects.get("habitat");
+    if (project !== undefined && project.root !== "scripts/habitat") {
+        throw new Error(`Habitat repository preset found project 'habitat' at incompatible root '${project.root}'.`);
+    }
+    const conflictingRootOwner = [...projects.entries()].find(([name, configuration]) => name !== "habitat" && configuration.root === "scripts/habitat");
+    if (conflictingRootOwner !== undefined) {
+        throw new Error(`Habitat repository preset found root 'scripts/habitat' owned by incompatible project '${conflictingRootOwner[0]}'.`);
+    }
+    if (!tree.exists(HABITAT_PROJECT_PATH) || emptyHabitatProject)
+        return;
+    const input = readJson(tree, HABITAT_PROJECT_PATH);
+    if (!habitatProjectValidator.Check(input)) {
+        throw new Error(`${HABITAT_PROJECT_PATH} is not a compatible Habitat policy project.`);
+    }
+    if (Object.hasOwn(input, "projectType")) {
+        throw new Error(`${HABITAT_PROJECT_PATH} must not declare projectType.`);
+    }
+    for (const target of ["check", "format", "lint"]) {
+        if (!isDeepStrictEqual(input.targets[target], habitatProjectDocument.targets[target])) {
+            throw new Error(`${HABITAT_PROJECT_PATH} has incompatible Habitat target '${target}'.`);
+        }
+    }
+}
+function planRootPackage(packageJson) {
+    return {
+        ...packageJson,
+        private: true,
+        type: "module",
+        packageManager: packageJson.packageManager ?? `bun@${BUN_VERSION}`,
+        workspaces: [...new Set([...standardWorkspaces, ...(packageJson.workspaces ?? [])])],
+        scripts: { ...standardScripts, ...packageJson.scripts },
+        nx: { ...packageJson.nx, includedScripts: [...(packageJson.nx?.includedScripts ?? [])] },
+        devDependencies: { ...packageJson.devDependencies, ...standardDevDependencies },
+    };
+}
+function planNxJson(nxJson) {
+    assertReservedNxValues("named input", nxJson.namedInputs, standardNamedInputs, nativeNxPresetNamedInputs);
+    assertReservedNxValues("target default", nxJson.targetDefaults, standardTargetDefaults);
+    return {
+        ...nxJson,
+        namedInputs: { ...nxJson.namedInputs, ...standardNamedInputs },
+        targetDefaults: { ...nxJson.targetDefaults, ...standardTargetDefaults },
+    };
+}
+function assertReservedNxValues(kind, existing, canonical, admittedPredecessors = {}) {
+    for (const [name, value] of Object.entries(canonical)) {
+        const current = existing?.[name];
+        const predecessor = admittedPredecessors[name];
+        if (current !== undefined &&
+            !isDeepStrictEqual(current, value) &&
+            !isDeepStrictEqual(current, predecessor)) {
+            throw new Error(`Habitat repository preset found incompatible Nx ${kind} '${name}'.`);
+        }
+    }
+}
+function planTypeScriptConfig(config) {
+    const existing = (config?.compilerOptions ?? {});
+    for (const [name, value] of Object.entries(standardTypeScriptCompilerOptions)) {
+        if (name === "types")
+            continue;
+        const current = existing[name];
+        if (current !== undefined && !isDeepStrictEqual(current, value)) {
+            throw new Error(`Habitat repository preset found incompatible TypeScript compiler option '${name}'.`);
+        }
+    }
+    return {
+        ...config,
+        compilerOptions: {
+            ...standardTypeScriptCompilerOptions,
+            ...existing,
+            types: [...new Set([...standardTypeScriptCompilerOptions.types, ...(existing.types ?? [])])],
+        },
+    };
+}
+function plannedTextFiles(tree) {
+    return [
+        { path: "biome.json", contents: biomeConfig },
+        { path: "bunfig.toml", contents: bunfig },
+        { path: HABITAT_PROJECT_PATH, contents: habitatProject },
+    ].filter((file) => !tree.exists(file.path) || isEmptyTextFile(tree, file.path));
+}
+function isEmptyTextFile(tree, path) {
+    return tree.exists(path) && tree.read(path, "utf8")?.trim().length === 0;
+}
+function withoutHabitatProject(tree) {
+    return new Proxy(tree, {
+        get(target, property, receiver) {
+            if (property === "listChanges") {
+                return () => [
+                    ...target.listChanges().filter((change) => change.path !== HABITAT_PROJECT_PATH),
+                    { path: HABITAT_PROJECT_PATH, type: "DELETE", content: null },
+                ];
+            }
+            const value = Reflect.get(target, property, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
+function jsonDocument(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}

package/generators.json

@@ -1,6 +1,11 @@
 {
   "$schema": "https://json-schema.org/schema",
   "generators": {
+    "preset": {
+      "factory": "./dist/generators/preset.js",
+      "schema": "./preset.schema.json",
+      "description": "Create the portable Habitat Bun/Nx repository spine."
+    },
     "init": {
       "factory": "./dist/generators/init.js",
       "schema": "./generators.schema.json",

package/oclif.manifest.json

@@ -99,5 +99,5 @@
       ]
     }
   },
-  "version": "0.5.2"
+  "version": "0.5.4"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habitat-ai/cli",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "private": false,
   "repository": {
     "type": "git",
@@ -20,6 +20,8 @@
     "dist",
     "generators.json",
     "generators.schema.json",
+    "preset.schema.json",
+    "README.md",
     "oclif.manifest.json",
     "package.json"
   ],
@@ -27,6 +29,11 @@
     "habitat": "./bin/run.js"
   },
   "generators": "./generators.json",
+  "nx-migrations": {
+    "packageGroup": [
+      "@habitat-ai/sdk"
+    ]
+  },
   "exports": {
     "./nx-plugin": {
       "types": "./dist/nx-plugin.d.ts",
@@ -45,8 +52,8 @@
     "test": "vitest run --project habitat-cli"
   },
   "dependencies": {
-    "@habitat-ai/sdk": "0.5.2",
-    "@nx/devkit": "23.1.0",
+    "@habitat-ai/sdk": "0.5.4",
+    "@nx/devkit": "23.1.1",
     "@oclif/core": "^4.13.2",
     "@oclif/plugin-help": "^6.2.27",
     "typebox": "1.3.8"

package/preset.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "packageManager": {
+      "type": "string",
+      "enum": ["bun"],
+      "description": "Package manager selected by create-nx-workspace; Habitat accepts Bun only."
+    }
+  },
+  "required": ["packageManager"],
+  "additionalProperties": true
+}