@habitat-ai/cli 0.3.1 → 0.4.1

package/dist/nx/projection.js

@@ -0,0 +1,293 @@
+import { posix } from "node:path";
+const HABITAT_CATALOG_PATHS = [
+    ".habitat/blueprints/*/blueprint.toml",
+    ".habitat/index.json",
+    ".habitat/**/rule.json",
+    "**/habitat.toml",
+];
+const HABITAT_AUTHORITY_GLOB = `{${HABITAT_CATALOG_PATHS.join(",")}}`;
+const DEFAULT_CHECK_TARGET = "check:policy";
+const HABITAT_EXECUTABLE = "habitat";
+const PORTABLE_OWNER_PROJECT = /^[A-Za-z0-9@][A-Za-z0-9@._/+:-]*$/u;
+/**
+ * Projects resolved Habitat applications and compatibility rules into native Nx targets.
+ *
+ * The factory receives the app-owned workspace client and runtime cache facts.
+ * It does not select providers, discover authority, execute checks, or name
+ * projects.
+ */
+export function createHabitatNxPlugin(binding) {
+    const createNodes = [
+        HABITAT_AUTHORITY_GLOB,
+        async (configFiles, _options, context) => {
+            const matchedFiles = [...new Set(configFiles.map(normalizeWorkspacePath))].sort();
+            const client = await binding.clientForWorkspace(context.workspaceRoot);
+            const result = await client.catalog.resolve({});
+            if (result._tag === "Rejected")
+                throw rejectedCatalogError(result);
+            return projectCatalogTargets(matchedFiles, result.catalog, binding.runtimeInputs);
+        },
+    ];
+    return Object.freeze({ createNodes });
+}
+function projectCatalogTargets(matchedFiles, catalog, runtimeInputs) {
+    if (catalog.applications.length === 0 && catalog.compatibility.rules.length === 0)
+        return [];
+    const authorityFiles = new Set(matchedFiles);
+    const instances = indexInstances(catalog.instances);
+    const rootsByOwner = new Map();
+    const ownersByRoot = new Map();
+    const projects = new Map();
+    for (const [ownerProject, ownerRoot] of Object.entries(catalog.compatibility.ownerRoots).sort(([left], [right]) => compareText(left, right))) {
+        recordOwnerRoot(ownerProject, ownerRoot, rootsByOwner, ownersByRoot);
+    }
+    for (const application of catalog.applications) {
+        const instance = requireApplicationInstance(application, instances);
+        const manifestPath = requireMatchedManifest(application.manifestPath, authorityFiles, `instance '${instance.id}'`);
+        const root = recordOwnerRoot(application.ownerProject, projectRootFor(manifestPath), rootsByOwner, ownersByRoot);
+        const project = projectFor(projects, root, application.ownerProject);
+        project.applicationManifests.add(manifestPath);
+        const targetName = applicationTargetName(application);
+        addLeafTarget(project, targetName, applicationTarget(application, runtimeInputs));
+    }
+    for (const rule of catalog.compatibility.rules) {
+        const root = rootsByOwner.get(rule.ownerProject);
+        if (root === undefined) {
+            throw new Error(`Habitat Nx projection rejected compatibility rule '${rule.ruleId}': owner '${rule.ownerProject}' has no root.`);
+        }
+        const manifestPath = requireMatchedManifest(rule.manifestPath, authorityFiles, `compatibility rule '${rule.ruleId}'`);
+        const project = projectFor(projects, root, rule.ownerProject);
+        project.compatibilityManifests.add(manifestPath);
+        addLeafTarget(project, compatibilityTargetName(rule), compatibilityTarget(rule, runtimeInputs));
+    }
+    return [...projects.entries()]
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([root, project]) => {
+        project.targets[DEFAULT_CHECK_TARGET] = ownerTarget(project.ownerProject, ownerInputs(project.targets, runtimeInputs), project.compatibilityManifests.size > 0);
+        return [
+            projectionSource(project),
+            {
+                projects: {
+                    [root]: {
+                        targets: Object.fromEntries(Object.entries(project.targets).sort(([left], [right]) => compareText(left, right))),
+                    },
+                },
+            },
+        ];
+    });
+}
+function recordOwnerRoot(ownerProject, ownerRoot, rootsByOwner, ownersByRoot) {
+    const root = normalizeWorkspacePath(ownerRoot);
+    const priorRoot = rootsByOwner.get(ownerProject);
+    if (priorRoot !== undefined && priorRoot !== root) {
+        throw new Error(`Habitat Nx projection rejected owner '${ownerProject}': roots '${priorRoot}' and '${root}' collide.`);
+    }
+    const priorOwner = ownersByRoot.get(root);
+    if (priorOwner !== undefined && priorOwner !== ownerProject) {
+        throw new Error(`Habitat Nx projection rejected root '${root}': owners '${priorOwner}' and '${ownerProject}' collide.`);
+    }
+    rootsByOwner.set(ownerProject, root);
+    ownersByRoot.set(root, ownerProject);
+    return root;
+}
+function projectFor(projects, root, ownerProject) {
+    const project = projects.get(root);
+    if (project !== undefined) {
+        if (project.ownerProject !== ownerProject) {
+            throw new Error(`Habitat Nx projection rejected root '${root}': owners '${project.ownerProject}' and '${ownerProject}' collide.`);
+        }
+        return project;
+    }
+    const created = {
+        ownerProject,
+        applicationManifests: new Set(),
+        compatibilityManifests: new Set(),
+        targets: {},
+    };
+    projects.set(root, created);
+    return created;
+}
+function requireMatchedManifest(path, authorityFiles, subject) {
+    const manifestPath = normalizeWorkspacePath(path);
+    if (!authorityFiles.has(manifestPath)) {
+        throw new Error(`Habitat Nx projection rejected ${subject}: manifest '${manifestPath}' is outside the matched authority files.`);
+    }
+    return manifestPath;
+}
+function addLeafTarget(project, targetName, target) {
+    if (Object.hasOwn(project.targets, targetName)) {
+        throw new Error(`Habitat Nx projection rejected duplicate target '${project.ownerProject}:${targetName}'.`);
+    }
+    project.targets[targetName] = target;
+}
+function projectionSource(project) {
+    const applicationManifest = [...project.applicationManifests].sort(compareText)[0];
+    if (applicationManifest !== undefined)
+        return applicationManifest;
+    const compatibilityManifest = [...project.compatibilityManifests].sort(compareText)[0];
+    if (compatibilityManifest === undefined) {
+        throw new Error(`Habitat Nx projection rejected owner '${project.ownerProject}': projected targets have no manifest.`);
+    }
+    return compatibilityManifest;
+}
+function requireApplicationInstance(application, instances) {
+    const instance = instances.get(application.instanceId);
+    if (!instance) {
+        throw new Error(`Habitat Nx projection rejected application '${application.ruleId}': instance '${application.instanceId}' is absent.`);
+    }
+    const mismatches = [
+        instance.ownerProject === application.ownerProject
+            ? undefined
+            : `owner '${application.ownerProject}' does not match '${instance.ownerProject}'`,
+        instance.blueprint === application.blueprint
+            ? undefined
+            : `blueprint '${application.blueprint}' does not match '${instance.blueprint}'`,
+        instance.blueprintVersion === application.blueprintVersion
+            ? undefined
+            : `blueprint version '${application.blueprintVersion}' does not match '${instance.blueprintVersion}'`,
+        normalizeWorkspacePath(instance.manifestPath) ===
+            normalizeWorkspacePath(application.manifestPath)
+            ? undefined
+            : `manifest '${application.manifestPath}' does not match '${instance.manifestPath}'`,
+    ].filter((mismatch) => mismatch !== undefined);
+    if (mismatches.length > 0) {
+        throw new Error(`Habitat Nx projection rejected instance '${instance.id}': ${mismatches.join("; ")}.`);
+    }
+    return instance;
+}
+function indexInstances(instances) {
+    const indexed = new Map();
+    for (const instance of instances) {
+        if (indexed.has(instance.id)) {
+            throw new Error(`Habitat Nx projection rejected duplicate instance '${instance.id}'.`);
+        }
+        indexed.set(instance.id, instance);
+    }
+    return indexed;
+}
+function applicationTargetName(application) {
+    return `habitat:application:${application.instanceId}:${application.ruleId}`;
+}
+function compatibilityTargetName(rule) {
+    return `habitat:rule:${rule.ruleId}`;
+}
+function applicationTarget(application, runtimeInputs) {
+    return {
+        command: `${HABITAT_EXECUTABLE} check --instance ${application.instanceId} --rule ${application.ruleId}`,
+        cache: true,
+        inputs: applicationInputs(application, runtimeInputs),
+        outputs: [],
+        options: { cwd: "{workspaceRoot}" },
+        metadata: {
+            description: `Check Habitat application ${application.instanceId}/${application.ruleId}`,
+        },
+    };
+}
+function compatibilityTarget(rule, runtimeInputs) {
+    return {
+        command: `${HABITAT_EXECUTABLE} check --rule ${rule.ruleId}`,
+        cache: true,
+        inputs: compatibilityInputs(rule, runtimeInputs),
+        outputs: [],
+        options: { cwd: "{workspaceRoot}" },
+        metadata: { description: `Check Habitat compatibility rule ${rule.ruleId}` },
+    };
+}
+function ownerTarget(ownerProject, inputs, hasCompatibility) {
+    if (!PORTABLE_OWNER_PROJECT.test(ownerProject)) {
+        throw new Error(`Habitat Nx projection rejected owner '${ownerProject}': identity is not portable as an Nx command argument.`);
+    }
+    return {
+        command: `${HABITAT_EXECUTABLE} check --owner ${ownerProject}`,
+        cache: true,
+        inputs,
+        outputs: [],
+        options: { cwd: "{workspaceRoot}" },
+        metadata: {
+            description: hasCompatibility
+                ? `Check resolved Habitat policy owned by ${ownerProject}`
+                : `Check resolved Habitat applications owned by ${ownerProject}`,
+        },
+    };
+}
+function ownerInputs(targets, runtimeInputs) {
+    const runtimeStrings = new Set(runtimeInputs.filter((input) => typeof input === "string"));
+    const corpusInputs = new Set();
+    for (const target of Object.values(targets)) {
+        for (const input of target.inputs ?? []) {
+            if (typeof input === "string" && !runtimeStrings.has(input))
+                corpusInputs.add(input);
+        }
+    }
+    return [...runtimeInputs, ...[...corpusInputs].sort(compareText)];
+}
+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));
+        for (const entry of application.runner.acquisition.entries) {
+            addSubjectInputs(files, entry.path, entry.kind);
+        }
+    }
+    else {
+        files.add(workspaceInput(application.runner.structure.relativePath));
+        for (const binding of application.runner.rootBindings) {
+            if (binding.path !== undefined)
+                addSubjectInputs(files, binding.path, binding.kind);
+        }
+    }
+    return [...runtimeInputs, ...[...files].sort()];
+}
+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));
+    for (const pattern of rule.coveragePatterns)
+        files.add(workspaceInput(pattern));
+    if (rule.runner.name === "grit") {
+        files.add(workspaceInput(rule.runner.pattern.relativePath));
+        for (const entry of rule.runner.acquisition.entries) {
+            addSubjectInputs(files, entry.path, entry.kind);
+        }
+    }
+    else {
+        files.add(workspaceInput(rule.runner.structure.relativePath));
+    }
+    return [...runtimeInputs, ...[...files].sort(compareText)];
+}
+function addSubjectInputs(target, path, kind) {
+    const exact = workspaceInput(path);
+    if (kind === "directory" && path === ".") {
+        target.add("{workspaceRoot}/**/*");
+        return;
+    }
+    target.add(exact);
+    if (kind === "directory")
+        target.add(`${exact}/**/*`);
+}
+function workspaceInput(path) {
+    const normalized = normalizeWorkspacePath(path);
+    return normalized === "." ? "{workspaceRoot}" : `{workspaceRoot}/${normalized}`;
+}
+function projectRootFor(manifestPath) {
+    const root = posix.dirname(manifestPath);
+    return root === "" ? "." : root;
+}
+function normalizeWorkspacePath(path) {
+    const slashPath = path.replaceAll("\\", "/");
+    if (posix.isAbsolute(slashPath) || /^[A-Za-z]:\//.test(slashPath)) {
+        throw new Error(`Habitat Nx projection requires a workspace-relative path: '${path}'.`);
+    }
+    const normalized = posix.normalize(slashPath).replace(/^\.\//, "");
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`Habitat Nx projection path escapes the workspace: '${path}'.`);
+    }
+    return normalized === "" ? "." : normalized;
+}
+function rejectedCatalogError(result) {
+    return new Error(`Habitat catalog resolution rejected during Nx projection: ${JSON.stringify(result.issues)}`);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/nx-generators.d.ts

@@ -0,0 +1,31 @@
+/** Exact app-owned identities projected by the public Habitat Nx generators. */
+export declare const habitatConsumerBinding: {
+    readonly gritPackage: "@getgrit/cli";
+    readonly nxPlugin: "@habitat-ai/cli/nx-plugin";
+    readonly predecessorNxPlugins: readonly [{
+        readonly plugin: "@habitat/cli/nx-plugin";
+        readonly options: {
+            readonly checkTargetName: "check:policy";
+        };
+    }];
+    readonly hook: {
+        readonly _habitat: {
+            readonly identity: "@habitat-ai/cli:agent-stop";
+            readonly revision: 1;
+        };
+        readonly hooks: [{
+            readonly type: "command";
+            readonly command: "bash -lc 'repo=\"${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}\"; if [ -n \"$repo\" ]; then repo=\"$(git -C \"$repo\" rev-parse --show-toplevel 2>/dev/null)\"; else repo=\"$(git rev-parse --show-toplevel 2>/dev/null)\"; fi && cd \"$repo\" 2>/dev/null || { printf \"%s\\n\" \"Habitat agent-stop hook must run inside the repository worktree.\" >&2; exit 2; }; bunx --bun --no-install --package @habitat-ai/cli habitat hook agent-stop'";
+            readonly timeout: 120;
+            readonly statusMessage: "Checking Habitat structure laws";
+        }];
+    };
+    readonly predecessorHooks: readonly [{
+        readonly hooks: [{
+            readonly type: "command";
+            readonly command: "bash -lc 'repo=\"${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}\"; if [ -n \"$repo\" ]; then repo=\"$(git -C \"$repo\" rev-parse --show-toplevel 2>/dev/null)\"; else repo=\"$(git rev-parse --show-toplevel 2>/dev/null)\"; fi && cd \"$repo\" 2>/dev/null || { printf \"%s\\n\" \"Habitat agent-stop hook must run inside the repository worktree.\" >&2; exit 2; }; bun habitat hook agent-stop'";
+            readonly timeout: 120;
+            readonly statusMessage: "Checking Habitat structure laws";
+        }];
+    }];
+};

package/dist/nx-generators.js

@@ -0,0 +1,34 @@
+/** Exact app-owned identities projected by the public Habitat Nx generators. */
+export const habitatConsumerBinding = {
+    gritPackage: "@getgrit/cli",
+    nxPlugin: "@habitat-ai/cli/nx-plugin",
+    predecessorNxPlugins: [
+        {
+            plugin: "@habitat/cli/nx-plugin",
+            options: { checkTargetName: "check:policy" },
+        },
+    ],
+    hook: {
+        _habitat: { identity: "@habitat-ai/cli:agent-stop", revision: 1 },
+        hooks: [
+            {
+                type: "command",
+                command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bunx --bun --no-install --package @habitat-ai/cli habitat hook agent-stop\'',
+                timeout: 120,
+                statusMessage: "Checking Habitat structure laws",
+            },
+        ],
+    },
+    predecessorHooks: [
+        {
+            hooks: [
+                {
+                    type: "command",
+                    command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bun habitat hook agent-stop\'',
+                    timeout: 120,
+                    statusMessage: "Checking Habitat structure laws",
+                },
+            ],
+        },
+    ],
+};

package/dist/nx-plugin.d.ts

@@ -0,0 +1,2 @@
+/** Native Nx project inference backed by the public Habitat SDK. */
+export declare const createNodes: import("@nx/devkit").CreateNodes<undefined>;