hirmos 1.3.0

package/README.md

@@ -0,0 +1,107 @@
+# HIRMOS CLI
+
+Product-facing HIRMOS CLI.
+
+Implemented command:
+
+```bash
+hirmos init [project-path] [--integration <ids>] [--source <path>]
+```
+
+The CLI makes an installed HIRMOS project discoverable to selected agent-native tools by generating thin bootstrap integration files from `_hirmos/integrations/agent-tools/`.
+
+It does not invoke agents, run HIRMOS workflows, install extensions, download remote packages, or generate slash-command packs.
+
+## Usage
+
+From a project that already contains `_hirmos/`:
+
+```bash
+hirmos init
+```
+
+This defaults to:
+
+```text
+project-path = .
+integration = agents
+source = existing _hirmos/ in the project
+```
+
+Generate specific integrations:
+
+```bash
+hirmos init --integration claude,cursor,copilot
+```
+
+Initialize another project path:
+
+```bash
+hirmos init /path/to/project --integration agents,claude
+```
+
+Install `_hirmos/` from a local source folder or release zip when the target project does not already contain `_hirmos/`:
+
+```bash
+hirmos init /path/to/project --source /path/to/hirmos-framework.zip --integration agents
+```
+
+## Supported integrations
+
+```text
+agents
+claude
+cursor
+copilot
+codex
+opencode
+gemini
+windsurf
+kiro
+```
+
+Some integrations share the same target file. For example, `agents`, `codex`, and `opencode` all use `AGENTS.md` as the safe generic bootstrap target.
+
+## Managed-block behavior
+
+For existing files, the CLI updates only the HIRMOS managed block:
+
+```md
+<!-- HIRMOS:START -->
+...
+<!-- HIRMOS:END -->
+```
+
+If the file exists and has no HIRMOS block, the CLI appends one. User-owned content outside the block is preserved.
+
+## Project config behavior
+
+The CLI merges selected integration IDs into:
+
+```text
+_hirmos/project.json
+```
+
+under:
+
+```json
+{
+  "integrations": {
+    "installed": []
+  }
+}
+```
+
+Re-running `hirmos init --integration ...` is additive and does not remove previously recorded integrations.
+
+## Workflow commands are not CLI commands
+
+These are HIRMOS workflow commands to use inside the AI tool after HIRMOS Core has loaded:
+
+```text
+hirmos requirements
+hirmos system-design
+hirmos implementation
+```
+
+The CLI currently implements only `hirmos init`.

package/dist/commands/init.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const filesystem_1 = require("../lib/filesystem");
+const integration_registry_1 = require("../lib/integration-registry");
+const managed_blocks_1 = require("../lib/managed-blocks");
+const project_config_1 = require("../lib/project-config");
+const source_install_1 = require("../lib/source-install");
+const validation_1 = require("../lib/validation");
+function runInit(options) {
+    const projectRoot = path_1.default.resolve(options.projectPath);
+    (0, validation_1.validateProjectRoot)(projectRoot);
+    (0, source_install_1.ensureHirmosInstalled)(projectRoot, options.source);
+    (0, validation_1.validateHirmosFramework)(projectRoot);
+    const hirmosDir = path_1.default.join(projectRoot, "_hirmos");
+    const registry = (0, integration_registry_1.loadRegistry)(hirmosDir);
+    const selected = (0, integration_registry_1.normalizeSelectedIntegrations)(options.integrations, registry);
+    const plannedTargets = (0, integration_registry_1.planTargetUpdates)(projectRoot, hirmosDir, selected, registry);
+    const currentConfig = (0, project_config_1.loadProjectConfig)(projectRoot);
+    const mergeResult = (0, project_config_1.mergeProjectConfig)(currentConfig, selected, registry);
+    const renderedWrites = plannedTargets.map((target) => {
+        (0, filesystem_1.assertInsideProject)(projectRoot, target.targetPath);
+        const existing = fs_1.default.existsSync(target.targetPath) ? (0, filesystem_1.readText)(target.targetPath) : null;
+        const nextContent = (0, managed_blocks_1.updateManagedBlock)(existing, target.templateContent, registry.managed_block, target.target);
+        return {
+            path: target.targetPath,
+            relative: target.target,
+            content: nextContent,
+            integrationIds: target.integrationIds
+        };
+    });
+    for (const write of renderedWrites) {
+        (0, filesystem_1.writeText)(write.path, write.content);
+    }
+    (0, project_config_1.writeProjectConfig)(projectRoot, mergeResult.config);
+    return formatInitSummary(mergeResult.wasFirstInitialization, selected, mergeResult.added, mergeResult.alreadyInstalled, renderedWrites.map((item) => item.relative));
+}
+function formatInitSummary(first, selected, added, alreadyInstalled, targets) {
+    const lines = [];
+    if (first) {
+        lines.push("HIRMOS initialized.", "");
+        lines.push("Installed integrations:");
+        for (const id of selected)
+            lines.push(`- ${id}`);
+        lines.push("", "Generated or updated files:");
+        for (const target of targets)
+            lines.push(`- ${target}`);
+        lines.push("", "Next step:");
+        lines.push("Open your AI coding tool and ask it to read and follow _hirmos/HIRMOS_CORE.md.");
+        lines.push("", "To add more integrations later:");
+        lines.push("hirmos init --integration claude,cursor,copilot");
+        return `${lines.join("\n")}\n`;
+    }
+    lines.push("HIRMOS integrations updated.", "");
+    if (added.length > 0) {
+        lines.push("Added:");
+        for (const id of added)
+            lines.push(`- ${id}`);
+        lines.push("");
+    }
+    if (alreadyInstalled.length > 0) {
+        lines.push("Already installed:");
+        for (const id of alreadyInstalled)
+            lines.push(`- ${id}`);
+        lines.push("");
+    }
+    lines.push("Generated or updated files:");
+    for (const target of targets)
+        lines.push(`- ${target}`);
+    return `${lines.join("\n").replace(/\n+$/u, "")}\n`;
+}

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./lib/args");
+const errors_1 = require("./lib/errors");
+const init_1 = require("./commands/init");
+function main() {
+    try {
+        const parsed = (0, args_1.parseArgs)(process.argv.slice(2));
+        if (parsed.command === "help") {
+            process.stdout.write((0, args_1.helpText)());
+            return;
+        }
+        if (parsed.command === "init") {
+            const summary = (0, init_1.runInit)({
+                projectPath: parsed.projectPath,
+                integrations: parsed.integrations,
+                source: parsed.source
+            });
+            process.stdout.write(summary);
+            return;
+        }
+    }
+    catch (error) {
+        if (error instanceof errors_1.HirmosCliError) {
+            process.stderr.write(`ERROR: ${error.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        process.stderr.write(`ERROR: ${error?.message ?? String(error)}\n`);
+        process.exitCode = 1;
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/lib/args.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.parseIntegrationList = parseIntegrationList;
+exports.helpText = helpText;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+        return { command: "help" };
+    }
+    const command = argv[0];
+    if (command !== "init") {
+        (0, errors_1.fail)(`Unsupported command: ${command}. DP-3B implements only: hirmos init`);
+    }
+    let projectPath = ".";
+    let projectPathSet = false;
+    let integrationValue;
+    let source;
+    for (let i = 1; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--integration") {
+            const value = argv[++i];
+            if (!value)
+                (0, errors_1.fail)("Missing value for --integration");
+            integrationValue = value;
+            continue;
+        }
+        if (arg.startsWith("--integration=")) {
+            integrationValue = arg.slice("--integration=".length);
+            continue;
+        }
+        if (arg === "--source") {
+            const value = argv[++i];
+            if (!value)
+                (0, errors_1.fail)("Missing value for --source");
+            source = value;
+            continue;
+        }
+        if (arg.startsWith("--source=")) {
+            source = arg.slice("--source=".length);
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return { command: "help" };
+        }
+        if (arg.startsWith("-")) {
+            (0, errors_1.fail)(`Unsupported option: ${arg}`);
+        }
+        if (projectPathSet) {
+            (0, errors_1.fail)(`Unexpected extra positional argument: ${arg}`);
+        }
+        projectPath = arg;
+        projectPathSet = true;
+    }
+    const integrations = parseIntegrationList(integrationValue ?? "agents");
+    return {
+        command: "init",
+        projectPath: path_1.default.resolve(projectPath),
+        integrations,
+        source: source ? path_1.default.resolve(source) : undefined
+    };
+}
+function parseIntegrationList(value) {
+    const ids = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (ids.length === 0) {
+        (0, errors_1.fail)("--integration must include at least one integration id");
+    }
+    return ids;
+}
+function helpText() {
+    return `HIRMOS CLI\n\nUsage:\n  hirmos init [project-path] [--integration <ids>] [--source <path>]\n\nDefaults:\n  project-path: .\n  integration: agents\n  source: existing _hirmos/ in the project\n\nDP-3B implements only hirmos init. Workflow commands such as hirmos requirements are interpreted by an agent after HIRMOS Core is loaded.\n`;
+}

package/dist/lib/errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HirmosCliError = void 0;
+exports.fail = fail;
+class HirmosCliError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HirmosCliError";
+    }
+}
+exports.HirmosCliError = HirmosCliError;
+function fail(message) {
+    throw new HirmosCliError(message);
+}

package/dist/lib/filesystem.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.readText = readText;
+exports.writeText = writeText;
+exports.readJson = readJson;
+exports.writeJson = writeJson;
+exports.assertInsideProject = assertInsideProject;
+exports.pathExists = pathExists;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+function ensureDir(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function readText(filePath) {
+    return fs_1.default.readFileSync(filePath, "utf8");
+}
+function writeText(filePath, content) {
+    ensureDir(path_1.default.dirname(filePath));
+    fs_1.default.writeFileSync(filePath, content, "utf8");
+}
+function readJson(filePath, label) {
+    try {
+        return JSON.parse(readText(filePath));
+    }
+    catch (error) {
+        (0, errors_1.fail)(`Invalid ${label} JSON at ${filePath}: ${error.message}`);
+    }
+}
+function writeJson(filePath, value) {
+    writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function assertInsideProject(projectRoot, targetPath) {
+    const relative = path_1.default.relative(projectRoot, targetPath);
+    if (relative.startsWith("..") || path_1.default.isAbsolute(relative)) {
+        (0, errors_1.fail)(`Refusing to write outside the project root: ${targetPath}`);
+    }
+}
+function pathExists(filePath) {
+    return fs_1.default.existsSync(filePath);
+}

package/dist/lib/integration-registry.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRegistry = loadRegistry;
+exports.registryOrder = registryOrder;
+exports.normalizeSelectedIntegrations = normalizeSelectedIntegrations;
+exports.planTargetUpdates = planTargetUpdates;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+const filesystem_1 = require("./filesystem");
+const managed_blocks_1 = require("./managed-blocks");
+function loadRegistry(hirmosDir) {
+    const registryPath = path_1.default.join(hirmosDir, "integrations/agent-tools", "registry.json");
+    const registry = (0, filesystem_1.readJson)(registryPath, "agent integration registry");
+    if (!registry || typeof registry !== "object")
+        (0, errors_1.fail)("Agent integration registry is malformed.");
+    if (registry.schema_version !== 1)
+        (0, errors_1.fail)(`Unsupported agent integration registry schema_version: ${registry.schema_version}`);
+    if (!registry.managed_block?.start || !registry.managed_block?.end)
+        (0, errors_1.fail)("Agent integration registry is missing managed block markers.");
+    if (!registry.integrations || typeof registry.integrations !== "object")
+        (0, errors_1.fail)("Agent integration registry is missing integrations.");
+    return registry;
+}
+function registryOrder(registry) {
+    return Object.keys(registry.integrations);
+}
+function normalizeSelectedIntegrations(selected, registry) {
+    const selectedSet = new Set();
+    for (const id of selected) {
+        if (!registry.integrations[id]) {
+            (0, errors_1.fail)(`Unknown integration id: ${id}. Valid integrations: ${registryOrder(registry).join(", ")}`);
+        }
+        selectedSet.add(id);
+    }
+    return registryOrder(registry).filter((id) => selectedSet.has(id));
+}
+function planTargetUpdates(projectRoot, hirmosDir, selected, registry) {
+    const grouped = new Map();
+    for (const id of selected) {
+        const integration = registry.integrations[id];
+        if (integration.mode !== "managed_block")
+            (0, errors_1.fail)(`Unsupported integration mode for ${id}: ${integration.mode}`);
+        const templatePath = path_1.default.join(hirmosDir, "integrations/agent-tools", integration.template);
+        const templateContent = (0, filesystem_1.readText)(templatePath);
+        (0, managed_blocks_1.validateTemplateManagedBlock)(templateContent, registry.managed_block, integration.template);
+        const existing = grouped.get(integration.target);
+        if (existing) {
+            if (existing.templateContent !== templateContent) {
+                (0, errors_1.fail)(`Integrations sharing target ${integration.target} use different templates. Refusing ambiguous update.`);
+            }
+            existing.integrationIds.push(id);
+            continue;
+        }
+        grouped.set(integration.target, {
+            target: integration.target,
+            targetPath: path_1.default.resolve(projectRoot, integration.target),
+            templatePath,
+            templateContent,
+            integrationIds: [id]
+        });
+    }
+    return Array.from(grouped.values());
+}

package/dist/lib/managed-blocks.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTemplateManagedBlock = validateTemplateManagedBlock;
+exports.updateManagedBlock = updateManagedBlock;
+const errors_1 = require("./errors");
+function countOccurrences(content, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let index = 0;
+    while (true) {
+        const found = content.indexOf(needle, index);
+        if (found === -1)
+            return count;
+        count += 1;
+        index = found + needle.length;
+    }
+}
+function validateTemplateManagedBlock(template, markers, label) {
+    const starts = countOccurrences(template, markers.start);
+    const ends = countOccurrences(template, markers.end);
+    if (starts !== 1 || ends !== 1) {
+        (0, errors_1.fail)(`Template ${label} must contain exactly one complete HIRMOS managed block.`);
+    }
+    if (template.indexOf(markers.start) > template.indexOf(markers.end)) {
+        (0, errors_1.fail)(`Template ${label} has malformed HIRMOS managed block markers.`);
+    }
+}
+function updateManagedBlock(existing, renderedTemplate, markers, targetLabel) {
+    validateTemplateManagedBlock(renderedTemplate, markers, targetLabel);
+    if (existing === null) {
+        return ensureTrailingNewline(renderedTemplate);
+    }
+    const starts = countOccurrences(existing, markers.start);
+    const ends = countOccurrences(existing, markers.end);
+    if (starts !== ends) {
+        (0, errors_1.fail)(`Target ${targetLabel} has malformed HIRMOS managed block markers.`);
+    }
+    if (starts > 1) {
+        (0, errors_1.fail)(`Target ${targetLabel} contains multiple HIRMOS managed blocks. Refusing to modify it.`);
+    }
+    if (starts === 1) {
+        const startIndex = existing.indexOf(markers.start);
+        const endIndex = existing.indexOf(markers.end, startIndex);
+        if (endIndex === -1 || startIndex > endIndex) {
+            (0, errors_1.fail)(`Target ${targetLabel} has malformed HIRMOS managed block markers.`);
+        }
+        const afterEnd = endIndex + markers.end.length;
+        return ensureTrailingNewline(`${existing.slice(0, startIndex)}${trimTrailingNewline(renderedTemplate)}${existing.slice(afterEnd)}`);
+    }
+    const separator = existing.trim().length === 0 ? "" : "\n\n";
+    return ensureTrailingNewline(`${trimTrailingNewline(existing)}${separator}${trimTrailingNewline(renderedTemplate)}`);
+}
+function trimTrailingNewline(content) {
+    return content.replace(/\n+$/u, "");
+}
+function ensureTrailingNewline(content) {
+    return `${trimTrailingNewline(content)}\n`;
+}

package/dist/lib/project-config.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProjectConfig = loadProjectConfig;
+exports.mergeProjectConfig = mergeProjectConfig;
+exports.writeProjectConfig = writeProjectConfig;
+const path_1 = __importDefault(require("path"));
+const filesystem_1 = require("./filesystem");
+const integration_registry_1 = require("./integration-registry");
+function loadProjectConfig(projectRoot) {
+    return (0, filesystem_1.readJson)(path_1.default.join(projectRoot, "_hirmos", "project.json"), "_hirmos/project.json");
+}
+function mergeProjectConfig(config, selected, registry) {
+    const previousInstalled = Array.isArray(config.integrations?.installed)
+        ? config.integrations.installed.filter((id) => typeof id === "string")
+        : [];
+    const previousSet = new Set(previousInstalled);
+    const selectedSet = new Set(selected);
+    const added = selected.filter((id) => !previousSet.has(id));
+    const alreadyInstalled = selected.filter((id) => previousSet.has(id));
+    const knownOrder = (0, integration_registry_1.registryOrder)(registry);
+    const allKnown = knownOrder.filter((id) => previousSet.has(id) || selectedSet.has(id));
+    const unknownExisting = previousInstalled.filter((id) => !registry.integrations[id]);
+    const installed = [...allKnown, ...unknownExisting];
+    const nextConfig = {
+        ...config,
+        integrations: {
+            ...(config.integrations ?? {}),
+            installed
+        }
+    };
+    return {
+        config: nextConfig,
+        previousInstalled,
+        added,
+        alreadyInstalled,
+        installed,
+        wasFirstInitialization: previousInstalled.length === 0
+    };
+}
+function writeProjectConfig(projectRoot, config) {
+    (0, filesystem_1.writeJson)(path_1.default.join(projectRoot, "_hirmos", "project.json"), config);
+}

package/dist/lib/source-install.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureHirmosInstalled = ensureHirmosInstalled;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const errors_1 = require("./errors");
+const filesystem_1 = require("./filesystem");
+function ensureHirmosInstalled(projectRoot, source) {
+    const hirmosDir = path_1.default.join(projectRoot, "_hirmos");
+    if ((0, filesystem_1.pathExists)(hirmosDir)) {
+        return;
+    }
+    if (!source) {
+        (0, errors_1.fail)(`Missing _hirmos/ in ${projectRoot}. Provide --source <path-to-hirmos-framework.zip-or-folder>.`);
+    }
+    if (!(0, filesystem_1.pathExists)(source)) {
+        (0, errors_1.fail)(`Source path does not exist: ${source}`);
+    }
+    const stat = fs_1.default.statSync(source);
+    if (stat.isDirectory()) {
+        installFromDirectory(projectRoot, source);
+        return;
+    }
+    if (stat.isFile() && source.toLowerCase().endsWith(".zip")) {
+        installFromZip(projectRoot, source);
+        return;
+    }
+    (0, errors_1.fail)(`Unsupported --source. Expected a .zip, a folder containing _hirmos, or an _hirmos folder: ${source}`);
+}
+function installFromDirectory(projectRoot, sourceDir) {
+    const sourceHirmos = path_1.default.basename(sourceDir) === "_hirmos" ? sourceDir : path_1.default.join(sourceDir, "_hirmos");
+    if (!(0, filesystem_1.pathExists)(sourceHirmos) || !fs_1.default.statSync(sourceHirmos).isDirectory()) {
+        (0, errors_1.fail)(`Source folder does not contain _hirmos/: ${sourceDir}`);
+    }
+    copyHirmos(projectRoot, sourceHirmos);
+}
+function installFromZip(projectRoot, zipPath) {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "hirmos-cli-"));
+    try {
+        try {
+            extractZip(zipPath, tmp);
+        }
+        catch (error) {
+            (0, errors_1.fail)(`Unable to extract --source zip. Ensure the zip is valid and an extraction command is available: ${error.message}`);
+        }
+        const sourceHirmos = findHirmosDir(tmp);
+        if (!sourceHirmos) {
+            (0, errors_1.fail)(`Source zip does not contain an _hirmos/ folder: ${zipPath}`);
+        }
+        copyHirmos(projectRoot, sourceHirmos);
+    }
+    finally {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+function findHirmosDir(root) {
+    const direct = path_1.default.join(root, "_hirmos");
+    if ((0, filesystem_1.pathExists)(direct) && fs_1.default.statSync(direct).isDirectory())
+        return direct;
+    const entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = path_1.default.join(root, entry.name, "_hirmos");
+        if ((0, filesystem_1.pathExists)(candidate) && fs_1.default.statSync(candidate).isDirectory())
+            return candidate;
+    }
+    return null;
+}
+function copyHirmos(projectRoot, sourceHirmos) {
+    const target = path_1.default.join(projectRoot, "_hirmos");
+    if ((0, filesystem_1.pathExists)(target)) {
+        (0, errors_1.fail)(`Refusing to overwrite existing _hirmos/: ${target}`);
+    }
+    (0, filesystem_1.ensureDir)(projectRoot);
+    fs_1.default.cpSync(sourceHirmos, target, { recursive: true, errorOnExist: true });
+}
+function extractZip(zipPath, destination) {
+    if (process.platform === "win32") {
+        (0, child_process_1.execFileSync)("powershell", ["-NoProfile", "-Command", "Expand-Archive", "-LiteralPath", zipPath, "-DestinationPath", destination, "-Force"], { stdio: "ignore" });
+        return;
+    }
+    (0, child_process_1.execFileSync)("unzip", ["-q", zipPath, "-d", destination], { stdio: "ignore" });
+}

package/dist/lib/validation.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProjectRoot = validateProjectRoot;
+exports.validateHirmosFramework = validateHirmosFramework;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+const filesystem_1 = require("./filesystem");
+function validateProjectRoot(projectRoot) {
+    if (!(0, filesystem_1.pathExists)(projectRoot)) {
+        (0, errors_1.fail)(`Project path does not exist: ${projectRoot}`);
+    }
+    if (!fs_1.default.statSync(projectRoot).isDirectory()) {
+        (0, errors_1.fail)(`Project path is not a directory: ${projectRoot}`);
+    }
+}
+function validateHirmosFramework(projectRoot) {
+    const required = [
+        "_hirmos/HIRMOS_CORE.md",
+        "_hirmos/project.json",
+        "_hirmos/integrations/agent-tools/registry.json"
+    ];
+    for (const relative of required) {
+        const absolute = path_1.default.join(projectRoot, relative);
+        if (!(0, filesystem_1.pathExists)(absolute)) {
+            (0, errors_1.fail)(`Required HIRMOS file is missing: ${relative}`);
+        }
+    }
+    const templatesDir = path_1.default.join(projectRoot, "_hirmos", "integrations/agent-tools", "templates");
+    if (!(0, filesystem_1.pathExists)(templatesDir) || !fs_1.default.statSync(templatesDir).isDirectory()) {
+        (0, errors_1.fail)("Required HIRMOS directory is missing: _hirmos/integrations/agent-tools/templates/");
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "hirmos",
+  "version": "1.3.0",
+  "description": "HIRMOS product-facing CLI.",
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "bin": {
+    "hirmos": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.js",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ]
+}