@habitat-ai/cli 0.5.4 → 0.5.6

package/dist/command.d.ts

@@ -0,0 +1,44 @@
+import { Command } from "@oclif/core";
+/** Normalized values for the shared machine-output and mutation-control flags. */
+export type HabitatBaseFlags = {
+    json: boolean;
+    dryRun: boolean;
+    yes: boolean;
+};
+/** Structured command failure rendered consistently for machine and human callers. */
+export type HabitatError = {
+    message: string;
+    code?: string;
+    details?: unknown;
+};
+/** Stable success-or-failure envelope returned by Habitat command projections. */
+export type HabitatResult<TData = unknown> = {
+    ok: true;
+    data?: TData;
+    warnings?: string[];
+    meta?: Record<string, unknown>;
+} | {
+    ok: false;
+    error: HabitatError;
+    meta?: Record<string, unknown>;
+};
+/** Shared result and output contract for native Oclif command projections. */
+export declare abstract class HabitatCommand extends Command {
+    static baseFlags: {
+        readonly json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        readonly "dry-run": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        readonly yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected ok<TData>(data?: TData, meta?: Record<string, unknown>, warnings?: string[]): HabitatResult<TData>;
+    protected fail(message: string, options?: {
+        code?: string;
+        details?: unknown;
+        meta?: Record<string, unknown>;
+    }): HabitatResult<never>;
+    /** Renders one result through the selected machine or human output channel. */
+    protected outputResult<TData>(result: HabitatResult<TData>, options?: {
+        flags?: HabitatBaseFlags;
+        human?: (result: HabitatResult<TData>) => void;
+    }): Promise<void>;
+    static extractBaseFlags(flags: Record<string, unknown>): HabitatBaseFlags;
+}

package/dist/command.js

@@ -0,0 +1,45 @@
+import { Command, Flags } from "@oclif/core";
+import { writeJsonResult } from "./lib/output.js";
+/** Shared result and output contract for native Oclif command projections. */
+export class HabitatCommand extends Command {
+    static baseFlags = {
+        json: Flags.boolean({ description: "Output machine-readable JSON" }),
+        "dry-run": Flags.boolean({
+            description: "Print actions without making any changes",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Assume yes for prompts/confirmation",
+        }),
+    };
+    ok(data, meta, warnings) {
+        return { ok: true, data, meta, warnings };
+    }
+    fail(message, options) {
+        return {
+            ok: false,
+            error: { message, code: options?.code, details: options?.details },
+            meta: options?.meta,
+        };
+    }
+    /** Renders one result through the selected machine or human output channel. */
+    async outputResult(result, options) {
+        const flags = options?.flags ?? { json: false, dryRun: false, yes: false };
+        if (flags.json) {
+            await writeJsonResult(result);
+            return;
+        }
+        if (options?.human) {
+            options.human(result);
+            return;
+        }
+        this.log(result.ok ? "ok" : `error: ${result.error.message}`);
+    }
+    static extractBaseFlags(flags) {
+        return {
+            json: Boolean(flags.json),
+            dryRun: Boolean(flags["dry-run"] ?? flags.dryRun),
+            yes: Boolean(flags.yes),
+        };
+    }
+}

package/dist/generators/init.js

@@ -1,12 +1,15 @@
 import { execSync } from "node:child_process";
 import { getPackageManagerCommand, installPackagesTask, runTasksInSerial, } from "@nx/devkit";
 import { initializeHabitatConsumer } from "../nx/initialization.js";
-import { assertHabitatBunConsumer } from "../nx/repository-preset.js";
+import { assertHabitatBunConsumer, initializeHabitatBunRepository, } 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) {
     assertHabitatBunConsumer(tree);
-    const result = initializeHabitatConsumer(tree, habitatConsumerBinding);
+    const repository = initializeHabitatBunRepository(tree, habitatConsumerBinding, {
+        packageManager: "bun",
+    });
+    const consumer = initializeHabitatConsumer(tree, habitatConsumerBinding);
     const activateHusky = () => {
         const command = `${getPackageManagerCommand("bun").exec} husky`;
         execSync(command, {
@@ -14,7 +17,7 @@ export default function initializeHabitat(tree) {
             stdio: "inherit",
         });
     };
-    if (!result.packageChanged)
+    if (!repository.packageChanged && !consumer.packageChanged)
         return activateHusky;
     return runTasksInSerial(() => installPackagesTask(tree, false, "", "bun"), activateHusky);
 }

package/dist/generators/service.d.ts

@@ -0,0 +1,16 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+/** Exact non-SDK dependency pins emitted into every constructed service package. */
+export declare const SERVICE_GENERATOR_DEPENDENCY_VERSIONS: {
+    readonly "@orpc/contract": "2.0.0-beta.23";
+    readonly "@orpc/server": "2.0.0-beta.23";
+    readonly typebox: "1.3.8";
+};
+/** Options for constructing one closed Habitat service package. */
+export interface ServiceGeneratorOptions {
+    readonly name: string;
+    readonly directory: string;
+    readonly module: string;
+    readonly operation: string;
+}
+/** Constructs a private service package through Nx and schedules Bun dependency installation. */
+export default function createService(tree: Tree, options: ServiceGeneratorOptions): Promise<GeneratorCallback>;

package/dist/generators/service.js

@@ -0,0 +1,164 @@
+import { fileURLToPath } from "node:url";
+import { addProjectConfiguration, generateFiles, getProjects, installPackagesTask, names, OverwriteStrategy, readJson, } from "@nx/devkit";
+import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, } from "nx/src/plugins/package-json";
+import { Type } from "typebox";
+import { Validator } from "typebox/schema";
+import { assertHabitatBunConsumer } from "../nx/repository-preset.js";
+import { installedSdkVersion } from "../product-version.js";
+const PACKAGE_NAME_PATTERN = "^(?:@[a-z0-9][a-z0-9._-]*/)?[a-z0-9][a-z0-9._-]*$";
+const KEBAB_NAME_PATTERN = "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
+const STRICT_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** Exact non-SDK dependency pins emitted into every constructed service package. */
+export const SERVICE_GENERATOR_DEPENDENCY_VERSIONS = {
+    "@orpc/contract": "2.0.0-beta.23",
+    "@orpc/server": "2.0.0-beta.23",
+    typebox: "1.3.8",
+};
+const RESERVED_IDENTIFIERS = new Set([
+    "arguments",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+]);
+const ORPC_IMPLEMENTER_MEMBERS = new Set(["lazy", "middleware", "router", "use"]);
+const SERVICE_CONTEXT_LANES = new Set(["config", "deps", "invocation", "provided", "scope"]);
+const ServiceGeneratorOptionsSchema = Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 214, pattern: PACKAGE_NAME_PATTERN }),
+    directory: Type.String({ minLength: 1 }),
+    module: Type.String({ pattern: KEBAB_NAME_PATTERN }),
+    operation: Type.String({ pattern: KEBAB_NAME_PATTERN }),
+}, { additionalProperties: false });
+const optionsValidator = new Validator({}, ServiceGeneratorOptionsSchema);
+/** Constructs a private service package through Nx and schedules Bun dependency installation. */
+export default async function createService(tree, options) {
+    assertOptions(options);
+    assertPortableDirectory(options.directory);
+    assertHabitatBunConsumer(tree);
+    assertWorkspaceDestination(tree, options.directory);
+    const moduleNames = names(options.module);
+    const operationNames = names(options.operation);
+    assertStrictIdentifier("module", moduleNames.propertyName);
+    assertStrictIdentifier("operation", operationNames.propertyName);
+    assertAvailableModuleName(moduleNames.propertyName);
+    const stagedProjects = getProjects(tree);
+    if (stagedProjects.has(options.name)) {
+        throw new Error(`Cannot generate service '${options.name}': an Nx project already uses that name.`);
+    }
+    const stagedRootCollision = [...stagedProjects.entries()].find(([, project]) => project.root === options.directory);
+    if (stagedRootCollision !== undefined) {
+        throw new Error(`Cannot generate service '${options.name}': destination '${options.directory}' is already owned by staged Nx project '${stagedRootCollision[0]}'.`);
+    }
+    if (tree.exists(options.directory) || tree.children(options.directory).length > 0) {
+        throw new Error(`Cannot generate service '${options.name}': destination '${options.directory}' is occupied.`);
+    }
+    const tsconfigBasePath = `${"../".repeat(options.directory.split("/").length)}tsconfig.base.json`;
+    const templateRoot = fileURLToPath(new URL("../../generators/service/files", import.meta.url));
+    const dependenciesJson = indentJson({
+        "@habitat-ai/sdk": installedSdkVersion(),
+        ...SERVICE_GENERATOR_DEPENDENCY_VERSIONS,
+    }, 2);
+    generateFiles(tree, templateRoot, options.directory, {
+        directory: options.directory,
+        directoryLiteral: JSON.stringify(options.directory),
+        dependenciesJson,
+        moduleFileName: moduleNames.fileName,
+        moduleName: moduleNames.propertyName,
+        moduleLocalName: moduleNames.propertyName,
+        name: options.name,
+        nameLiteral: JSON.stringify(options.name),
+        operationFileName: operationNames.fileName,
+        operationName: operationNames.propertyName,
+        tsconfigBasePath,
+    }, { overwriteStrategy: OverwriteStrategy.ThrowIfExisting });
+    addProjectConfiguration(tree, options.name, {
+        root: options.directory,
+        tags: ["type:service", "role:servicepackage"],
+        targets: {
+            check: {
+                executor: "nx:noop",
+            },
+        },
+    });
+    return () => installPackagesTask(tree, true, "", "bun");
+}
+function assertOptions(options) {
+    if (!optionsValidator.Check(options)) {
+        throw new Error("Service generator options require a valid package name, workspace-relative directory, and kebab-case module and operation.");
+    }
+}
+function assertPortableDirectory(directory) {
+    const segments = directory.split("/");
+    if (directory.startsWith("/") ||
+        /^[A-Za-z]:/.test(directory) ||
+        directory.includes("\\") ||
+        directory.trim() !== directory ||
+        segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new Error(`Cannot generate service in '${directory}': directory must be a normalized workspace-relative path without traversal.`);
+    }
+}
+function assertWorkspaceDestination(tree, directory) {
+    const patterns = buildPackageJsonPatterns(tree.root, (path) => readJson(tree, path));
+    const isWorkspacePackage = buildPackageJsonWorkspacesMatcher(patterns);
+    if (!isWorkspacePackage(`${directory}/package.json`)) {
+        throw new Error(`Cannot generate service in '${directory}': destination must match a Bun workspace declared in package.json.`);
+    }
+}
+function assertStrictIdentifier(kind, identifier) {
+    if (!STRICT_IDENTIFIER_PATTERN.test(identifier) ||
+        RESERVED_IDENTIFIERS.has(identifier) ||
+        ORPC_IMPLEMENTER_MEMBERS.has(identifier)) {
+        throw new Error(`Cannot generate service: ${kind} '${identifier}' collides with JavaScript or oRPC implementer syntax.`);
+    }
+}
+function assertAvailableModuleName(identifier) {
+    if (SERVICE_CONTEXT_LANES.has(identifier)) {
+        throw new Error(`Cannot generate service: module '${identifier}' is reserved for the service context.`);
+    }
+}
+function indentJson(value, spaces) {
+    return JSON.stringify(value, null, 2).replaceAll("\n", `\n${" ".repeat(spaces)}`);
+}

package/dist/nx/repository-preset.js

@@ -15,7 +15,9 @@ const ALTERNATE_PACKAGE_MANAGER_PATHS = [
 ];
 const BUN_VERSION = "1.3.14";
 const BIOME_VERSION = "2.5.3";
+const ESLINT_VERSION = "10.0.3";
 const NX_VERSION = "23.1.1";
+const TYPESCRIPT_ESLINT_PARSER_VERSION = "8.66.0";
 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." })),
@@ -101,8 +103,12 @@ const standardScripts = {
 };
 const standardDevDependencies = {
     "@biomejs/biome": BIOME_VERSION,
+    "@nx/eslint": NX_VERSION,
+    "@nx/eslint-plugin": NX_VERSION,
+    "@typescript-eslint/parser": TYPESCRIPT_ESLINT_PARSER_VERSION,
     "@types/node": "24.13.3",
     "bun-types": BUN_VERSION,
+    eslint: ESLINT_VERSION,
     nx: NX_VERSION,
     typescript: "5.9.3",
 };
@@ -121,6 +127,10 @@ const nativeNxPresetNamedInputs = {
     default: ["{projectRoot}/**/*", "sharedGlobals"],
     production: ["default"],
 };
+const nxEslintPlugin = {
+    plugin: "@nx/eslint/plugin",
+    options: { targetName: "check:boundaries" },
+};
 const standardTargetDefaults = {
     build: {
         cache: true,
@@ -132,6 +142,7 @@ const standardTargetDefaults = {
         cache: false,
         dependsOn: [
             { projects: ["habitat"], target: "lint" },
+            "check:boundaries",
             "typecheck",
             "verify",
             "check:policy",
@@ -164,6 +175,45 @@ linker = "isolated"
 # Registry versions remain registry consumers; source relationships opt in with workspace:*.
 linkWorkspacePackages = false
 `;
+const eslintConfig = `import nxPlugin from "@nx/eslint-plugin";
+import tsParser from "@typescript-eslint/parser";
+
+export default [
+  ...nxPlugin.configs["flat/base"],
+  {
+    files: ["**/*.{js,jsx,cjs,mjs,ts,tsx,cts,mts}"],
+    ignores: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/coverage/**",
+      "**/.nx/**",
+      "**/.habitat/cache/**",
+      "**/.tmp/**",
+    ],
+    rules: {
+      "@nx/enforce-module-boundaries": [
+        "error",
+        {
+          allow: [],
+          depConstraints: [],
+          enforceBuildableLibDependency: false,
+        },
+      ],
+    },
+  },
+  {
+    files: ["**/*.{ts,tsx,cts,mts}"],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaFeatures: { jsx: true },
+        ecmaVersion: "latest",
+        sourceType: "module",
+      },
+    },
+  },
+];
+`;
 const standardTypeScriptCompilerOptions = {
     target: "ES2022",
     module: "ESNext",
@@ -465,12 +515,26 @@ function planRootPackage(packageJson) {
 function planNxJson(nxJson) {
     assertReservedNxValues("named input", nxJson.namedInputs, standardNamedInputs, nativeNxPresetNamedInputs);
     assertReservedNxValues("target default", nxJson.targetDefaults, standardTargetDefaults);
+    const plugins = planNxEslintRegistration(nxJson.plugins);
     return {
         ...nxJson,
+        plugins,
         namedInputs: { ...nxJson.namedInputs, ...standardNamedInputs },
         targetDefaults: { ...nxJson.targetDefaults, ...standardTargetDefaults },
     };
 }
+function planNxEslintRegistration(plugins) {
+    const existing = plugins ?? [];
+    const matches = existing.filter((plugin) => (typeof plugin === "string" ? plugin : plugin.plugin) === nxEslintPlugin.plugin);
+    if (matches.length > 1) {
+        throw new Error("nx.json contains multiple Nx ESLint plugin registrations.");
+    }
+    const match = matches[0];
+    if (match !== undefined && !isDeepStrictEqual(match, nxEslintPlugin)) {
+        throw new Error("nx.json contains an incompatible Nx ESLint plugin registration.");
+    }
+    return match === undefined ? [...existing, nxEslintPlugin] : [...existing];
+}
 function assertReservedNxValues(kind, existing, canonical, admittedPredecessors = {}) {
     for (const [name, value] of Object.entries(canonical)) {
         const current = existing?.[name];
@@ -505,6 +569,7 @@ function plannedTextFiles(tree) {
     return [
         { path: "biome.json", contents: biomeConfig },
         { path: "bunfig.toml", contents: bunfig },
+        { path: "eslint.config.mjs", contents: eslintConfig },
         { path: HABITAT_PROJECT_PATH, contents: habitatProject },
     ].filter((file) => !tree.exists(file.path) || isEmptyTextFile(tree, file.path));
 }

package/dist/product-version.d.ts

@@ -0,0 +1,2 @@
+/** Returns the exact SDK version paired with the installed Habitat CLI. */
+export declare function installedSdkVersion(): string;

package/dist/product-version.js

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const EXACT_SEMVER_PATTERN = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const cliPackageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+/** Returns the exact SDK version paired with the installed Habitat CLI. */
+export function installedSdkVersion() {
+    const manifest = JSON.parse(readFileSync(cliPackageJsonPath, "utf8"));
+    const version = manifest.dependencies?.["@habitat-ai/sdk"];
+    if (typeof version !== "string" ||
+        !EXACT_SEMVER_PATTERN.test(version) ||
+        version !== manifest.version) {
+        throw new Error("Installed @habitat-ai/cli and @habitat-ai/sdk must use one identical exact semantic version.");
+    }
+    return version;
+}

package/generators/service/files/AGENTS.md.template

@@ -0,0 +1,31 @@
+# <%= name %> Service Router
+
+## Purpose
+
+- Own the runtime capability exposed through this package's public client.
+
+## Scope
+
+- Applies to this service package and its private implementation spine.
+
+## Boundaries
+
+- Consumers enter only through `src/client.ts` and the package's `./client` export.
+- App composition supplies ready resources and public service clients through context.
+- Transports, orchestration, provider acquisition, and runtime mounting stay outside this service.
+
+## Flow
+
+- The public contract descends through one native oRPC implementation lineage.
+- The module projects its named dependency into the direct handler vocabulary, and its router leaf
+  authors `<%= operationName %>`.
+- Native oRPC retains inherited context additively; the direct projection narrows authorship rather
+  than claiming runtime erasure.
+- Module and service routers only compose already-authored operations.
+- The initial operation uses an inline native `.handler(...)`. When authored operations genuinely
+  require Effect, install the official `.effect(...)` extension once in `src/service/impl.ts` and
+  author their generators directly in the operation routers.
+
+## Validation
+
+- Run `bunx nx run <%= name %>:typecheck` and `bunx nx run <%= name %>:build`.

package/generators/service/files/habitat.toml.template

@@ -0,0 +1,10 @@
+schemaVersion = 1
+id = <%- nameLiteral %>
+ownerProject = <%- nameLiteral %>
+blueprint = "service"
+blueprintVersion = 1
+
+[roots]
+project = <%- directoryLiteral %>
+
+[selections]

package/generators/service/files/package.json.template

@@ -0,0 +1,26 @@
+{
+  "name": "<%= name %>",
+  "private": true,
+  "type": "module",
+  "packageManager": "bun@1.3.14",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    }
+  },
+  "scripts": {
+    "build": "bun --eval 'await import(\"node:fs/promises\").then(({ rm }) => rm(\"dist\", { recursive: true, force: true }))' && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": <%- dependenciesJson %>,
+  "nx": {
+    "tags": [
+      "type:service",
+      "role:servicepackage"
+    ]
+  }
+}

package/generators/service/files/src/client.ts.template

@@ -0,0 +1,35 @@
+import type { RouterContractClient } from "@orpc/contract";
+import { createRouterClient } from "@orpc/server";
+import type { Context } from "./service/base.js";
+import { type Contract, contract } from "./service/contract.js";
+import { router } from "./service/router.js";
+
+export { type Contract, contract };
+
+/** Host-supplied ready capabilities used by service operations. */
+export type Deps = Context["deps"];
+
+/** Stable caller scope fixed at client construction. */
+export type Scope = Context["scope"];
+
+/** App-selected service policy fixed at client construction. */
+export type Config = Context["config"];
+
+/** Public construction boundary for one in-process client. */
+export type CreateClientOptions = Pick<Context, "deps" | "scope" | "config">;
+
+/** Typed caller surface derived from the public contract. */
+export type Client = RouterContractClient<Contract>;
+
+/** Constructs the sole public client over the private service router. */
+export function createClient({ deps, scope, config }: CreateClientOptions): Client {
+  return createRouterClient(router, {
+    context: {
+      deps,
+      scope,
+      config,
+      invocation: {},
+      provided: {},
+    } satisfies Context,
+  });
+}

package/generators/service/files/src/service/base.ts.template

@@ -0,0 +1,17 @@
+import { os } from "@orpc/server";
+
+type EmptyContextLane = Readonly<Record<PropertyKey, never>>;
+
+/** Complete five-lane context supplied before module-local curation. */
+export type Context = {
+  readonly deps: {
+    readonly <%= moduleName %>: unknown;
+  };
+  readonly scope: EmptyContextLane;
+  readonly config: EmptyContextLane;
+  readonly invocation: EmptyContextLane;
+  readonly provided: EmptyContextLane;
+};
+
+/** Standalone middleware author rooted in the complete service context. */
+export const base = os.$context<Context>();

package/generators/service/files/src/service/contract.ts.template

@@ -0,0 +1,8 @@
+import { oc } from "@orpc/contract";
+import { contract as <%= moduleLocalName %> } from "./modules/<%= moduleFileName %>/contract/index.js";
+
+/** Public service contract composed from its semantic modules. */
+export const contract = oc.router({ <%= moduleName %>: <%= moduleLocalName %> });
+
+/** Caller contract type exposed through the public client face. */
+export type Contract = typeof contract;

package/generators/service/files/src/service/impl.ts.template

@@ -0,0 +1,9 @@
+import { implement } from "@orpc/server";
+import type { Context } from "./base.js";
+import { contract } from "./contract.js";
+
+/** Unconfigured implementer retained for aggregate router completion. */
+export const impl = implement(contract).$context<Context>();
+
+/** Configured service lineage from which modules descend. */
+export const service = impl;

package/generators/service/files/src/service/modules/__moduleFileName__/AGENTS.md.template

@@ -0,0 +1,22 @@
+# <%= moduleName %> Module Router
+
+## Purpose
+
+- Own the `<%= operationName %>` operation at this service boundary.
+
+## Boundaries
+
+- The contract directory owns caller-visible schemas.
+- `module.ts` projects the named dependency into the direct handler vocabulary without acquiring
+  resources or providers.
+- Native oRPC retains inherited context additively; the projection narrows authorship rather than
+  claiming runtime erasure.
+- The named router leaf owns operation behavior; router faces only compose.
+
+## Interfaces
+
+- `<%= operationName %>` is the module's native operation.
+
+## Validation
+
+- Run the owning service's typecheck and build targets.

package/generators/service/files/src/service/modules/__moduleFileName__/contract/__operationFileName__.ts.template

@@ -0,0 +1,15 @@
+import { standard } from "@habitat-ai/sdk/service/schema";
+import { oc } from "@orpc/contract";
+import { Type } from "typebox";
+
+const InputSchema = Type.Object(
+  {},
+  { additionalProperties: false, description: "Empty <%= operationName %> operation input." }
+);
+const OutputSchema = Type.Object(
+  {},
+  { additionalProperties: false, description: "Empty <%= operationName %> operation output." }
+);
+
+/** Minimal TypeBox-backed <%= operationName %> operation contract. */
+export const <%= operationName %> = oc.input(standard(InputSchema)).output(standard(OutputSchema));

package/generators/service/files/src/service/modules/__moduleFileName__/contract/index.ts.template

@@ -0,0 +1,6 @@
+import { <%= operationName %> } from "./<%= operationFileName %>.js";
+
+/** Module contract composed from its semantic operation leaves. */
+export const contract = {
+  <%= operationName %>,
+};

package/generators/service/files/src/service/modules/__moduleFileName__/module.ts.template

@@ -0,0 +1,6 @@
+import { service } from "../../impl.js";
+
+/** Projects the module's named dependency into the direct handler vocabulary. */
+export const module = service.<%= moduleName %>.use(({ context, next }) =>
+  next({ context: { <%= moduleName %>: context.deps.<%= moduleName %> } })
+);

package/generators/service/files/src/service/modules/__moduleFileName__/router/__operationFileName__.ts.template

@@ -0,0 +1,7 @@
+import { module } from "../module.js";
+
+/** Authors the <%= operationName %> operation at its named router leaf. */
+export const <%= operationName %> = module.<%= operationName %>.handler(({ context }) => {
+  void context.<%= moduleName %>;
+  return {};
+});

package/generators/service/files/src/service/modules/__moduleFileName__/router.ts.template

@@ -0,0 +1,6 @@
+import { <%= operationName %> } from "./router/<%= operationFileName %>.js";
+
+/** Composes completed operations into the module router face. */
+export const router = {
+  <%= operationName %>,
+};

package/generators/service/files/src/service/router.ts.template

@@ -0,0 +1,5 @@
+import { impl } from "./impl.js";
+import { router as <%= moduleLocalName %> } from "./modules/<%= moduleFileName %>/router.js";
+
+/** Completes the contract from already-authored module routers. */
+export const router = impl.router({ <%= moduleName %>: <%= moduleLocalName %> });

package/generators/service/files/tsconfig.build.json.template

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "noEmit": false
+  }
+}

package/generators/service/files/tsconfig.json.template

@@ -0,0 +1,11 @@
+{
+  "extends": "<%= tsconfigBasePath %>",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "noUnusedLocals": true
+  },
+  "include": [
+    "src"
+  ]
+}

package/generators/service/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 214,
+      "pattern": "^(?:@[a-z0-9][a-z0-9._-]*/)?[a-z0-9][a-z0-9._-]*$",
+      "description": "Exact Nx project, package, Habitat instance, and owner identity."
+    },
+    "directory": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Full workspace-relative root for the service package."
+    },
+    "module": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+      "description": "Kebab-case semantic module name."
+    },
+    "operation": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+      "description": "Kebab-case semantic operation name."
+    }
+  },
+  "required": ["name", "directory", "module", "operation"],
+  "additionalProperties": false
+}

package/generators.json

@@ -15,6 +15,11 @@
       "factory": "./dist/generators/remove-hook.js",
       "schema": "./generators.schema.json",
       "description": "Remove Habitat's named Codex hook contribution."
+    },
+    "service": {
+      "factory": "./dist/generators/service.js",
+      "schema": "./generators/service/schema.json",
+      "description": "Construct one closed Habitat service package."
     }
   }
 }

package/oclif.manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habitat-ai/cli",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "private": false,
   "repository": {
     "type": "git",
@@ -18,6 +18,7 @@
   "files": [
     "bin",
     "dist",
+    "generators",
     "generators.json",
     "generators.schema.json",
     "preset.schema.json",
@@ -35,6 +36,11 @@
     ]
   },
   "exports": {
+    "./command": {
+      "types": "./dist/command.d.ts",
+      "import": "./dist/command.js",
+      "default": "./dist/command.js"
+    },
     "./nx-plugin": {
       "types": "./dist/nx-plugin.d.ts",
       "import": "./dist/nx-plugin.js",
@@ -52,7 +58,7 @@
     "test": "vitest run --project habitat-cli"
   },
   "dependencies": {
-    "@habitat-ai/sdk": "0.5.4",
+    "@habitat-ai/sdk": "0.5.6",
     "@nx/devkit": "23.1.1",
     "@oclif/core": "^4.13.2",
     "@oclif/plugin-help": "^6.2.27",