@nomai/nomai 0.1.0

package/dist/payload-DdBYzrl3.mjs

@@ -0,0 +1,473 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import os from "node:os";
+//#region src/core/manifest.ts
+const MANIFEST_FILENAME = "nomai-manifest.json";
+function manifestPath(installDir) {
+	return path.join(installDir, MANIFEST_FILENAME);
+}
+function hashBytes(contents) {
+	return createHash("sha256").update(contents).digest("hex");
+}
+/** @returns null when no manifest exists; throws on a corrupt/foreign one. */
+async function readManifest(installDir) {
+	const file = manifestPath(installDir);
+	let raw;
+	try {
+		raw = await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Corrupt manifest at ${file}: not valid JSON. Remove it and reinstall.`);
+	}
+	if (!isManifest(parsed)) throw new Error(`Unrecognized manifest at ${file}. Remove it and reinstall.`);
+	return parsed;
+}
+async function writeManifest(installDir, manifest) {
+	await mkdir(installDir, { recursive: true });
+	await writeFile(manifestPath(installDir), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+async function removeManifest(installDir) {
+	await rm(manifestPath(installDir), { force: true });
+}
+function isManifest(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const m = value;
+	return m.schemaVersion === 1 && typeof m.nomaiVersion === "string" && typeof m.source === "string" && typeof m.harness === "string" && (m.scope === "project" || m.scope === "global") && typeof m.installedAt === "string" && Array.isArray(m.files) && m.files.every((f) => typeof f === "object" && f !== null && typeof f.path === "string" && typeof f.sha256 === "string");
+}
+function createManifest(options) {
+	return {
+		schemaVersion: 1,
+		nomaiVersion: options.nomaiVersion,
+		source: options.source,
+		harness: options.harness,
+		scope: options.scope,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		files: options.files
+	};
+}
+//#endregion
+//#region src/core/installer.ts
+/**
+* Generic install/uninstall/status engine shared by all harness adapters.
+* defineHarness() wires adapter methods to these functions by default;
+* adapters with special needs override the methods instead.
+*
+* This module is the only place in the codebase that writes to disk.
+*/
+async function installHarness(adapter, ctx) {
+	if (!ctx.payload) throw new Error(`install(${adapter.id}) requires a payload source.`);
+	const installDir = adapter.resolveInstallDir(ctx.scope, ctx);
+	const merged = mergePayload(await ctx.payload.readSharedFiles(), await ctx.payload.readHarnessOverlay(adapter.id));
+	const files = await adapter.transformPayload(merged, {
+		projectDir: ctx.projectDir,
+		homeDir: ctx.homeDir,
+		scope: ctx.scope,
+		nomaiVersion: ctx.nomaiVersion
+	});
+	const nextEntries = files.map((file) => ({
+		path: toPosix(file.relPath),
+		sha256: hashBytes(file.contents)
+	})).sort((a, b) => comparePaths(a.path, b.path));
+	const existing = await readManifest(installDir);
+	if (existing && !ctx.force) {
+		if (sameEntries(existing.files, nextEntries) && await allFilesMatch(installDir, nextEntries)) return {
+			installDir,
+			filesWritten: [],
+			filesRemoved: [],
+			skipped: true
+		};
+	}
+	const nextPaths = new Set(nextEntries.map((entry) => entry.path));
+	const orphans = (existing?.files ?? []).filter((entry) => !nextPaths.has(entry.path));
+	if (ctx.dryRun) return {
+		installDir,
+		filesWritten: nextEntries.map((entry) => entry.path),
+		filesRemoved: orphans.map((entry) => entry.path),
+		skipped: false
+	};
+	for (const file of files) {
+		const target = path.join(installDir, file.relPath);
+		await mkdir(path.dirname(target), { recursive: true });
+		await writeFile(target, file.contents);
+	}
+	const removed = await removeOwnedFiles(installDir, orphans, ctx.force);
+	await writeManifest(installDir, createManifest({
+		nomaiVersion: ctx.nomaiVersion,
+		source: ctx.payload.description,
+		harness: adapter.id,
+		scope: ctx.scope,
+		files: nextEntries
+	}));
+	return {
+		installDir,
+		filesWritten: nextEntries.map((entry) => entry.path),
+		filesRemoved: removed.removed,
+		skipped: false
+	};
+}
+async function uninstallHarness(adapter, ctx) {
+	const installDir = adapter.resolveInstallDir(ctx.scope, ctx);
+	const manifest = await readManifest(installDir);
+	if (!manifest) return {
+		installDir,
+		notInstalled: true,
+		filesRemoved: [],
+		filesKept: []
+	};
+	if (ctx.dryRun) return {
+		installDir,
+		notInstalled: false,
+		filesRemoved: manifest.files.map((entry) => entry.path),
+		filesKept: []
+	};
+	const { removed, kept } = await removeOwnedFiles(installDir, manifest.files, ctx.force);
+	await removeManifest(installDir);
+	await pruneEmptyDirs(installDir, removed);
+	return {
+		installDir,
+		notInstalled: false,
+		filesRemoved: removed,
+		filesKept: kept
+	};
+}
+async function statusHarness(adapter, ctx) {
+	const installDir = adapter.resolveInstallDir(ctx.scope, ctx);
+	const detected = ctx.scope === "project" ? await adapter.detectProject(ctx.projectDir) : await adapter.detectGlobal(ctx.homeDir);
+	const manifest = await readManifest(installDir);
+	if (!manifest) return {
+		harnessId: adapter.id,
+		scope: ctx.scope,
+		installDir,
+		detected,
+		installed: false,
+		modifiedFiles: [],
+		missingFiles: []
+	};
+	const modified = [];
+	const missing = [];
+	for (const entry of manifest.files) try {
+		if (hashBytes(await readFile(path.join(installDir, entry.path))) !== entry.sha256) modified.push(entry.path);
+	} catch (error) {
+		if (error.code === "ENOENT") missing.push(entry.path);
+		else throw error;
+	}
+	return {
+		harnessId: adapter.id,
+		scope: ctx.scope,
+		installDir,
+		detected,
+		installed: true,
+		installedVersion: manifest.nomaiVersion,
+		installedAt: manifest.installedAt,
+		modifiedFiles: modified,
+		missingFiles: missing
+	};
+}
+/** Overlay wins over shared on the same relPath. */
+function mergePayload(shared, overlay) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const file of shared) byPath.set(toPosix(file.relPath), file);
+	for (const file of overlay) byPath.set(toPosix(file.relPath), file);
+	return [...byPath.values()];
+}
+/**
+* Delete manifest-owned files. A file whose content no longer matches its
+* manifest hash was modified by the user — keep it unless force.
+* Missing files are treated as already removed.
+*/
+async function removeOwnedFiles(installDir, entries, force) {
+	const removed = [];
+	const kept = [];
+	for (const entry of entries) {
+		const target = path.join(installDir, entry.path);
+		let contents;
+		try {
+			contents = await readFile(target);
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		if (!force && hashBytes(contents) !== entry.sha256) {
+			kept.push(entry.path);
+			continue;
+		}
+		await rm(target, { force: true });
+		removed.push(entry.path);
+	}
+	return {
+		removed,
+		kept
+	};
+}
+/**
+* Remove directories left empty by deletions, walking up from each removed
+* file. Never removes the install dir itself — nomai never deletes .claude/.
+*/
+async function pruneEmptyDirs(installDir, removedPaths) {
+	const root = path.resolve(installDir);
+	const candidates = /* @__PURE__ */ new Set();
+	for (const relPath of removedPaths) {
+		let dir = path.dirname(path.resolve(installDir, relPath));
+		while (dir.startsWith(root) && dir !== root) {
+			candidates.add(dir);
+			dir = path.dirname(dir);
+		}
+	}
+	const ordered = [...candidates].sort((a, b) => b.length - a.length);
+	for (const dir of ordered) try {
+		if ((await readdir(dir)).length === 0) await rmdir(dir);
+	} catch {}
+}
+async function allFilesMatch(installDir, entries) {
+	for (const entry of entries) try {
+		if (hashBytes(await readFile(path.join(installDir, entry.path))) !== entry.sha256) return false;
+	} catch {
+		return false;
+	}
+	return true;
+}
+function sameEntries(a, b) {
+	if (a.length !== b.length) return false;
+	const sortedA = [...a].sort((x, y) => comparePaths(x.path, y.path));
+	const sortedB = [...b].sort((x, y) => comparePaths(x.path, y.path));
+	return sortedA.every((entry, i) => entry.path === sortedB[i].path && entry.sha256 === sortedB[i].sha256);
+}
+/** Codepoint sort: stable across machines/locales (localeCompare is not). */
+function comparePaths(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function toPosix(relPath) {
+	return relPath.split(path.sep).join("/");
+}
+//#endregion
+//#region src/harnesses/define.ts
+/**
+* Build a HarnessAdapter from declarative config. A typical adapter is:
+*
+*   export const claudeCode = defineHarness({
+*     id: "claude-code",
+*     displayName: "Claude Code",
+*     configDirName: ".claude",
+*   });
+*
+* Harnesses that need per-harness compilation override transformPayload;
+* harnesses with entirely custom mechanics (e.g. settings.json merges for
+* hooks) can override install/uninstall/status wholesale.
+*/
+function defineHarness(config) {
+	const adapter = {
+		id: config.id,
+		displayName: config.displayName,
+		configDirName: config.configDirName,
+		detectProject: config.detectProject ?? ((projectDir) => dirExists(path.join(projectDir, config.configDirName))),
+		detectGlobal: config.detectGlobal ?? ((homeDir) => dirExists(path.join(homeDir, config.configDirName))),
+		resolveInstallDir: config.resolveInstallDir ?? ((scope, ctx) => path.join(scope === "project" ? ctx.projectDir : ctx.homeDir, config.configDirName)),
+		transformPayload: config.transformPayload ?? (async (files) => files),
+		install: config.install ?? ((ctx) => installHarness(adapter, ctx)),
+		uninstall: config.uninstall ?? ((ctx) => uninstallHarness(adapter, ctx)),
+		status: config.status ?? ((ctx) => statusHarness(adapter, ctx))
+	};
+	return adapter;
+}
+async function dirExists(target) {
+	try {
+		return (await stat(target)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/harnesses/index.ts
+/**
+* Register new harnesses here. Adding one:
+*   1. Create src/harnesses/<name>.ts with defineHarness({...}).
+*   2. Add it to this array.
+*   3. Create payload/<name>/ for harness-specific payload files (optional).
+*/
+const harnesses = [defineHarness({
+	id: "claude-code",
+	displayName: "Claude Code",
+	configDirName: ".claude"
+})];
+//#endregion
+//#region src/core/registry.ts
+function listHarnesses() {
+	return [...harnesses];
+}
+function getHarness(id) {
+	const adapter = harnesses.find((harness) => harness.id === id);
+	if (!adapter) {
+		const valid = harnesses.map((harness) => harness.id).join(", ");
+		throw new Error(`Unknown harness "${id}". Valid harnesses: ${valid}`);
+	}
+	return adapter;
+}
+//#endregion
+//#region src/core/detect.ts
+/**
+* Ask every registered harness whether it is present at project and global
+* scope. The report preseeds the wizard's harness multiselect and drives
+* the defaults used by --yes.
+*/
+async function detectHarnesses(ctx) {
+	const results = await Promise.all(listHarnesses().map(async (adapter) => ({
+		harnessId: adapter.id,
+		project: await adapter.detectProject(ctx.projectDir),
+		global: await adapter.detectGlobal(ctx.homeDir)
+	})));
+	return {
+		results,
+		detectedIds: results.filter((r) => r.project || r.global).map((r) => r.harnessId),
+		projectDetectedIds: results.filter((r) => r.project).map((r) => r.harnessId)
+	};
+}
+//#endregion
+//#region src/core/payload.ts
+/**
+* Default payload source: the Nomai GitHub repo, fetched as a codeload
+* tarball of `main` at install time (same model as BuilderIO's
+* `npx @agent-native/skills`). The npm package itself ships no payload.
+*/
+const DEFAULT_SOURCE = "A-MCode/nomai-installer";
+/** Name of the payload directory inside the repo. */
+const PAYLOAD_DIR = "payload";
+/** Subdirectory holding the canonical payload shared by all harnesses. */
+const SHARED_DIR = "shared";
+/** Accepts "owner/repo", "owner/repo#ref", or a github.com URL (optionally /tree/<ref>). */
+function parseGitHubSource(input) {
+	const shorthand = input.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:#(.+))?$/);
+	if (shorthand) return {
+		owner: shorthand[1],
+		repo: shorthand[2].replace(/\.git$/, ""),
+		ref: shorthand[3]
+	};
+	let url;
+	try {
+		url = new URL(input);
+	} catch {
+		return null;
+	}
+	if (url.hostname !== "github.com") return null;
+	const parts = url.pathname.split("/").filter(Boolean);
+	const [owner, repo] = parts;
+	if (!owner || !repo) return null;
+	const treeIndex = parts.indexOf("tree");
+	return {
+		owner,
+		repo: repo.replace(/\.git$/, ""),
+		ref: treeIndex >= 0 && parts[treeIndex + 1] ? parts.slice(treeIndex + 1).join("/") : void 0
+	};
+}
+/**
+* Turn a --source value (or the default) into a live PayloadSource:
+* an existing local path wins, otherwise a GitHub download.
+*/
+async function resolvePayloadSource(input) {
+	const source = input ?? "A-MCode/nomai-installer";
+	const localRoot = path.resolve(source);
+	if (await exists(localRoot)) {
+		await assertPayloadRoot(localRoot, source);
+		return new DirectoryPayloadSource(source, localRoot);
+	}
+	const parsed = parseGitHubSource(source);
+	if (!parsed) throw new Error(`Payload source not found: ${source}. Use a local path, GitHub owner/repo[#ref], or GitHub URL.`);
+	return materializeGitHubSource(parsed);
+}
+async function materializeGitHubSource(ref) {
+	const gitRef = ref.ref ?? "main";
+	const description = `${ref.owner}/${ref.repo}#${gitRef}`;
+	const url = `https://codeload.github.com/${ref.owner}/${ref.repo}/tar.gz/${encodeURIComponent(gitRef)}`;
+	const tmpRoot = await mkdtemp(path.join(os.tmpdir(), "nomai-payload-"));
+	try {
+		const response = await fetch(url, { headers: { "user-agent": "nomai" } });
+		if (!response.ok) throw new Error(`Could not download ${description}: HTTP ${response.status}.`);
+		const archive = path.join(tmpRoot, "source.tgz");
+		await writeFile(archive, Buffer.from(await response.arrayBuffer()));
+		const extracted = spawnSync("tar", [
+			"-xzf",
+			archive,
+			"-C",
+			tmpRoot
+		], {
+			stdio: "pipe",
+			encoding: "utf8"
+		});
+		if (extracted.status !== 0) throw new Error(`Could not extract ${description}: ${extracted.stderr || extracted.stdout}`);
+		const repoDir = (await readdir(tmpRoot, { withFileTypes: true })).find((entry) => entry.isDirectory());
+		if (!repoDir) throw new Error(`Downloaded archive for ${description} did not contain a repo directory.`);
+		const root = path.join(tmpRoot, repoDir.name);
+		await assertPayloadRoot(root, description);
+		return new DirectoryPayloadSource(description, root, () => rm(tmpRoot, {
+			recursive: true,
+			force: true
+		}));
+	} catch (error) {
+		await rm(tmpRoot, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+/** Reads payload files from a repo checkout/extract on disk. */
+var DirectoryPayloadSource = class {
+	description;
+	rootDir;
+	cleanup;
+	constructor(description, rootDir, cleanup) {
+		this.description = description;
+		this.rootDir = rootDir;
+		this.cleanup = cleanup;
+	}
+	async readSharedFiles() {
+		return readTree(path.join(this.rootDir, PAYLOAD_DIR, SHARED_DIR));
+	}
+	async readHarnessOverlay(harnessId) {
+		if (harnessId === "shared") return [];
+		return readTree(path.join(this.rootDir, PAYLOAD_DIR, harnessId));
+	}
+	async dispose() {
+		await this.cleanup?.();
+	}
+};
+async function assertPayloadRoot(root, description) {
+	if (!await exists(path.join(root, "payload"))) throw new Error(`${description} does not contain a ${PAYLOAD_DIR}/ directory — not a Nomai payload source.`);
+}
+/** Recursively read a directory into PayloadFiles; missing dir → []. Skips .gitkeep placeholders. */
+async function readTree(dir, prefix = "") {
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const files = [];
+	for (const entry of entries) {
+		const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) files.push(...await readTree(path.join(dir, entry.name), relPath));
+		else if (entry.isFile() && entry.name !== ".gitkeep") files.push({
+			relPath,
+			contents: await readFile(path.join(dir, entry.name))
+		});
+	}
+	return files.sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0);
+}
+async function exists(target) {
+	try {
+		await stat(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { getHarness as a, installHarness as c, MANIFEST_FILENAME as d, readManifest as f, detectHarnesses as i, statusHarness as l, parseGitHubSource as n, listHarnesses as o, resolvePayloadSource as r, defineHarness as s, DEFAULT_SOURCE as t, uninstallHarness as u };

package/dist/rolldown-runtime-C7HZzL1F.mjs

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@nomai/nomai",
+  "version": "0.1.0",
+  "description": "Install Nomai skills, hooks, and commands into AI coding harnesses",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/A-MCode/nomai-installer.git"
+  },
+  "homepage": "https://github.com/A-MCode/nomai-installer#readme",
+  "bugs": {
+    "url": "https://github.com/A-MCode/nomai-installer/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "nomai": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@types/node": "^22.10.0",
+    "@vercel/detect-agent": "^1.2.3",
+    "commander": "^15.0.0",
+    "tsdown": "^0.22.4",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.0"
+  }
+}