@hi-man/himan 0.1.0 → 0.2.2

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 { ProjectLockStore } from "../state/project-lock-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,54 +101,95 @@ 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) {
-        const source = await this.loadSourceFromConfig();
-        const sourceInfo = await this.getLockSourceInfo();
-        const history = await source.history(type, name);
-        if (history.length === 0) {
-            throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `Resource not found: ${type}/${name}`);
-        }
-        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);
-        await this.lockStore.upsertResource(projectDir, sourceInfo, {
-            type,
-            name,
-            version: resolvedVersion,
-        });
-        return { type, name, version: resolvedVersion, linkPath };
+    async install(type, name, version, projectDir, agents, mode = "link") {
+        const { source, sourceInfo } = await this.loadSourceWithInfoFromConfig();
+        return this.installWithSource(source, sourceInfo, type, name, version, projectDir, agents, 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 +204,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)}`);
@@ -193,21 +252,69 @@ export class ServiceFactory {
             throw new HimanError(errorCodes.LOCK_NOT_FOUND, `Lock file has no resources: ${this.lockStore.getLockPath(projectDir)}`);
         }
         const results = [];
+        const lockSourceInfo = this.normalizeLockSourceInfo(lock.source);
+        const lockedSource = await this.loadSourceFromLock(lockSourceInfo);
         for (const item of lock.resources) {
-            const result = await this.install(item.type, item.name, item.version, projectDir);
+            const result = await this.installWithSource(lockedSource, lockSourceInfo, item.type, item.name, item.version, projectDir, agents ?? item.agents, mode ?? this.resolveInstallMode(item.mode));
             results.push(result);
         }
         return results;
     }
+    async installWithSource(source, sourceInfo, type, name, version, projectDir, agents, mode) {
+        const history = await source.history(type, name);
+        if (history.length === 0) {
+            throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `Resource not found: ${type}/${name}`);
+        }
+        const resolvedVersion = this.resolveVersion(history, version);
+        const storePath = this.getStorePath(type, name, resolvedVersion);
+        if (!(await this.exists(storePath))) {
+            await source.pull(type, name, resolvedVersion, storePath);
+        }
+        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: linkPaths[0], mode };
+    }
     async loadSourceFromConfig() {
+        return (await this.loadSourceWithInfoFromConfig()).source;
+    }
+    async loadSourceWithInfoFromConfig() {
+        const { name, source: stateSource } = await this.getCurrentSourceState();
+        const sourceInfo = this.toLockSourceInfo(stateSource, name);
+        const source = await this.loadSourceFromInfo(sourceInfo);
+        return {
+            source,
+            sourceInfo,
+        };
+    }
+    async loadSourceFromLock(sourceInfo) {
+        return this.loadSourceFromInfo(sourceInfo);
+    }
+    async loadSourceFromInfo(sourceInfo) {
+        const normalizedSourceInfo = this.normalizeLockSourceInfo(sourceInfo);
+        const sourceConfig = this.buildSourceConfig(normalizedSourceInfo.type, normalizedSourceInfo.repo, normalizedSourceInfo.repoId);
+        const source = this.createSource(normalizedSourceInfo.type);
+        await source.init(sourceConfig);
+        return source;
+    }
+    async getCurrentSourceState() {
         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);
-        const source = this.createSource(config.source.type);
-        await source.init(sourceConfig);
-        return source;
+        const currentName = config.sources?.default ?? "default";
+        const currentSource = config.sources?.items[currentName] ?? config.source;
+        return { name: currentName, source: currentSource };
     }
     createSource(type) {
         return type === "registry"
@@ -215,21 +322,31 @@ export class ServiceFactory {
             : new GitSourceAdapter();
     }
     async getLockSourceInfo() {
-        const config = await this.stateStore.loadConfig();
-        if (!config) {
-            throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "Source config not found. Please run `himan init <git_repo>` first.");
+        const { name, source } = await this.getCurrentSourceState();
+        return this.toLockSourceInfo(source, name);
+    }
+    toLockSourceInfo(source, name) {
+        return this.normalizeLockSourceInfo({
+            name,
+            type: source.type,
+            repo: source.repo,
+            repoId: source.repoId,
+        });
+    }
+    normalizeLockSourceInfo(sourceInfo) {
+        if (sourceInfo.type !== "git" || !sourceInfo.repo) {
+            return sourceInfo;
         }
         return {
-            type: config.source.type,
-            repo: config.source.repo,
-            repoId: config.source.repoId,
+            ...sourceInfo,
+            repoId: sourceInfo.repoId ?? toRepoId(sourceInfo.repo),
         };
     }
-    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 +375,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 +492,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/index-cache-store.js

@@ -12,12 +12,13 @@ export class IndexCacheStore {
             return null;
         return data.entries.find((item) => item.repoId === repoId && item.type === type) ?? null;
     }
-    async upsert(repoId, type, baseDirMtimeMs, resources) {
+    async upsert(repoId, type, metadataHash, resources) {
         const now = new Date().toISOString();
         const file = (await this.load()) ?? { version: 1, entries: [] };
         const found = file.entries.find((item) => item.repoId === repoId && item.type === type);
         if (found) {
-            found.baseDirMtimeMs = baseDirMtimeMs;
+            found.metadataHash = metadataHash;
+            delete found.baseDirMtimeMs;
             found.resources = resources;
             found.updatedAt = now;
         }
@@ -25,7 +26,7 @@ export class IndexCacheStore {
             file.entries.push({
                 repoId,
                 type,
-                baseDirMtimeMs,
+                metadataHash,
                 resources,
                 updatedAt: now,
             });

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/utils/errors.js

@@ -21,5 +21,7 @@ export const errorCodes = {
     RESOURCE_EXISTS: "E_RESOURCE_EXISTS",
     TEMPLATE_NOT_FOUND: "E_TEMPLATE_NOT_FOUND",
     INVALID_RESOURCE_NAME: "E_INVALID_RESOURCE_NAME",
+    INVALID_RESOURCE_METADATA: "E_INVALID_RESOURCE_METADATA",
+    PUBLISH_NO_CHANGES: "E_PUBLISH_NO_CHANGES",
     UNSUPPORTED_RESOURCE_TYPE: "E_UNSUPPORTED_RESOURCE_TYPE",
 };

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");