@hi-man/himan 0.4.0 → 0.5.0

package/dist/cli/resource-commands.js

@@ -10,18 +10,30 @@ export function registerResourceCommands(command, services) {
         .option("--agent <list>", "agent list filter, comma separated")
         .option("--brief", "hide resource descriptions")
         .option("--installed", "list resources installed in current project")
+        .option("--archived", "list archived resources only")
+        .option("--include-archived", "include archived resources in source list")
         .option("--json", "output json format")
         .description("List resources from current default source or project installs")
         .action(async (type, options) => {
         await runAction(async () => {
             const agents = parseAgents(options.agent);
             const showDescription = !options.brief;
+            if (options.installed && (options.archived || options.includeArchived)) {
+                throw new HimanError(errorCodes.CLI_USAGE, "--archived and --include-archived only apply to source resource lists.");
+            }
+            if (options.archived && options.includeArchived) {
+                throw new HimanError(errorCodes.CLI_USAGE, "Use only one of --archived or --include-archived.");
+            }
+            const listOptions = {
+                archived: Boolean(options.archived),
+                includeArchived: Boolean(options.includeArchived),
+            };
             if (options.installed) {
                 await writeInstalledList(services, type, agents, Boolean(options.json));
                 return;
             }
             if (!type) {
-                const groups = await listGroupedResources(services, agents);
+                const groups = await listGroupedResources(services, agents, listOptions);
                 if (options.json) {
                     process.stdout.write(`${JSON.stringify(formatResourceGroups(groups, showDescription), null, 2)}\n`);
                     return;
@@ -30,7 +42,7 @@ export function registerResourceCommands(command, services) {
                 return;
             }
             const resourceType = ensureResourceType(type);
-            const resources = await services.list(resourceType, agents);
+            const resources = await services.list(resourceType, agents, listOptions);
             if (options.json) {
                 process.stdout.write(`${JSON.stringify(formatResources(resources, showDescription), null, 2)}\n`);
                 return;
@@ -91,6 +103,48 @@ export function registerResourceCommands(command, services) {
             process.stdout.write(`Created ${result.type}/${result.name} at ${result.resourceDir}${result.dryRun ? " (dry-run)" : ""}\n`);
         });
     });
+    command
+        .command("archive")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .option("--reason <text>", "archive reason")
+        .option("--dry-run", "show archive result without writing")
+        .option("--json", "output json format")
+        .description("Archive resource in current default source")
+        .action(async (type, name, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.archive(resourceType, name, {
+                reason: options.reason,
+                dryRun: options.dryRun,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Archived ${result.type}/${result.name}${result.dryRun ? " (dry-run)" : ""}\n`);
+        });
+    });
+    command
+        .command("restore")
+        .argument("<type>", "resource type")
+        .argument("<name>", "resource name")
+        .option("--dry-run", "show restore result without writing")
+        .option("--json", "output json format")
+        .description("Restore archived resource into current default source")
+        .action(async (type, name, options) => {
+        await runAction(async () => {
+            const resourceType = ensureResourceType(type);
+            const result = await services.restore(resourceType, name, {
+                dryRun: options.dryRun,
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Restored ${result.type}/${result.name}${result.dryRun ? " (dry-run)" : ""}\n`);
+        });
+    });
     command
         .command("rename")
         .argument("<type>", "resource type")
@@ -139,11 +193,11 @@ function ensureResourceType(type) {
     }
     return type;
 }
-async function listGroupedResources(services, agents) {
+async function listGroupedResources(services, agents, options = {}) {
     return {
-        rule: await services.list("rule", agents),
-        command: await services.list("command", agents),
-        skill: await services.list("skill", agents),
+        rule: await services.list("rule", agents, options),
+        command: await services.list("command", agents, options),
+        skill: await services.list("skill", agents, options),
     };
 }
 function formatResourceGroups(groups, showDescription) {
@@ -181,7 +235,8 @@ function writeResourceList(resources, showDescription) {
         return;
     }
     for (const resource of resources) {
-        process.stdout.write(`- ${resource.type}/${resource.name}${showDescription && resource.description ? `: ${resource.description}` : ""}\n`);
+        const archived = resource.archived ? " [archived]" : "";
+        process.stdout.write(`- ${resource.type}/${resource.name}${archived}${showDescription && resource.description ? `: ${resource.description}` : ""}\n`);
     }
 }
 function formatGroupTitle(type) {

package/dist/cli/source-commands.js

@@ -1,12 +1,41 @@
+import { getSupportedAgentNames, normalizeAgent } from "../utils/agent-configs.js";
+import { HimanError, errorCodes } from "../utils/errors.js";
 import { runAction } from "./shared.js";
 export function registerInitCommand(command, services) {
     command
         .command("init")
         .argument("<git_repo>", "Git repository URL")
-        .action(async (gitRepo) => {
+        .option("--agent <list>", "set current project default agents, comma separated")
+        .option("--install <refs>", "install resource refs after init, comma separated: rule/name[@version]")
+        .option("--mode <mode>", "install mode for --install: link or copy")
+        .option("--json", "output json format")
+        .action(async (gitRepo, options) => {
         await runAction(async () => {
-            const result = await services.initSource("git", gitRepo);
-            process.stdout.write(`Initialized ${result.sourceType} source: ${result.repo}\n`);
+            const agents = parseAgents(options.agent);
+            const installRefs = parseInstallRefs(options.install);
+            const mode = parseInstallMode(options.mode);
+            if (mode && installRefs.length === 0) {
+                throw new HimanError(errorCodes.CLI_USAGE, "Use --mode only with --install.");
+            }
+            const source = await services.initSource("git", gitRepo);
+            const agentResult = agents?.length
+                ? await services.setAgents(agents, "project", process.cwd())
+                : undefined;
+            const installed = [];
+            for (const ref of installRefs) {
+                installed.push(await services.install(ref.type, ref.name, ref.version, process.cwd(), agents, mode));
+            }
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ source, agents: agentResult, installed }, null, 2)}\n`);
+                return;
+            }
+            process.stdout.write(`Initialized ${source.sourceType} source: ${source.repo}\n`);
+            if (agentResult) {
+                process.stdout.write(`Using agents (${agentResult.scope}): ${agentResult.agents.join(", ")}\n`);
+            }
+            for (const item of installed) {
+                process.stdout.write(`Installed ${item.type}/${item.name}@${item.version}\n`);
+            }
         });
     });
 }
@@ -158,3 +187,67 @@ export function registerSourceCommands(command, services, options) {
         });
     });
 }
+function ensureResourceType(type) {
+    if (type !== "rule" && type !== "command" && type !== "skill") {
+        throw new HimanError(errorCodes.UNSUPPORTED_RESOURCE_TYPE, `Unsupported resource type: ${type}`);
+    }
+    return type;
+}
+function parseInstallRefs(input) {
+    if (!input)
+        return [];
+    const refs = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (refs.length === 0) {
+        throw new HimanError(errorCodes.INVALID_INPUT, "Install list cannot be empty.");
+    }
+    return refs.map((ref) => {
+        const parts = ref.split("/");
+        if (parts.length !== 2 || !parts[0] || !parts[1]) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Invalid install ref: ${ref}. Use type/name[@version].`);
+        }
+        const { name, version } = parseNameVersion(parts[1]);
+        if (!name) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Invalid install ref: ${ref}. Use type/name[@version].`);
+        }
+        return {
+            type: ensureResourceType(parts[0]),
+            name,
+            version,
+        };
+    });
+}
+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 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;
+}

package/dist/domain/doctor.js

@@ -0,0 +1 @@
+export {};