@habitat-ai/cli 0.4.1 → 0.5.0

package/dist/generators/init.d.ts

@@ -1,3 +1,3 @@
 import { type GeneratorCallback, type Tree } from "@nx/devkit";
 /** Initializes the installed Habitat package inside one Nx consumer. */
-export default function initializeHabitat(tree: Tree): GeneratorCallback | void;
+export default function initializeHabitat(tree: Tree): GeneratorCallback;

package/dist/generators/init.js

@@ -1,10 +1,22 @@
-import { installPackagesTask } from "@nx/devkit";
+import { execSync } from "node:child_process";
+import { detectPackageManager, getPackageManagerCommand, installPackagesTask, runTasksInSerial, } from "@nx/devkit";
 import { initializeHabitatConsumer } from "../nx/initialization.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.");
+    }
     const result = initializeHabitatConsumer(tree, habitatConsumerBinding);
+    const activateHusky = () => {
+        const command = `${getPackageManagerCommand(packageManager).exec} husky`;
+        execSync(command, {
+            cwd: tree.root,
+            stdio: "inherit",
+        });
+    };
     if (!result.packageChanged)
-        return;
-    return () => installPackagesTask(tree);
+        return activateHusky;
+    return runTasksInSerial(() => installPackagesTask(tree), activateHusky);
 }

package/dist/nx/initialization.d.ts

@@ -23,18 +23,29 @@ type HookGroup = Static<typeof HookGroupSchema>;
 type HabitatOwnedHookGroup = Static<typeof HabitatOwnedHookGroupSchema>;
 /** App-owned identities and exact predecessor states consumed by native Nx initialization. */
 export type HabitatConsumerBinding = Readonly<{
+    defaultCheckScript: string;
+    gitHook: Readonly<{
+        contents: string;
+        path: string;
+    }>;
     gritPackage: string;
     hook: HabitatOwnedHookGroup;
+    husky: Readonly<{
+        package: string;
+        prepare: string;
+        predecessorPrepareScripts: readonly string[];
+        version: string;
+    }>;
     nxPlugin: string;
     predecessorHooks: readonly HookGroup[];
     predecessorNxPlugins: readonly PluginConfiguration[];
 }>;
-/** Observable generator decision needed to schedule the consumer package manager once. */
+/** Reports whether dependency installation must precede local Husky activation. */
 export type HabitatInitializationResult = Readonly<{
     packageChanged: boolean;
 }>;
 /**
- * Converges one Nx consumer on the app-owned Habitat plugin, hook, and Grit trust.
+ * Converges one Nx consumer on Habitat's app-owned Nx, Codex, package, and Git-hook state.
  *
  * Every admission and compatibility decision completes before the first Tree
  * write, so an incompatible consumer remains byte-for-byte unchanged.

package/dist/nx/initialization.js

@@ -51,6 +51,21 @@ const CodexHooksSchema = Type.Object({
     })),
 }, { additionalProperties: true, description: "Consumer-owned Codex hook configuration." });
 const ConsumerPackageSchema = Type.Object({
+    dependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Runtime dependencies installed directly in the Nx consumer.",
+    })),
+    scripts: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Consumer-owned package lifecycle and command scripts.",
+    })),
+    devDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Development tools installed directly in the Nx consumer.",
+    })),
+    optionalDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Optional runtime dependencies installed in the Nx consumer.",
+    })),
+    peerDependencies: Type.Optional(Type.Record(Type.String(), Type.String(), {
+        description: "Peer dependency contracts declared by the Nx consumer.",
+    })),
     trustedDependencies: Type.Optional(Type.Array(Type.String({ minLength: 1 }), {
         description: "Package lifecycle scripts explicitly trusted by the Bun consumer.",
     })),
@@ -58,7 +73,7 @@ const ConsumerPackageSchema = Type.Object({
 const hooksValidator = new Validator({}, CodexHooksSchema);
 const packageValidator = new Validator({}, ConsumerPackageSchema);
 /**
- * Converges one Nx consumer on the app-owned Habitat plugin, hook, and Grit trust.
+ * Converges one Nx consumer on Habitat's app-owned Nx, Codex, package, and Git-hook state.
  *
  * Every admission and compatibility decision completes before the first Tree
  * write, so an incompatible consumer remains byte-for-byte unchanged.
@@ -69,13 +84,16 @@ export function initializeHabitatConsumer(tree, binding) {
     const packageJson = readPackage(tree);
     const nxPlan = planNxInitialization(nxJson, binding);
     const hookPlan = planHookInitialization(hooks, binding);
-    const packagePlan = planPackageInitialization(packageJson, binding.gritPackage);
+    const packagePlan = planPackageInitialization(packageJson, binding);
+    const gitHookPlan = planGitHookInitialization(tree, binding.gitHook);
     if (nxPlan.changed)
         updateNxJson(tree, nxPlan.value);
     if (hookPlan.changed)
         writeJson(tree, CODEX_HOOKS_PATH, hookPlan.value);
     if (packagePlan.changed)
         writeJson(tree, PACKAGE_PATH, packagePlan.value);
+    if (gitHookPlan.changed)
+        tree.write(binding.gitHook.path, gitHookPlan.value);
     return { packageChanged: packagePlan.changed };
 }
 /** Removes only Habitat's named hook group while preserving installed Nx integration. */
@@ -167,19 +185,64 @@ function planHookRemoval(hooks, binding) {
         },
     };
 }
-function planPackageInitialization(packageJson, gritPackage) {
+function planPackageInitialization(packageJson, binding) {
+    const { gritPackage, husky } = binding;
     const trusted = packageJson.trustedDependencies ?? [];
     const matches = trusted.filter((dependency) => dependency === gritPackage);
     if (matches.length > 1) {
         throw new Error(`package.json contains duplicate ${gritPackage} trust entries.`);
     }
-    if (matches.length === 1)
+    const currentHuskyVersion = packageJson.devDependencies?.[husky.package];
+    const invalidHuskyPlacement = ["dependencies", "optionalDependencies", "peerDependencies"].find((bucket) => packageJson[bucket]?.[husky.package] !== undefined);
+    if (invalidHuskyPlacement !== undefined) {
+        throw new Error(`package.json must declare ${husky.package} only in devDependencies; found ${invalidHuskyPlacement}.`);
+    }
+    if (currentHuskyVersion !== undefined && currentHuskyVersion !== husky.version) {
+        throw new Error(`package.json contains an incompatible ${husky.package} version: ${currentHuskyVersion}.`);
+    }
+    const currentPrepare = packageJson.scripts?.prepare;
+    if (currentPrepare !== undefined &&
+        currentPrepare !== husky.prepare &&
+        !husky.predecessorPrepareScripts.includes(currentPrepare)) {
+        throw new Error("package.json contains an incompatible prepare script.");
+    }
+    const trustedChanged = matches.length === 0;
+    const huskyChanged = currentHuskyVersion === undefined;
+    const prepareChanged = currentPrepare !== husky.prepare;
+    const currentCheck = packageJson.scripts?.check;
+    if (currentCheck !== undefined && currentCheck.trim().length === 0) {
+        throw new Error("package.json contains an empty check script.");
+    }
+    const checkChanged = currentCheck === undefined;
+    if (!trustedChanged && !huskyChanged && !prepareChanged && !checkChanged) {
         return { changed: false, value: packageJson };
+    }
     return {
         changed: true,
-        value: { ...packageJson, trustedDependencies: [...trusted, gritPackage] },
+        value: {
+            ...packageJson,
+            scripts: {
+                ...packageJson.scripts,
+                check: currentCheck ?? binding.defaultCheckScript,
+                prepare: husky.prepare,
+            },
+            devDependencies: {
+                ...packageJson.devDependencies,
+                [husky.package]: husky.version,
+            },
+            trustedDependencies: trustedChanged ? [...trusted, gritPackage] : trusted,
+        },
     };
 }
+function planGitHookInitialization(tree, hook) {
+    if (!tree.exists(hook.path))
+        return { changed: true, value: hook.contents };
+    const contents = tree.read(hook.path, "utf8");
+    if (contents === null || contents.trim().length === 0) {
+        throw new Error(`${hook.path} is empty.`);
+    }
+    return { changed: false, value: contents };
+}
 function oneOwnedHookLocation(hooks, binding) {
     const identity = binding.hook._habitat.identity;
     const locations = Object.entries(hooks.hooks ?? {}).flatMap(([event, groups]) => groups.flatMap((group, index) => {

package/dist/nx/projection.js

@@ -224,13 +224,13 @@ function ownerInputs(targets, runtimeInputs) {
 function applicationInputs(application, runtimeInputs) {
     const files = new Set(HABITAT_CATALOG_PATHS.map(workspaceInput));
     if (application.runner.name === "grit") {
-        files.add(workspaceInput(application.runner.pattern.relativePath));
+        addLocalAssetInput(files, application.runner.pattern);
         for (const entry of application.runner.acquisition.entries) {
             addSubjectInputs(files, entry.path, entry.kind);
         }
     }
     else {
-        files.add(workspaceInput(application.runner.structure.relativePath));
+        addLocalAssetInput(files, application.runner.structure);
         for (const binding of application.runner.rootBindings) {
             if (binding.path !== undefined)
                 addSubjectInputs(files, binding.path, binding.kind);
@@ -242,20 +242,24 @@ function compatibilityInputs(rule, runtimeInputs) {
     const files = new Set(HABITAT_CATALOG_PATHS.map(workspaceInput));
     files.add(workspaceInput(".habitat/**"));
     files.add(workspaceInput(rule.manifestPath));
-    files.add(workspaceInput(rule.baseline.relativePath));
+    addLocalAssetInput(files, rule.baseline);
     for (const pattern of rule.coveragePatterns)
         files.add(workspaceInput(pattern));
     if (rule.runner.name === "grit") {
-        files.add(workspaceInput(rule.runner.pattern.relativePath));
+        addLocalAssetInput(files, rule.runner.pattern);
         for (const entry of rule.runner.acquisition.entries) {
             addSubjectInputs(files, entry.path, entry.kind);
         }
     }
     else {
-        files.add(workspaceInput(rule.runner.structure.relativePath));
+        addLocalAssetInput(files, rule.runner.structure);
     }
     return [...runtimeInputs, ...[...files].sort(compareText)];
 }
+function addLocalAssetInput(target, asset) {
+    if (asset.provenance.kind === "local")
+        target.add(workspaceInput(asset.relativePath));
+}
 function addSubjectInputs(target, path, kind) {
     const exact = workspaceInput(path);
     if (kind === "directory" && path === ".") {

package/dist/nx-generators.d.ts

@@ -1,6 +1,17 @@
 /** Exact app-owned identities projected by the public Habitat Nx generators. */
 export declare const habitatConsumerBinding: {
+    readonly defaultCheckScript: "nx run-many -t check";
+    readonly gitHook: {
+        readonly path: ".husky/pre-push";
+        readonly contents: "# Nested Git work must discover its own repository.\nunset $(git rev-parse --local-env-vars)\nbun run check\n";
+    };
     readonly gritPackage: "@getgrit/cli";
+    readonly husky: {
+        readonly package: "husky";
+        readonly version: "9.1.7";
+        readonly prepare: "husky";
+        readonly predecessorPrepareScripts: readonly ["./scripts/dev/install-repository-hooks.sh", "git config core.hooksPath scripts/githooks"];
+    };
     readonly nxPlugin: "@habitat-ai/cli/nx-plugin";
     readonly predecessorNxPlugins: readonly [{
         readonly plugin: "@habitat/cli/nx-plugin";

package/dist/nx-generators.js

@@ -1,6 +1,23 @@
 /** Exact app-owned identities projected by the public Habitat Nx generators. */
 export const habitatConsumerBinding = {
+    defaultCheckScript: "nx run-many -t check",
+    gitHook: {
+        path: ".husky/pre-push",
+        contents: `# Nested Git work must discover its own repository.
+unset $(git rev-parse --local-env-vars)
+bun run check
+`,
+    },
     gritPackage: "@getgrit/cli",
+    husky: {
+        package: "husky",
+        version: "9.1.7",
+        prepare: "husky",
+        predecessorPrepareScripts: [
+            "./scripts/dev/install-repository-hooks.sh",
+            "git config core.hooksPath scripts/githooks",
+        ],
+    },
     nxPlugin: "@habitat-ai/cli/nx-plugin",
     predecessorNxPlugins: [
         {

package/dist/nx-plugin.js

@@ -4,6 +4,7 @@ const clientForWorkspace = createHabitatClientForWorkspace;
 const plugin = createHabitatNxPlugin({
     clientForWorkspace,
     runtimeInputs: [
+        { externalDependencies: ["@habitat-ai/cli", "@habitat-ai/sdk"] },
         "{workspaceRoot}/bun.lock",
         "{workspaceRoot}/package.json",
         { env: "HABITAT_COMMAND_TIMEOUT_MS" },

package/oclif.manifest.json

@@ -99,5 +99,5 @@
       ]
     }
   },
-  "version": "0.4.1"
+  "version": "0.5.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habitat-ai/cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "test": "vitest run --project habitat-cli"
   },
   "dependencies": {
-    "@habitat-ai/sdk": "0.4.1",
+    "@habitat-ai/sdk": "0.5.0",
     "@nx/devkit": "23.1.0",
     "@oclif/core": "^4.13.2",
     "@oclif/plugin-help": "^6.2.27",