@hi-man/himan 0.1.0

package/dist/state/index-cache-store.js

@@ -0,0 +1,48 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { PathResolver } from "../utils/path-resolver.js";
+export class IndexCacheStore {
+    paths = new PathResolver();
+    getIndexPath() {
+        return path.join(this.paths.getHimanRoot(), "index.json");
+    }
+    async get(repoId, type) {
+        const data = await this.load();
+        if (!data)
+            return null;
+        return data.entries.find((item) => item.repoId === repoId && item.type === type) ?? null;
+    }
+    async upsert(repoId, type, baseDirMtimeMs, 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.resources = resources;
+            found.updatedAt = now;
+        }
+        else {
+            file.entries.push({
+                repoId,
+                type,
+                baseDirMtimeMs,
+                resources,
+                updatedAt: now,
+            });
+        }
+        await fs.mkdir(path.dirname(this.getIndexPath()), { recursive: true });
+        await fs.writeFile(this.getIndexPath(), JSON.stringify(file, null, 2), "utf8");
+    }
+    async load() {
+        try {
+            const raw = await fs.readFile(this.getIndexPath(), "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export class ProjectLockStore {
+    getLockPath(projectDir) {
+        return path.join(projectDir, "himan.lock");
+    }
+    async loadWithState(projectDir) {
+        const lockPath = this.getLockPath(projectDir);
+        try {
+            const raw = await fs.readFile(lockPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version !== 1 || !Array.isArray(parsed.resources)) {
+                return { lock: null, state: "invalid" };
+            }
+            return { lock: parsed, state: "ok" };
+        }
+        catch (error) {
+            const err = error;
+            if (err?.code === "ENOENT") {
+                return { lock: null, state: "missing" };
+            }
+            return { lock: null, state: "invalid" };
+        }
+    }
+    async load(projectDir) {
+        const result = await this.loadWithState(projectDir);
+        return result.lock;
+    }
+    async upsertResource(projectDir, source, resource) {
+        const now = new Date().toISOString();
+        const existing = await this.load(projectDir);
+        const lock = existing ?? {
+            version: 1,
+            source,
+            updatedAt: now,
+            resources: [],
+        };
+        lock.source = source;
+        lock.updatedAt = now;
+        const found = lock.resources.find((item) => item.type === resource.type && item.name === resource.name);
+        if (found) {
+            found.version = resource.version;
+            found.updatedAt = now;
+        }
+        else {
+            lock.resources.push({
+                type: resource.type,
+                name: resource.name,
+                version: resource.version,
+                updatedAt: now,
+            });
+        }
+        lock.resources.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type.localeCompare(b.type);
+            return a.name.localeCompare(b.name);
+        });
+        await fs.writeFile(this.getLockPath(projectDir), JSON.stringify(lock, null, 2), "utf8");
+    }
+    async removeResource(projectDir, resource) {
+        const lock = await this.load(projectDir);
+        if (!lock)
+            return;
+        const nextResources = lock.resources.filter((item) => !(item.type === resource.type && item.name === resource.name));
+        if (nextResources.length === lock.resources.length) {
+            return;
+        }
+        lock.resources = nextResources;
+        lock.updatedAt = new Date().toISOString();
+        await fs.writeFile(this.getLockPath(projectDir), JSON.stringify(lock, null, 2), "utf8");
+    }
+}

package/dist/state/state-store.js

@@ -0,0 +1,55 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { PathResolver } from "../utils/path-resolver.js";
+export class StateStore {
+    paths = new PathResolver();
+    getConfigPath() {
+        return path.join(this.paths.getHimanRoot(), "config.json");
+    }
+    async ensureBaseDirs() {
+        await fs.mkdir(this.paths.getReposDir(), { recursive: true });
+        await fs.mkdir(this.paths.getStoreDir(), { recursive: true });
+    }
+    async saveConfig(config) {
+        const normalized = this.normalizeConfig(config);
+        await fs.mkdir(path.dirname(this.getConfigPath()), { recursive: true });
+        await fs.writeFile(this.getConfigPath(), JSON.stringify(normalized, null, 2));
+    }
+    async loadConfig() {
+        try {
+            const raw = await fs.readFile(this.getConfigPath(), "utf8");
+            return this.normalizeConfig(JSON.parse(raw));
+        }
+        catch {
+            return null;
+        }
+    }
+    normalizeConfig(input) {
+        if (input.sources?.default && input.sources.items) {
+            const defaultName = input.sources.default;
+            const defaultSource = input.sources.items[defaultName];
+            if (defaultSource) {
+                return {
+                    source: defaultSource,
+                    sources: {
+                        default: defaultName,
+                        items: input.sources.items,
+                    },
+                };
+            }
+        }
+        const fallback = input.source;
+        if (!fallback) {
+            throw new Error("Invalid config: source is required.");
+        }
+        return {
+            source: fallback,
+            sources: {
+                default: "default",
+                items: {
+                    default: fallback,
+                },
+            },
+        };
+    }
+}

package/dist/utils/errors.js

@@ -0,0 +1,25 @@
+export class HimanError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "HimanError";
+    }
+}
+export const errorCodes = {
+    CONFIG_NOT_FOUND: "E_CONFIG_NOT_FOUND",
+    NOT_IMPLEMENTED: "E_NOT_IMPLEMENTED",
+    INVALID_INPUT: "E_INVALID_INPUT",
+    RESOURCE_NOT_FOUND: "E_RESOURCE_NOT_FOUND",
+    VERSION_NOT_FOUND: "E_VERSION_NOT_FOUND",
+    INSTALL_NOT_FOUND: "E_INSTALL_NOT_FOUND",
+    LOCK_NOT_FOUND: "E_LOCK_NOT_FOUND",
+    LOCK_INVALID: "E_LOCK_INVALID",
+    CLI_USAGE: "E_CLI_USAGE",
+    RESOURCE_EXISTS: "E_RESOURCE_EXISTS",
+    TEMPLATE_NOT_FOUND: "E_TEMPLATE_NOT_FOUND",
+    INVALID_RESOURCE_NAME: "E_INVALID_RESOURCE_NAME",
+    UNSUPPORTED_RESOURCE_TYPE: "E_UNSUPPORTED_RESOURCE_TYPE",
+};

package/dist/utils/path-resolver.js

@@ -0,0 +1,16 @@
+import os from "node:os";
+import path from "node:path";
+export class PathResolver {
+    getHomeDir() {
+        return os.homedir();
+    }
+    getHimanRoot() {
+        return path.join(this.getHomeDir(), ".himan");
+    }
+    getReposDir() {
+        return path.join(this.getHimanRoot(), "repos");
+    }
+    getStoreDir() {
+        return path.join(this.getHimanRoot(), "store");
+    }
+}

package/dist/utils/repo-id.js

@@ -0,0 +1,4 @@
+export function toRepoId(repo) {
+    const normalized = repo.replace(/\/+$/, "").replace(/\.git$/, "");
+    return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}

package/dist/version.js

@@ -0,0 +1,10 @@
+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 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");
+}
+export const PACKAGE_VERSION = parsed.version;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@hi-man/himan",
+  "version": "0.1.0",
+  "description": "Prompt and agent asset management CLI",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "pnpm@10.32.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lidetao/himan.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lidetao/himan/issues"
+  },
+  "homepage": "https://github.com/lidetao/himan#readme",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "himan": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "verify": "pnpm run typecheck && pnpm run test && pnpm run build",
+    "release": "pnpm run verify && npm publish",
+    "release:dry": "pnpm run verify && npm publish --dry-run",
+    "release:test": "pnpm run verify && npm version prerelease --preid test --no-git-tag-version && npm publish --tag test",
+    "version:patch": "npm version patch --no-git-tag-version",
+    "version:minor": "npm version minor --no-git-tag-version",
+    "version:major": "npm version major --no-git-tag-version"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "semver": "^7.7.4",
+    "simple-git": "^3.33.0",
+    "yaml": "^2.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "@types/semver": "^7.7.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
+  }
+}