@hi-man/himan 0.1.0 → 0.2.2

package/dist/cli/agent-commands.js

@@ -0,0 +1,93 @@
+import { HimanError, errorCodes } from "../utils/errors.js";
+import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { runAction } from "./shared.js";
+export function registerAgentCommands(command, services) {
+    command
+        .command("list")
+        .option("--json", "output json format")
+        .description("List supported agents")
+        .action(async (options) => {
+        await runAction(async () => {
+            const agents = getSupportedAgentNames();
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(agents, null, 2)}\n`);
+                return;
+            }
+            for (const agent of agents) {
+                process.stdout.write(`- ${agent}\n`);
+            }
+        });
+    });
+    command
+        .command("use")
+        .argument("<agent_list>", "agent list, comma separated")
+        .option("--global", "save as global default")
+        .option("--project", "save as current project default")
+        .option("--json", "output json format")
+        .description("Set default agents globally or for current project")
+        .action(async (agentList, options) => {
+        await runAction(async () => {
+            const scope = parseScope(options);
+            const result = await services.setAgents(parseAgents(agentList), scope, process.cwd());
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Using agents (${result.scope}): ${result.agents.join(", ")}\n`);
+        });
+    });
+    command
+        .command("current")
+        .option("--json", "output json format")
+        .description("Show configured and effective default agents")
+        .action(async (options) => {
+        await runAction(async () => {
+            const settings = await services.getAgentSettings(process.cwd());
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(settings, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`effective: ${settings.effective.join(", ")}\n`);
+            process.stdout.write(`project: ${(settings.project ?? []).join(", ") || "-"}\n`);
+            process.stdout.write(`global: ${(settings.global ?? []).join(", ") || "-"}\n`);
+        });
+    });
+    command
+        .command("clear")
+        .option("--global", "clear global default agents")
+        .option("--project", "clear current project default agents")
+        .option("--json", "output json format")
+        .description("Clear configured default agents")
+        .action(async (options) => {
+        await runAction(async () => {
+            const result = await services.clearAgents(parseScope(options), process.cwd());
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Cleared agents (${result.scope}).\n`);
+        });
+    });
+}
+function parseScope(options) {
+    if (options.global && options.project) {
+        throw new HimanError(errorCodes.CLI_USAGE, "Use only one of --global or --project.");
+    }
+    return options.global ? "global" : "project";
+}
+function parseAgents(input) {
+    const agents = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (agents.length === 0) {
+        throw new HimanError(errorCodes.INVALID_INPUT, "Agent list cannot be empty.");
+    }
+    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/builders.js

@@ -0,0 +1,72 @@
+import { ServiceFactory } from "../services/index.js";
+import { registerAgentCommands } from "./agent-commands.js";
+import { registerProjectCommands } from "./project-commands.js";
+import { registerResourceCommands } from "./resource-commands.js";
+import { registerInitCommand, registerSourceCommands } from "./source-commands.js";
+import { createBaseProgram } from "./shared.js";
+export function buildCli() {
+    const program = createBaseProgram("himan", "Prompt and agent asset management CLI");
+    const services = new ServiceFactory();
+    appendCommandGroupsHelp(program);
+    registerInitCommand(program, services);
+    const sourceCmd = program.command("source").description("Manage source repositories");
+    registerSourceCommands(sourceCmd, services, { includeInit: true });
+    const resourceCmd = program
+        .command("resource")
+        .description("Manage resources from current default source");
+    registerResourceCommands(resourceCmd, services);
+    const projectCmd = program
+        .command("project")
+        .description("Manage installed resources in current project");
+    registerProjectCommands(projectCmd, services);
+    const agentCmd = program
+        .command("agent")
+        .description("Manage default agent configuration");
+    registerAgentCommands(agentCmd, services);
+    // Backward compatible top-level resource lifecycle commands.
+    registerResourceCommands(program, services);
+    registerProjectCommands(program, services);
+    return program;
+}
+export function buildSourceCli() {
+    const program = createBaseProgram("himan-source", "Source repository management CLI");
+    const services = new ServiceFactory();
+    registerSourceCommands(program, services, { includeInit: true });
+    return program;
+}
+export function buildResourceCli() {
+    const program = createBaseProgram("himan-resource", "Resource lifecycle management CLI");
+    const services = new ServiceFactory();
+    registerResourceCommands(program, services);
+    const agentCmd = program
+        .command("agent")
+        .description("Manage default agent configuration");
+    registerAgentCommands(agentCmd, services);
+    // Backward compatible: keep project lifecycle commands in himan-resource.
+    registerProjectCommands(program, services);
+    return program;
+}
+export function buildProjectCli() {
+    const program = createBaseProgram("himan-project", "Project lifecycle management CLI");
+    const services = new ServiceFactory();
+    const agentCmd = program
+        .command("agent")
+        .description("Manage default agent configuration");
+    registerAgentCommands(agentCmd, services);
+    registerProjectCommands(program, services);
+    return program;
+}
+function appendCommandGroupsHelp(program) {
+    program.addHelpText("after", `
+Command groups:
+  source   Data source management (git now, registry reserved)
+           init, source init, source add, source use, source list
+  resource Source resource discovery and metadata
+           list, history, create, resource list, resource history, resource create
+  project  Resource usage lifecycle in current project
+           install, dev, uninstall, publish,
+           project install, project dev, project uninstall, project publish
+  agent    Default agent configuration
+           agent list, agent use, agent current, agent clear
+`);
+}

package/dist/cli/index.js

@@ -1,318 +1,3 @@
-import { Command, CommanderError } from "commander";
-import { ServiceFactory } from "../services/index.js";
-import { errorCodes, HimanError } from "../utils/errors.js";
-import { PACKAGE_VERSION } from "../version.js";
-export function buildCli() {
-    const program = new Command();
-    const services = new ServiceFactory();
-    program.exitOverride();
-    program.configureOutput({
-        writeOut: (str) => {
-            process.stdout.write(str);
-        },
-        writeErr: () => {
-            // Parse/usage errors are unified by writeCliError().
-        },
-    });
-    program
-        .name("himan")
-        .description("Prompt and agent asset management CLI")
-        .version(PACKAGE_VERSION);
-    appendCommandGroupsHelp(program);
-    program
-        .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`);
-        });
-    });
-    const sourceCmd = program.command("source").description("Manage source repositories");
-    sourceCmd
-        .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`);
-        });
-    });
-    sourceCmd
-        .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`);
-        });
-    });
-    sourceCmd
-        .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`);
-            }
-        });
-    });
-    program
-        .command("list")
-        .argument("[type]", "resource type", "rule")
-        .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);
-            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`);
-            }
-        });
-    });
-    program
-        .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`);
-            }
-        });
-    });
-    program
-        .command("install")
-        .argument("[type]", "resource type")
-        .argument("[name[@version]]", "resource name with optional @version")
-        .description("Install resource, or install from himan.lock")
-        .action(async (type, nameVersion) => {
-        await runAction(async () => {
-            if (!type && !nameVersion) {
-                const results = await services.installFromLock(process.cwd());
-                if (results.length === 0) {
-                    process.stdout.write("No resources in lock file.\n");
-                    return;
-                }
-                for (const item of results) {
-                    process.stdout.write(`Installed ${item.type}/${item.name}@${item.version}\n`);
-                }
-                return;
-            }
-            if (!type || !nameVersion) {
-                throw new Error("Install usage:\n"
-                    + "  - himan install  # install from himan.lock\n"
-                    + "  - himan install <type> <name[@version]>  # install single resource");
-            }
-            const resourceType = ensureResourceType(type);
-            const { name, version } = parseNameVersion(nameVersion);
-            const result = await services.install(resourceType, name, version, process.cwd());
-            process.stdout.write(`Installed ${result.type}/${result.name}@${result.version}\n`);
-        });
-    });
-    program
-        .command("dev")
-        .argument("<type>", "resource type")
-        .argument("<name>", "resource name")
-        .description("Switch resource to development mode")
-        .action(async (type, name) => {
-        await runAction(async () => {
-            const resourceType = ensureResourceType(type);
-            const result = await services.dev(resourceType, name, process.cwd());
-            process.stdout.write(`Switched ${result.type}/${result.name} to dev mode: ${result.devPath}\n`);
-        });
-    });
-    program
-        .command("uninstall")
-        .argument("<type>", "resource type")
-        .argument("<name>", "resource name")
-        .description("Uninstall resource from project and lock")
-        .action(async (type, name) => {
-        await runAction(async () => {
-            const resourceType = ensureResourceType(type);
-            const result = await services.uninstall(resourceType, name, process.cwd());
-            process.stdout.write(`Uninstalled ${result.type}/${result.name}\n`);
-        });
-    });
-    program
-        .command("publish")
-        .argument("<type>", "resource type")
-        .argument("<name>", "resource name")
-        .option("--patch", "patch release")
-        .option("--minor", "minor release")
-        .option("--major", "major release")
-        .description("Publish resource (default: --patch)")
-        .action(async (type, name, options) => {
-        await runAction(async () => {
-            const resourceType = ensureResourceType(type);
-            const releaseType = resolveReleaseType(options);
-            const result = await services.publish(resourceType, name, releaseType, process.cwd());
-            process.stdout.write(`Published ${result.type}/${result.name}@${result.version}\n`);
-        });
-    });
-    program
-        .command("create")
-        .argument("<type>", "resource type")
-        .argument("<name>", "resource name")
-        .option("--description <text>", "resource description")
-        .option("--target <list>", "targets 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 = ensureCreateResourceType(type);
-            const result = await services.create(resourceType, name, {
-                description: options.description,
-                targets: parseTargets(options.target),
-                entry: options.entry,
-                template: options.template,
-                force: options.force,
-                dryRun: options.dryRun,
-            });
-            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`);
-        });
-    });
-    return program;
-}
-function ensureResourceType(type) {
-    if (type !== "rule" && type !== "command" && type !== "skill") {
-        throw new Error(`Unsupported resource type: ${type}`);
-    }
-    return type;
-}
-function parseNameVersion(input) {
-    const idx = input.lastIndexOf("@");
-    if (idx <= 0)
-        return { name: input };
-    return { name: input.slice(0, idx), version: input.slice(idx + 1) };
-}
-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");
-}
-function appendCommandGroupsHelp(program) {
-    program.addHelpText("after", `
-Command groups:
-  source   Data source management (git now, registry reserved)
-           init, source add, source use, source list
-  resource Source resource discovery and metadata
-           list, history, create
-  project  Resource usage lifecycle in current project
-           install, dev, uninstall, publish
-`);
-}
-function resolveReleaseType(options) {
-    const selected = [
-        options.patch ? "patch" : undefined,
-        options.minor ? "minor" : undefined,
-        options.major ? "major" : undefined,
-    ].filter(Boolean);
-    if (selected.length > 1) {
-        throw new Error("Use only one of --patch, --minor or --major.");
-    }
-    return selected[0] ?? "patch";
-}
-function ensureCreateResourceType(type) {
-    if (type !== "rule" && type !== "command" && type !== "skill") {
-        throw new Error(`Unsupported resource type: ${type}`);
-    }
-    return type;
-}
-function parseTargets(input) {
-    if (!input)
-        return undefined;
-    return input
-        .split(",")
-        .map((item) => item.trim())
-        .filter(Boolean);
-}
+export { buildCli, buildProjectCli, buildResourceCli, buildSourceCli } from "./builders.js";
+export { registerAgentCommands } from "./agent-commands.js";
+export { writeCliError } from "./shared.js";

package/dist/cli/project-commands.js

@@ -0,0 +1,127 @@
+import { HimanError, errorCodes } from "../utils/errors.js";
+import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { runAction } from "./shared.js";
+export function registerProjectCommands(command, services) {
+    command
+        .command("install")
+        .argument("[type]", "resource type")
+        .argument("[name[@version]]", "resource name with optional @version")
+        .option("--agent <list>", "install target agents, comma separated")
+        .option("--mode <mode>", "install mode: link or copy")
+        .description("Install resource, or install from himan.lock")
+        .action(async (type, nameVersion, options) => {
+        await runAction(async () => {
+            const agents = parseAgents(options.agent);
+            const mode = parseInstallMode(options.mode);
+            if (!type && !nameVersion) {
+                const results = await services.installFromLock(process.cwd(), agents, mode);
+                if (results.length === 0) {
+                    process.stdout.write("No resources in lock file.\n");
+                    return;
+                }
+                for (const item of results) {
+                    process.stdout.write(`Installed ${item.type}/${item.name}@${item.version}\n`);
+                }
+                return;
+            }
+            if (!type || !nameVersion) {
+                throw new HimanError(errorCodes.CLI_USAGE, "Install usage:\n"
+                    + "  - himan install  # install from himan.lock\n"
+                    + "  - himan install <type> <name[@version]> [--mode link|copy]  # install single resource");
+            }
+            const resourceType = ensureResourceType(type);
+            const { name, version } = parseNameVersion(nameVersion);
+            const result = await services.install(resourceType, name, version, process.cwd(), agents, mode);
+            process.stdout.write(`Installed ${result.type}/${result.name}@${result.version}\n`);
+        });
+    });
+    command
+        .command("dev")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .description("Switch resource to development mode")
+        .action(async (type, name) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.dev(resourceType, name, process.cwd());
+            process.stdout.write(`Switched ${result.type}/${result.name} to dev mode: ${result.devPath}\n`);
+        });
+    });
+    command
+        .command("uninstall")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .description("Uninstall resource from project and lock")
+        .action(async (type, name) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.uninstall(resourceType, name, process.cwd());
+            process.stdout.write(`Uninstalled ${result.type}/${result.name}\n`);
+        });
+    });
+    command
+        .command("publish")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .option("--patch", "patch release")
+        .option("--minor", "minor release")
+        .option("--major", "major release")
+        .description("Publish resource (default: --patch)")
+        .action(async (type, name, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const releaseType = resolveReleaseType(options);
+            const result = await services.publish(resourceType, name, releaseType, process.cwd());
+            process.stdout.write(`Published ${result.type}/${result.name}@${result.version}\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 parseNameVersion(input) {
+    const idx = input.lastIndexOf("@");
+    if (idx <= 0)
+        return { name: input };
+    return { name: input.slice(0, idx), version: input.slice(idx + 1) };
+}
+function resolveReleaseType(options) {
+    const selected = [
+        options.patch ? "patch" : undefined,
+        options.minor ? "minor" : undefined,
+        options.major ? "major" : undefined,
+    ].filter(Boolean);
+    if (selected.length > 1) {
+        throw new HimanError(errorCodes.CLI_USAGE, "Use only one of --patch, --minor or --major.");
+    }
+    return selected[0] ?? "patch";
+}
+function parseInstallMode(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "link" || normalized === "copy") {
+        return normalized;
+    }
+    throw new HimanError(errorCodes.INVALID_INPUT, `Unsupported install mode: ${input}. Supported modes: link, copy`);
+}
+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;
+}