@hi-man/himan 0.1.0 → 0.2.2

package/dist/cli/resource-commands.js

@@ -0,0 +1,104 @@
+import { HimanError, errorCodes } from "../utils/errors.js";
+import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { runAction } from "./shared.js";
+export function registerResourceCommands(command, services) {
+    command
+        .command("list")
+        .argument("[type]", "resource type", "rule")
+        .option("--agent <list>", "agent list filter, comma separated")
+        .option("--json", "output json format")
+        .description("List resources from current default source")
+        .action(async (type, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const resources = await services.list(resourceType, parseAgents(options.agent));
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(resources, null, 2)}\n`);
+                return;
+            }
+            if (resources.length === 0) {
+                process.stdout.write("No resources found.\n");
+                return;
+            }
+            for (const resource of resources) {
+                process.stdout.write(`- ${resource.type}/${resource.name}${resource.description ? `: ${resource.description}` : ""}\n`);
+            }
+        });
+    });
+    command
+        .command("history")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .option("--json", "output json format")
+        .description("Show resource history")
+        .action(async (type, name, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const versions = await services.history(resourceType, name);
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(versions, null, 2)}\n`);
+                return;
+            }
+            if (versions.length === 0) {
+                process.stdout.write(`No history found for ${resourceType}/${name}.\n`);
+                return;
+            }
+            for (const version of versions) {
+                process.stdout.write(`- ${version.raw}\n`);
+            }
+        });
+    });
+    command
+        .command("create")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .option("--description <text>", "resource description")
+        .option("--agent <list>", "agent list, comma separated")
+        .option("--entry <file>", "entry file name")
+        .option("--template <name>", "template name", "basic")
+        .option("--force", "overwrite existing resource")
+        .option("--dry-run", "show files without writing")
+        .option("--json", "output json format")
+        .description("Create resource scaffold")
+        .action(async (type, name, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.create(resourceType, name, {
+                description: options.description,
+                agents: parseAgents(options.agent),
+                entry: options.entry,
+                template: options.template,
+                force: options.force,
+                dryRun: options.dryRun,
+            }, process.cwd());
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Created ${result.type}/${result.name} at ${result.resourceDir}${result.dryRun ? " (dry-run)" : ""}\n`);
+        });
+    });
+}
+function ensureResourceType(type) {
+    if (type !== "rule" && type !== "command" && type !== "skill") {
+        throw new HimanError(errorCodes.UNSUPPORTED_RESOURCE_TYPE, `Unsupported resource type: ${type}`);
+    }
+    return type;
+}
+function parseAgents(input) {
+    if (!input)
+        return undefined;
+    const agents = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (agents.length === 0)
+        return undefined;
+    const supported = getSupportedAgentNames();
+    for (const agent of agents) {
+        if (!normalizeAgent(agent)) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Unsupported agent: ${agent}. Supported agents: ${supported.join(", ")}`);
+        }
+    }
+    return agents;
+}

package/dist/cli/shared.js

@@ -0,0 +1,69 @@
+import { Command, CommanderError } from "commander";
+import { errorCodes, HimanError } from "../utils/errors.js";
+import { PACKAGE_VERSION } from "../utils/version.js";
+export function createBaseProgram(name, description) {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({
+        writeOut: (str) => {
+            process.stdout.write(str);
+        },
+        writeErr: () => {
+            // Parse/usage errors are unified by writeCliError().
+        },
+    });
+    program.name(name).description(description).version(PACKAGE_VERSION);
+    return program;
+}
+export async function runAction(action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        writeCliError(error);
+        process.exitCode = 1;
+    }
+}
+export function writeCliError(error) {
+    const payload = toCliErrorPayload(error);
+    if (shouldOutputJsonError()) {
+        process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        return;
+    }
+    process.stderr.write(`[${payload.error.code}] ${payload.error.message}\n`);
+}
+function toCliErrorPayload(error) {
+    if (error instanceof CommanderError) {
+        return {
+            ok: false,
+            error: {
+                code: errorCodes.CLI_USAGE,
+                message: error.message,
+                details: {
+                    commanderCode: error.code,
+                    exitCode: error.exitCode,
+                },
+            },
+        };
+    }
+    if (error instanceof HimanError) {
+        return {
+            ok: false,
+            error: {
+                code: error.code,
+                message: error.message,
+                details: error.details,
+            },
+        };
+    }
+    return {
+        ok: false,
+        error: {
+            code: "E_UNKNOWN",
+            message: error instanceof Error ? error.message : String(error),
+        },
+    };
+}
+function shouldOutputJsonError() {
+    return process.argv.includes("--json");
+}

package/dist/cli/source-commands.js

@@ -0,0 +1,58 @@
+import { runAction } from "./shared.js";
+export function registerInitCommand(command, services) {
+    command
+        .command("init")
+        .argument("<git_repo>", "Git repository URL")
+        .action(async (gitRepo) => {
+        await runAction(async () => {
+            const result = await services.initSource("git", gitRepo);
+            process.stdout.write(`Initialized ${result.sourceType} source: ${result.repo}\n`);
+        });
+    });
+}
+export function registerSourceCommands(command, services, options) {
+    if (options?.includeInit) {
+        registerInitCommand(command, services);
+    }
+    command
+        .command("add")
+        .argument("<name>", "source name (kebab-case)")
+        .argument("<git_repo>", "Git repository URL")
+        .description("Add a named git source")
+        .action(async (name, gitRepo) => {
+        await runAction(async () => {
+            const result = await services.addSource(name, "git", gitRepo);
+            process.stdout.write(`Added source ${result.name}: ${result.type}${result.repo ? ` ${result.repo}` : ""}\n`);
+        });
+    });
+    command
+        .command("use")
+        .argument("<name>", "source name")
+        .description("Switch default source")
+        .action(async (name) => {
+        await runAction(async () => {
+            const result = await services.useSource(name);
+            process.stdout.write(`Using source: ${result.name}\n`);
+        });
+    });
+    command
+        .command("list")
+        .option("--json", "output json format")
+        .description("List configured sources and current default")
+        .action(async (options) => {
+        await runAction(async () => {
+            const sources = await services.listSources();
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(sources, null, 2)}\n`);
+                return;
+            }
+            if (sources.length === 0) {
+                process.stdout.write("No sources configured.\n");
+                return;
+            }
+            for (const source of sources) {
+                process.stdout.write(`- ${source.name}${source.isDefault ? " (default)" : ""}: ${source.type}${source.repo ? ` ${source.repo}` : ""}\n`);
+            }
+        });
+    });
+}