@hi-man/himan 0.1.0 → 0.2.0

package/dist/services/index.js

@@ -1,20 +1,25 @@
 import { GitSourceAdapter } from "../adapters/source/git-source-adapter.js";
 import { RegistrySourceAdapter } from "../adapters/source/registry-source-adapter.js";
 import { StateStore } from "../state/state-store.js";
+import { ProjectConfigStore } from "../state/project-config-store.js";
 import { ProjectLockStore } from "../state/project-lock-store.js";
 import { PathResolver } from "../utils/path-resolver.js";
 import { toRepoId } from "../utils/repo-id.js";
 import { HimanError, errorCodes } from "../utils/errors.js";
+import { getProjectResourcePaths, getSupportedAgentNames, normalizeAgents, } from "../utils/agent-configs.js";
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import { VersionResolver } from "../adapters/version/version-resolver.js";
+import YAML from "yaml";
 export class ServiceFactory {
     stateStore = new StateStore();
+    projectConfigStore = new ProjectConfigStore();
     lockStore = new ProjectLockStore();
     paths = new PathResolver();
     versions = new VersionResolver();
     async initSource(type, repo) {
         await this.stateStore.ensureBaseDirs();
+        const current = await this.stateStore.loadConfig();
         const sourceConfig = this.buildSourceConfig(type, repo);
         const source = this.createSource(type);
         await source.init(sourceConfig);
@@ -29,6 +34,7 @@ export class ServiceFactory {
                 default: "default",
                 items: { default: stateSource },
             },
+            agents: current?.agents,
         });
         return {
             sourceType: type,
@@ -60,6 +66,7 @@ export class ServiceFactory {
                 default: defaultName,
                 items,
             },
+            agents: current?.agents,
         });
         return { name, type, repo: sourceConfig.repo, repoId: sourceConfig.repoId };
     }
@@ -78,6 +85,7 @@ export class ServiceFactory {
                 default: name,
                 items: config.sources.items,
             },
+            agents: config.agents,
         });
         return { name };
     }
@@ -93,15 +101,63 @@ export class ServiceFactory {
             isDefault: name === config.sources?.default,
         }));
     }
-    async list(type) {
+    async setAgents(agents, scope, projectDir) {
+        const normalized = normalizeAgents(agents);
+        if (scope === "project") {
+            await this.projectConfigStore.saveAgents(projectDir, normalized);
+            return { scope, agents: normalized };
+        }
+        await this.stateStore.ensureBaseDirs();
+        const current = await this.stateStore.loadConfig();
+        await this.stateStore.saveConfig({
+            ...(current ?? {}),
+            agents: normalized,
+        });
+        return { scope, agents: normalized };
+    }
+    async getAgentSettings(projectDir) {
+        const [globalConfig, projectConfig] = await Promise.all([
+            this.stateStore.loadConfig(),
+            this.projectConfigStore.load(projectDir),
+        ]);
+        const global = globalConfig?.agents?.length
+            ? normalizeAgents(globalConfig.agents)
+            : undefined;
+        const project = projectConfig?.agents?.length
+            ? normalizeAgents(projectConfig.agents)
+            : undefined;
+        return {
+            global,
+            project,
+            effective: project ?? global ?? normalizeAgents(),
+            supported: getSupportedAgentNames(),
+        };
+    }
+    async clearAgents(scope, projectDir) {
+        if (scope === "project") {
+            await this.projectConfigStore.clearAgents(projectDir);
+            return { scope };
+        }
+        const current = await this.stateStore.loadConfig();
+        await this.stateStore.saveConfig({
+            ...(current ?? {}),
+            agents: undefined,
+        });
+        return { scope };
+    }
+    async list(type, agents) {
         const source = await this.loadSourceFromConfig();
-        return source.list(type);
+        const resources = await source.list(type);
+        if (!agents?.length)
+            return resources;
+        const selected = normalizeAgents(agents);
+        return resources.filter((resource) => normalizeAgents(resource.agents).some((agent) => selected.includes(agent)));
     }
     async history(type, name) {
         const source = await this.loadSourceFromConfig();
         return source.history(type, name);
     }
-    async install(type, name, version, projectDir) {
+    async install(type, name, version, projectDir, agents, mode = "link") {
         const source = await this.loadSourceFromConfig();
         const sourceInfo = await this.getLockSourceInfo();
         const history = await source.history(type, name);
@@ -110,37 +166,53 @@ export class ServiceFactory {
         }
         const resolvedVersion = this.resolveVersion(history, version);
         const storePath = this.getStorePath(type, name, resolvedVersion);
-        const linkPath = this.getProjectResourcePath(projectDir, type, name);
         if (!(await this.exists(storePath))) {
             await source.pull(type, name, resolvedVersion, storePath);
         }
-        await this.switchSymlink(storePath, linkPath);
+        const resourceMeta = await this.readResourceMetaFromDir(storePath);
+        const effectiveTargets = await this.resolveEffectiveAgents(projectDir, agents, resourceMeta?.agents);
+        const linkPaths = getProjectResourcePaths(projectDir, type, name, effectiveTargets);
+        for (const linkPath of linkPaths) {
+            await this.materializeResource(storePath, linkPath, mode);
+        }
         await this.lockStore.upsertResource(projectDir, sourceInfo, {
             type,
             name,
             version: resolvedVersion,
+            agents: effectiveTargets,
+            mode,
         });
-        return { type, name, version: resolvedVersion, linkPath };
+        return { type, name, version: resolvedVersion, linkPath: linkPaths[0], mode };
     }
     async dev(type, name, projectDir) {
-        const linkPath = this.getProjectResourcePath(projectDir, type, name);
-        const installedPath = await this.readInstalledPath(linkPath);
+        const installInfo = await this.resolveInstalledResource(projectDir, type, name);
+        const installedPath = installInfo.installedPath;
         const devPath = this.getProjectDevPath(projectDir, type, name);
         if (!(await this.exists(devPath))) {
             await fs.mkdir(path.dirname(devPath), { recursive: true });
             await fs.cp(installedPath, devPath, { recursive: true });
         }
-        await this.switchSymlink(devPath, linkPath);
-        return { type, name, devPath, linkPath };
+        for (const linkPath of installInfo.linkPaths) {
+            await this.materializeResource(devPath, linkPath, installInfo.mode);
+        }
+        return {
+            type,
+            name,
+            devPath,
+            linkPath: installInfo.linkPaths[0],
+            mode: installInfo.mode,
+        };
     }
     async uninstall(type, name, projectDir) {
-        const linkPath = this.getProjectResourcePath(projectDir, type, name);
-        if (!(await this.exists(linkPath))) {
-            throw new HimanError(errorCodes.INSTALL_NOT_FOUND, `Installed resource link not found: ${linkPath}.`);
+        const installInfo = await this.resolveInstalledResource(projectDir, type, name);
+        if (installInfo.linkPaths.length === 0) {
+            throw new HimanError(errorCodes.INSTALL_NOT_FOUND, `Installed resource link not found for ${type}/${name}.`);
+        }
+        for (const linkPath of installInfo.linkPaths) {
+            await fs.rm(linkPath, { recursive: true, force: true });
         }
-        await fs.rm(linkPath, { recursive: true, force: true });
         await this.lockStore.removeResource(projectDir, { type, name });
-        return { type, name, linkPath };
+        return { type, name, linkPath: installInfo.linkPaths[0] };
     }
     async publish(type, name, releaseType, projectDir) {
         const source = await this.loadSourceFromConfig();
@@ -155,33 +227,43 @@ export class ServiceFactory {
         if (!(await this.exists(storePath))) {
             await source.pull(type, name, nextVersion, storePath);
         }
-        const linkPath = this.getProjectResourcePath(projectDir, type, name);
-        if (await this.exists(linkPath)) {
-            await this.switchSymlink(storePath, linkPath);
+        const agentsFromMeta = normalizeAgents((await this.readResourceMetaFromDir(storePath))?.agents);
+        const locked = await this.getLockedResource(projectDir, type, name);
+        const nextAgents = locked?.agents?.length
+            ? normalizeAgents(locked.agents)
+            : agentsFromMeta;
+        const installMode = this.resolveInstallMode(locked?.mode);
+        const linkPaths = getProjectResourcePaths(projectDir, type, name, nextAgents);
+        for (const linkPath of linkPaths) {
+            if (await this.exists(linkPath)) {
+                await this.materializeResource(storePath, linkPath, installMode);
+            }
         }
-        if (await this.isResourceLocked(projectDir, type, name)) {
+        if (locked) {
             const sourceInfo = await this.getLockSourceInfo();
             await this.lockStore.upsertResource(projectDir, sourceInfo, {
                 type,
                 name,
                 version: nextVersion,
+                agents: nextAgents,
+                mode: installMode,
             });
         }
         return { type, name, version: result.version, tag: result.tag };
     }
-    async create(type, name, options) {
+    async create(type, name, options, projectDir) {
         this.validateCreateInput(type, name, options);
         const source = await this.loadSourceFromConfig();
         return source.create(type, name, {
             description: options.description,
-            targets: options.targets,
+            agents: await this.resolveEffectiveAgents(projectDir, options.agents),
             entry: options.entry,
             template: options.template ?? "basic",
             force: options.force,
             dryRun: options.dryRun,
         });
     }
-    async installFromLock(projectDir) {
+    async installFromLock(projectDir, agents, mode) {
         const { lock, state } = await this.lockStore.loadWithState(projectDir);
         if (state === "missing") {
             throw new HimanError(errorCodes.LOCK_NOT_FOUND, `Lock file not found: ${this.lockStore.getLockPath(projectDir)}`);
@@ -194,14 +276,14 @@ export class ServiceFactory {
         }
         const results = [];
         for (const item of lock.resources) {
-            const result = await this.install(item.type, item.name, item.version, projectDir);
+            const result = await this.install(item.type, item.name, item.version, projectDir, agents ?? item.agents, mode ?? this.resolveInstallMode(item.mode));
             results.push(result);
         }
         return results;
     }
     async loadSourceFromConfig() {
         const config = await this.stateStore.loadConfig();
-        if (!config) {
+        if (!config?.source) {
             throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "Source config not found. Please run `himan init <git_repo>` first.");
         }
         const sourceConfig = this.buildSourceConfig(config.source.type, config.source.repo, config.source.repoId);
@@ -216,7 +298,7 @@ export class ServiceFactory {
     }
     async getLockSourceInfo() {
         const config = await this.stateStore.loadConfig();
-        if (!config) {
+        if (!config?.source) {
             throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "Source config not found. Please run `himan init <git_repo>` first.");
         }
         return {
@@ -225,11 +307,11 @@ export class ServiceFactory {
             repoId: config.source.repoId,
         };
     }
-    async isResourceLocked(projectDir, type, name) {
+    async getLockedResource(projectDir, type, name) {
         const lock = await this.lockStore.load(projectDir);
         if (!lock)
-            return false;
-        return lock.resources.some((item) => item.type === type && item.name === name);
+            return undefined;
+        return lock.resources.find((item) => item.type === type && item.name === name);
     }
     buildSourceConfig(type, repo, repoId) {
         if (type === "registry") {
@@ -258,26 +340,100 @@ export class ServiceFactory {
     getStorePath(type, name, version) {
         return path.join(this.paths.getStoreDir(), type, name, version);
     }
-    getProjectResourcePath(projectDir, type, name) {
-        if (type === "rule")
-            return path.join(projectDir, ".cursor", "rules", name);
-        if (type === "command")
-            return path.join(projectDir, ".cursor", "commands", name);
-        return path.join(projectDir, ".cursor", "skills", name);
-    }
     getProjectDevPath(projectDir, type, name) {
         return path.join(projectDir, ".himan", "dev", type, name);
     }
-    async switchSymlink(targetPath, linkPath) {
-        await fs.mkdir(path.dirname(linkPath), { recursive: true });
-        await fs.rm(linkPath, { recursive: true, force: true });
-        await fs.symlink(targetPath, linkPath, "dir");
+    async materializeResource(sourcePath, targetPath, mode) {
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.rm(targetPath, { recursive: true, force: true });
+        if (mode === "copy") {
+            await fs.cp(sourcePath, targetPath, { recursive: true });
+            return;
+        }
+        await fs.symlink(sourcePath, targetPath, "dir");
+    }
+    resolveInstallMode(mode) {
+        return mode === "copy" ? "copy" : "link";
+    }
+    async resolveInstalledResource(projectDir, type, name) {
+        const locked = await this.getLockedResource(projectDir, type, name);
+        const configuredAgents = await this.getConfiguredAgents(projectDir);
+        const lockedTargets = locked?.agents?.length
+            ? normalizeAgents(locked.agents)
+            : configuredAgents ?? normalizeAgents();
+        const expectedFromLock = getProjectResourcePaths(projectDir, type, name, lockedTargets);
+        const existingFromLock = [];
+        for (const candidate of expectedFromLock) {
+            if (await this.exists(candidate))
+                existingFromLock.push(candidate);
+        }
+        if (existingFromLock.length > 0) {
+            const installedPath = await fs.realpath(existingFromLock[0]);
+            return {
+                installedPath,
+                agents: lockedTargets,
+                linkPaths: getProjectResourcePaths(projectDir, type, name, lockedTargets),
+                mode: this.resolveInstallMode(locked?.mode),
+            };
+        }
+        const allCandidates = getSupportedAgentNames().map((agent) => ({
+            agent,
+            path: getProjectResourcePaths(projectDir, type, name, [agent])[0],
+        }));
+        const existingCandidates = [];
+        for (const candidate of allCandidates) {
+            if (await this.exists(candidate.path))
+                existingCandidates.push(candidate);
+        }
+        if (existingCandidates.length === 0) {
+            throw new HimanError(errorCodes.INSTALL_NOT_FOUND, `Installed resource link not found for ${type}/${name}. Run install first.`);
+        }
+        const installedPath = await fs.realpath(existingCandidates[0].path);
+        const resourceMeta = await this.readResourceMetaFromDir(installedPath);
+        const agentsFromMeta = resourceMeta?.agents?.length
+            ? normalizeAgents(resourceMeta.agents)
+            : undefined;
+        const existingAgents = normalizeAgents(existingCandidates.map((candidate) => candidate.agent));
+        const effectiveAgents = configuredAgents ?? agentsFromMeta ?? existingAgents;
+        return {
+            installedPath,
+            agents: effectiveAgents,
+            linkPaths: getProjectResourcePaths(projectDir, type, name, effectiveAgents),
+            mode: "link",
+        };
+    }
+    async resolveEffectiveAgents(projectDir, explicitAgents, fallbackAgents) {
+        if (explicitAgents?.length) {
+            return normalizeAgents(explicitAgents);
+        }
+        const configuredAgents = await this.getConfiguredAgents(projectDir);
+        if (configuredAgents?.length) {
+            return configuredAgents;
+        }
+        return normalizeAgents(fallbackAgents);
     }
-    async readInstalledPath(linkPath) {
-        if (!(await this.exists(linkPath))) {
-            throw new HimanError(errorCodes.INSTALL_NOT_FOUND, `Installed resource link not found: ${linkPath}. Run install first.`);
+    async getConfiguredAgents(projectDir) {
+        const [globalConfig, projectConfig] = await Promise.all([
+            this.stateStore.loadConfig(),
+            this.projectConfigStore.load(projectDir),
+        ]);
+        if (projectConfig?.agents?.length) {
+            return normalizeAgents(projectConfig.agents);
         }
-        return fs.realpath(linkPath);
+        if (globalConfig?.agents?.length) {
+            return normalizeAgents(globalConfig.agents);
+        }
+        return undefined;
+    }
+    async readResourceMetaFromDir(resourceDir) {
+        const yamlPath = path.join(resourceDir, "himan.yaml");
+        if (!(await this.exists(yamlPath)))
+            return null;
+        const raw = await fs.readFile(yamlPath, "utf8");
+        const parsed = YAML.parse(raw) ?? null;
+        if (!parsed)
+            return null;
+        return { agents: parsed.agents ?? parsed.targets };
     }
     async exists(targetPath) {
         try {
@@ -301,7 +457,7 @@ export class ServiceFactory {
     }
     async getRepoResourceDir(type, name) {
         const config = await this.stateStore.loadConfig();
-        if (!config) {
+        if (!config?.source) {
             throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "Source config not found. Please run `himan init <git_repo>` first.");
         }
         const sourceConfig = this.buildSourceConfig(config.source.type, config.source.repo, config.source.repoId);

package/dist/state/project-config-store.js

@@ -0,0 +1,43 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export class ProjectConfigStore {
+    getConfigPath(projectDir) {
+        return path.join(projectDir, ".himan", "config.json");
+    }
+    async load(projectDir) {
+        try {
+            const raw = await fs.readFile(this.getConfigPath(projectDir), "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version !== 1)
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveAgents(projectDir, agents) {
+        const now = new Date().toISOString();
+        const existing = await this.load(projectDir);
+        const config = {
+            version: 1,
+            ...existing,
+            agents,
+            updatedAt: now,
+        };
+        await fs.mkdir(path.dirname(this.getConfigPath(projectDir)), { recursive: true });
+        await fs.writeFile(this.getConfigPath(projectDir), JSON.stringify(config, null, 2), "utf8");
+        return config;
+    }
+    async clearAgents(projectDir) {
+        const existing = await this.load(projectDir);
+        if (!existing)
+            return;
+        const config = {
+            ...existing,
+            agents: undefined,
+            updatedAt: new Date().toISOString(),
+        };
+        await fs.writeFile(this.getConfigPath(projectDir), JSON.stringify(config, null, 2), "utf8");
+    }
+}

package/dist/state/project-lock-store.js

@@ -40,6 +40,8 @@ export class ProjectLockStore {
         const found = lock.resources.find((item) => item.type === resource.type && item.name === resource.name);
         if (found) {
             found.version = resource.version;
+            found.agents = resource.agents;
+            found.mode = resource.mode;
             found.updatedAt = now;
         }
         else {
@@ -47,6 +49,8 @@ export class ProjectLockStore {
                 type: resource.type,
                 name: resource.name,
                 version: resource.version,
+                agents: resource.agents,
+                mode: resource.mode,
                 updatedAt: now,
             });
         }

package/dist/state/state-store.js

@@ -35,12 +35,15 @@ export class StateStore {
                         default: defaultName,
                         items: input.sources.items,
                     },
+                    agents: input.agents,
                 };
             }
         }
         const fallback = input.source;
         if (!fallback) {
-            throw new Error("Invalid config: source is required.");
+            return {
+                agents: input.agents,
+            };
         }
         return {
             source: fallback,
@@ -50,6 +53,7 @@ export class StateStore {
                     default: fallback,
                 },
             },
+            agents: input.agents,
         };
     }
 }

package/dist/utils/agent-configs.js

@@ -0,0 +1,71 @@
+import path from "node:path";
+const AGENT_CONFIGS = [
+    {
+        name: "cursor",
+        aliases: ["cursor"],
+        baseDir: ".cursor",
+    },
+    {
+        name: "claude-code",
+        aliases: ["claude", "claude-code", "claude code", "claude_code"],
+        baseDir: ".claude",
+    },
+    {
+        name: "codex",
+        aliases: ["codex"],
+        baseDir: ".agents",
+    },
+    {
+        name: "openclaw",
+        aliases: ["openclaw", "open-claw", "open claw"],
+        baseDir: ".openclaw",
+    },
+];
+const DEFAULT_AGENT = "cursor";
+const AGENT_ALIASES = buildAgentAliases();
+function getTypeDir(type) {
+    if (type === "rule")
+        return "rules";
+    if (type === "command")
+        return "commands";
+    return "skills";
+}
+function getAgentBaseDir(agent) {
+    return getAgentConfig(agent).baseDir;
+}
+export function normalizeAgents(agents) {
+    const normalized = (agents ?? [])
+        .map((item) => normalizeAgent(item))
+        .filter((item) => Boolean(item));
+    if (normalized.length === 0) {
+        return [DEFAULT_AGENT];
+    }
+    return [...new Set(normalized)];
+}
+export function normalizeAgent(input) {
+    return AGENT_ALIASES.get(input.trim().toLowerCase());
+}
+export function getProjectResourcePaths(projectDir, type, name, agents) {
+    const typeDir = getTypeDir(type);
+    return normalizeAgents(agents).map((agent) => path.join(projectDir, getAgentBaseDir(agent), typeDir, name));
+}
+export function getSupportedAgentNames() {
+    return AGENT_CONFIGS.map((config) => config.name);
+}
+function getAgentConfig(agent) {
+    const config = AGENT_CONFIGS.find((item) => item.name === agent);
+    if (!config) {
+        throw new Error(`Unsupported agent config: ${agent}`);
+    }
+    return config;
+}
+function buildAgentAliases() {
+    const aliases = new Map();
+    for (const config of AGENT_CONFIGS) {
+        aliases.set(config.name, config.name);
+        for (const alias of config.aliases) {
+            aliases.set(alias, config.name);
+        }
+    }
+    return aliases;
+}

package/dist/{version.js → utils/version.js}

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
-const pkgPath = join(moduleDir, "../package.json");
+const pkgPath = join(moduleDir, "../../package.json");
 const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
 if (typeof parsed.version !== "string" || parsed.version.length === 0) {
     throw new Error("Invalid or missing version in package.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hi-man/himan",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Prompt and agent asset management CLI",
   "license": "MIT",
   "type": "module",
@@ -23,11 +23,14 @@
     "registry": "https://registry.npmjs.org/"
   },
   "bin": {
-    "himan": "dist/index.js"
+    "himan": "dist/bin/himan.js",
+    "himan-source": "dist/bin/himan-source.js",
+    "himan-resource": "dist/bin/himan-resource.js",
+    "himan-project": "dist/bin/himan-project.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "dev": "tsx src/index.ts",
+    "dev": "tsx src/bin/himan.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",