@hi-man/himan 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,318 @@
+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);
+}

package/dist/domain/resource.js

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

package/dist/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { CommanderError } from "commander";
+import { buildCli, writeCliError } from "./cli/index.js";
+async function main() {
+    const program = buildCli();
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (error instanceof CommanderError && error.exitCode === 0) {
+            return;
+        }
+        writeCliError(error);
+        process.exitCode = error instanceof CommanderError ? error.exitCode : 1;
+    }
+}
+void main();

package/dist/services/index.js

@@ -0,0 +1,331 @@
+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 { PathResolver } from "../utils/path-resolver.js";
+import { toRepoId } from "../utils/repo-id.js";
+import { HimanError, errorCodes } from "../utils/errors.js";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { VersionResolver } from "../adapters/version/version-resolver.js";
+export class ServiceFactory {
+    stateStore = new StateStore();
+    lockStore = new ProjectLockStore();
+    paths = new PathResolver();
+    versions = new VersionResolver();
+    async initSource(type, repo) {
+        await this.stateStore.ensureBaseDirs();
+        const sourceConfig = this.buildSourceConfig(type, repo);
+        const source = this.createSource(type);
+        await source.init(sourceConfig);
+        const stateSource = {
+            type,
+            repo: sourceConfig.repo,
+            repoId: sourceConfig.repoId,
+        };
+        await this.stateStore.saveConfig({
+            source: stateSource,
+            sources: {
+                default: "default",
+                items: { default: stateSource },
+            },
+        });
+        return {
+            sourceType: type,
+            repo: sourceConfig.repo,
+            repoId: sourceConfig.repoId,
+        };
+    }
+    async addSource(name, type, repo) {
+        if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
+            throw new HimanError(errorCodes.INVALID_INPUT, `Invalid source name: ${name}`);
+        }
+        await this.stateStore.ensureBaseDirs();
+        const sourceConfig = this.buildSourceConfig(type, repo);
+        const source = this.createSource(type);
+        await source.init(sourceConfig);
+        const stateSource = {
+            type,
+            repo: sourceConfig.repo,
+            repoId: sourceConfig.repoId,
+        };
+        const current = await this.stateStore.loadConfig();
+        const items = { ...(current?.sources?.items ?? {}) };
+        items[name] = stateSource;
+        const defaultName = current?.sources?.default ?? name;
+        const defaultSource = items[defaultName] ?? stateSource;
+        await this.stateStore.saveConfig({
+            source: defaultSource,
+            sources: {
+                default: defaultName,
+                items,
+            },
+        });
+        return { name, type, repo: sourceConfig.repo, repoId: sourceConfig.repoId };
+    }
+    async useSource(name) {
+        const config = await this.stateStore.loadConfig();
+        if (!config?.sources) {
+            throw new HimanError(errorCodes.CONFIG_NOT_FOUND, "No source configured.");
+        }
+        const target = config.sources.items[name];
+        if (!target) {
+            throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `Source not found: ${name}`);
+        }
+        await this.stateStore.saveConfig({
+            source: target,
+            sources: {
+                default: name,
+                items: config.sources.items,
+            },
+        });
+        return { name };
+    }
+    async listSources() {
+        const config = await this.stateStore.loadConfig();
+        if (!config?.sources)
+            return [];
+        return Object.entries(config.sources.items).map(([name, source]) => ({
+            name,
+            type: source.type,
+            repo: source.repo,
+            repoId: source.repoId,
+            isDefault: name === config.sources?.default,
+        }));
+    }
+    async list(type) {
+        const source = await this.loadSourceFromConfig();
+        return source.list(type);
+    }
+    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 dev(type, name, projectDir) {
+        const linkPath = this.getProjectResourcePath(projectDir, type, name);
+        const installedPath = await this.readInstalledPath(linkPath);
+        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 };
+    }
+    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}.`);
+        }
+        await fs.rm(linkPath, { recursive: true, force: true });
+        await this.lockStore.removeResource(projectDir, { type, name });
+        return { type, name, linkPath };
+    }
+    async publish(type, name, releaseType, projectDir) {
+        const source = await this.loadSourceFromConfig();
+        const sourceDir = await this.resolvePublishSourceDir(type, name, projectDir);
+        const history = await source.history(type, name);
+        const latest = history[0]?.version ?? "0.0.0";
+        const nextVersion = this.versions.nextVersion(latest, releaseType);
+        const result = await source.publish(type, name, nextVersion, sourceDir, {
+            releaseType,
+        });
+        const storePath = this.getStorePath(type, name, nextVersion);
+        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);
+        }
+        if (await this.isResourceLocked(projectDir, type, name)) {
+            const sourceInfo = await this.getLockSourceInfo();
+            await this.lockStore.upsertResource(projectDir, sourceInfo, {
+                type,
+                name,
+                version: nextVersion,
+            });
+        }
+        return { type, name, version: result.version, tag: result.tag };
+    }
+    async create(type, name, options) {
+        this.validateCreateInput(type, name, options);
+        const source = await this.loadSourceFromConfig();
+        return source.create(type, name, {
+            description: options.description,
+            targets: options.targets,
+            entry: options.entry,
+            template: options.template ?? "basic",
+            force: options.force,
+            dryRun: options.dryRun,
+        });
+    }
+    async installFromLock(projectDir) {
+        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)}`);
+        }
+        if (state === "invalid" || !lock) {
+            throw new HimanError(errorCodes.LOCK_INVALID, `Lock file is invalid: ${this.lockStore.getLockPath(projectDir)}`);
+        }
+        if (lock.resources.length === 0) {
+            throw new HimanError(errorCodes.LOCK_NOT_FOUND, `Lock file has no resources: ${this.lockStore.getLockPath(projectDir)}`);
+        }
+        const results = [];
+        for (const item of lock.resources) {
+            const result = await this.install(item.type, item.name, item.version, projectDir);
+            results.push(result);
+        }
+        return results;
+    }
+    async loadSourceFromConfig() {
+        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 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;
+    }
+    createSource(type) {
+        return type === "registry"
+            ? new RegistrySourceAdapter()
+            : 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.");
+        }
+        return {
+            type: config.source.type,
+            repo: config.source.repo,
+            repoId: config.source.repoId,
+        };
+    }
+    async isResourceLocked(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);
+    }
+    buildSourceConfig(type, repo, repoId) {
+        if (type === "registry") {
+            return { type };
+        }
+        if (!repo) {
+            throw new HimanError(errorCodes.INVALID_INPUT, "Git repo is required for git source.");
+        }
+        const effectiveRepoId = repoId ?? toRepoId(repo);
+        return {
+            type,
+            repo,
+            repoId: effectiveRepoId,
+            repoDir: path.join(this.paths.getReposDir(), effectiveRepoId),
+        };
+    }
+    resolveVersion(history, version) {
+        if (!version)
+            return history[0].version;
+        const found = history.find((item) => item.version === version);
+        if (!found) {
+            throw new HimanError(errorCodes.VERSION_NOT_FOUND, `Version not found: ${version}`);
+        }
+        return found.version;
+    }
+    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 readInstalledPath(linkPath) {
+        if (!(await this.exists(linkPath))) {
+            throw new HimanError(errorCodes.INSTALL_NOT_FOUND, `Installed resource link not found: ${linkPath}. Run install first.`);
+        }
+        return fs.realpath(linkPath);
+    }
+    async exists(targetPath) {
+        try {
+            await fs.access(targetPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async resolvePublishSourceDir(type, name, projectDir) {
+        const devPath = this.getProjectDevPath(projectDir, type, name);
+        if (await this.exists(devPath)) {
+            return devPath;
+        }
+        const repoResourceDir = await this.getRepoResourceDir(type, name);
+        if (await this.exists(repoResourceDir)) {
+            return repoResourceDir;
+        }
+        throw new HimanError(errorCodes.RESOURCE_NOT_FOUND, `No publish source found for ${type}/${name}. Create resource or switch to dev mode first.`);
+    }
+    async getRepoResourceDir(type, name) {
+        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 sourceConfig = this.buildSourceConfig(config.source.type, config.source.repo, config.source.repoId);
+        if (!sourceConfig.repoDir) {
+            throw new HimanError(errorCodes.INVALID_INPUT, "Current source does not support repo directory publish.");
+        }
+        return path.join(sourceConfig.repoDir, `${this.getTypeDir(type)}`, name);
+    }
+    getTypeDir(type) {
+        if (type === "rule")
+            return "rules";
+        if (type === "command")
+            return "commands";
+        return "skills";
+    }
+    validateCreateInput(type, name, options) {
+        if (!["rule", "command", "skill"].includes(type)) {
+            throw new HimanError(errorCodes.UNSUPPORTED_RESOURCE_TYPE, `Unsupported resource type for create: ${type}`);
+        }
+        if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
+            throw new HimanError(errorCodes.INVALID_RESOURCE_NAME, `Invalid resource name: ${name}. Use kebab-case only.`);
+        }
+        if (options.template && options.template !== "basic") {
+            throw new HimanError(errorCodes.TEMPLATE_NOT_FOUND, `Template not found: ${options.template}`);
+        }
+    }
+}