@doki-land/nifty 0.0.0

package/src/config/detectProject.ts

@@ -0,0 +1,189 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export type ProjectKind = "cargo" | "npm" | "hybrid" | "unknown";
+
+/** Detected cargo + npm project layout. */
+export type ProjectLayout = {
+    /** Resolved project root (git root when present). */
+    root: string;
+    kind: ProjectKind;
+    /** Nearest `Cargo.toml` walking upward. */
+    cargoManifest?: string;
+    /** Nearest `package.json` walking upward (skips `node_modules`). */
+    packageManifest?: string;
+    /** Directory whose `Cargo.toml` declares a `[workspace]`. */
+    cargoWorkspaceRoot?: string;
+    /** Directory whose `package.json` declares npm `workspaces`. */
+    npmWorkspaceRoot?: string;
+};
+
+const CARGO_MANIFEST = "Cargo.toml";
+const PACKAGE_MANIFEST = "package.json";
+const GIT_DIR = ".git";
+
+function isInsideNodeModules(path: string): boolean {
+    return path.split(/[/\\]/).includes("node_modules");
+}
+
+function findFileUpward(cwd: string, fileName: string, skipNodeModules: boolean): string | undefined {
+    let here = resolve(cwd);
+    while (true) {
+        if (skipNodeModules && isInsideNodeModules(here)) {
+            const parent = dirname(here);
+            if (parent === here) {
+                return undefined;
+            }
+            here = parent;
+            continue;
+        }
+        const candidate = join(here, fileName);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(here);
+        if (parent === here) {
+            return undefined;
+        }
+        here = parent;
+    }
+}
+
+function findGitRoot(cwd: string): string | undefined {
+    let here = resolve(cwd);
+    while (true) {
+        if (existsSync(join(here, GIT_DIR))) {
+            return here;
+        }
+        const parent = dirname(here);
+        if (parent === here) {
+            return undefined;
+        }
+        here = parent;
+    }
+}
+
+function manifestHasCargoWorkspace(manifestPath: string): boolean {
+    try {
+        return readFileSync(manifestPath, "utf8")
+            .split(/\r?\n/)
+            .some((line) => line.trim() === "[workspace]");
+    } catch {
+        return false;
+    }
+}
+
+function manifestHasNpmWorkspaces(manifestPath: string): boolean {
+    try {
+        return readFileSync(manifestPath, "utf8").includes('"workspaces"');
+    } catch {
+        return false;
+    }
+}
+
+function findCargoWorkspaceRoot(manifestPath: string): string | undefined {
+    let here = dirname(resolve(manifestPath));
+    while (true) {
+        const candidate = join(here, CARGO_MANIFEST);
+        if (existsSync(candidate) && manifestHasCargoWorkspace(candidate)) {
+            return here;
+        }
+        const parent = dirname(here);
+        if (parent === here) {
+            return undefined;
+        }
+        here = parent;
+    }
+}
+
+function findNpmWorkspaceRoot(manifestPath: string): string | undefined {
+    let here = dirname(resolve(manifestPath));
+    while (true) {
+        const candidate = join(here, PACKAGE_MANIFEST);
+        if (existsSync(candidate) && manifestHasNpmWorkspaces(candidate)) {
+            return here;
+        }
+        const parent = dirname(here);
+        if (parent === here) {
+            return undefined;
+        }
+        here = parent;
+    }
+}
+
+function classifyProject(hasCargo: boolean, hasNpm: boolean): ProjectKind {
+    if (hasCargo && hasNpm) {
+        return "hybrid";
+    }
+    if (hasCargo) {
+        return "cargo";
+    }
+    if (hasNpm) {
+        return "npm";
+    }
+    return "unknown";
+}
+
+/** Walk upward and return the nearest `Cargo.toml`. */
+export function findCargoManifest(cwd = process.cwd()): string | undefined {
+    return findFileUpward(cwd, CARGO_MANIFEST, false);
+}
+
+/** Walk upward and return the nearest `package.json` (skips `node_modules`). */
+export function findPackageManifest(cwd = process.cwd()): string | undefined {
+    return findFileUpward(cwd, PACKAGE_MANIFEST, true);
+}
+
+/** Detect cargo/npm/hybrid layout from `cwd`. */
+export function detectProjectLayout(cwd = process.cwd()): ProjectLayout {
+    const start = resolve(cwd);
+    const cargoManifest = findCargoManifest(start);
+    const packageManifest = findPackageManifest(start);
+    const cargoWorkspaceRoot = cargoManifest ? findCargoWorkspaceRoot(cargoManifest) : undefined;
+    const npmWorkspaceRoot = packageManifest ? findNpmWorkspaceRoot(packageManifest) : undefined;
+    const kind = classifyProject(Boolean(cargoManifest), Boolean(packageManifest));
+    const root =
+        findGitRoot(start) ??
+        cargoWorkspaceRoot ??
+        npmWorkspaceRoot ??
+        (cargoManifest ? dirname(cargoManifest) : undefined) ??
+        (packageManifest ? dirname(packageManifest) : undefined) ??
+        start;
+
+    return {
+        root,
+        kind,
+        cargoManifest,
+        packageManifest,
+        cargoWorkspaceRoot,
+        npmWorkspaceRoot,
+    };
+}
+
+/** Discover npm package directories for hybrid monorepos. */
+export function discoverPackageDirs(layout: ProjectLayout): string[] {
+    const roots = new Set<string>();
+
+    if (layout.npmWorkspaceRoot) {
+        roots.add(layout.npmWorkspaceRoot);
+    }
+    if (layout.packageManifest) {
+        roots.add(dirname(layout.packageManifest));
+    }
+    if (layout.kind === "hybrid") {
+        const packagesDir = join(layout.root, "projects", "packages");
+        if (existsSync(packagesDir)) {
+            for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const packageJson = join(packagesDir, entry.name, "package.json");
+                if (existsSync(packageJson)) {
+                    roots.add(join(packagesDir, entry.name));
+                }
+            }
+        }
+    }
+
+    return [...roots];
+}

package/src/config/index.ts

@@ -0,0 +1,25 @@
+export { defineConfig } from "./defineConfig.js";
+export {
+    detectProjectLayout,
+    discoverPackageDirs,
+    findCargoManifest,
+    findPackageManifest,
+    type ProjectKind,
+    type ProjectLayout,
+} from "./detectProject.js";
+export {
+    authorMapToJson,
+    defaultConfigPath,
+    ensureConfigFile,
+    findConfigFile,
+    loadConfig,
+    type LoadConfigOptions,
+    type LoadedNiftyConfig,
+} from "./loadConfig.js";
+export {
+    CONFIG_FILE_NAMES,
+    type NiftyAuthorEntry,
+    type NiftyConfig,
+    type NiftyConfigEnv,
+    type NiftyConfigExport,
+} from "./types.js";

package/src/config/loadConfig.ts

@@ -0,0 +1,129 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createJiti } from "jiti";
+
+import type { NiftyConfig, NiftyConfigEnv, NiftyConfigExport } from "./types.js";
+import { CONFIG_FILE_NAMES } from "./types.js";
+import { detectProjectLayout } from "./detectProject.js";
+
+export type LoadConfigOptions = {
+    /** Directory to start searching from (defaults to `process.cwd()`). */
+    cwd?: string;
+    /** When set, skip searching and load this file directly. */
+    configFile?: string;
+    /** Passed to functional configs: `export default defineConfig(({ mode }) => ...)`. */
+    env?: Partial<NiftyConfigEnv>;
+    /**
+     * When true (default), write `nifty.config.ts` at the detected project root if missing.
+     * Set false for `--dry-run` so commands only report what would happen.
+     */
+    createIfMissing?: boolean;
+};
+
+export type LoadedNiftyConfig = {
+    config: NiftyConfig;
+    configFile?: string;
+    /** True when this run created a new config file. */
+    created?: boolean;
+};
+
+const DEFAULT_CONFIG_TEMPLATE = `// Nifty project configuration.
+// See @doki-land/nifty for defineConfig, githubToken, authorMap, and lint rules.
+export default {};
+`;
+
+const DEFAULT_ENV = (cwd: string): NiftyConfigEnv => ({
+    mode: process.env.NODE_ENV ?? "development",
+    command: "serve",
+    layout: detectProjectLayout(cwd),
+});
+
+/** Walk upward and return the nearest existing Nifty config file. */
+export function findConfigFile(cwd = process.cwd()): string | undefined {
+    let here = resolve(cwd);
+    while (true) {
+        for (const name of CONFIG_FILE_NAMES) {
+            const candidate = join(here, name);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        const parent = dirname(here);
+        if (parent === here) {
+            return undefined;
+        }
+        here = parent;
+    }
+}
+
+/** Default config path at the detected project root (prefers `nifty.config.ts`). */
+export function defaultConfigPath(cwd = process.cwd()): string {
+    const layout = detectProjectLayout(cwd);
+    return join(layout.root, CONFIG_FILE_NAMES[0]);
+}
+
+/** Warn and optionally create a default config when none exists. */
+export function ensureConfigFile(options: { cwd?: string; create?: boolean } = {}): string | undefined {
+    const cwd = options.cwd ?? process.cwd();
+    const existing = findConfigFile(cwd);
+    if (existing) {
+        return existing;
+    }
+
+    const target = defaultConfigPath(cwd);
+    if (options.create) {
+        writeFileSync(target, DEFAULT_CONFIG_TEMPLATE, "utf8");
+        console.warn(`nifty: no config found, created default ${target}`);
+        return target;
+    }
+
+    console.warn(`nifty: no nifty.config.* found near ${detectProjectLayout(cwd).root} (using defaults)`);
+    return undefined;
+}
+
+function normalizeExport(raw: unknown): NiftyConfigExport {
+    if (raw && typeof raw === "object" && "default" in raw) {
+        return (raw as { default: NiftyConfigExport }).default;
+    }
+    return raw as NiftyConfigExport;
+}
+
+async function resolveExport(exported: NiftyConfigExport, env: NiftyConfigEnv): Promise<NiftyConfig> {
+    if (typeof exported === "function") {
+        return await exported(env);
+    }
+    return exported;
+}
+
+/** Load `nifty.config.ts/js`, creating a default file at the project root when missing. */
+export async function loadConfig(options: LoadConfigOptions = {}): Promise<LoadedNiftyConfig> {
+    const cwd = options.cwd ?? process.cwd();
+    let configFile = options.configFile ?? findConfigFile(cwd);
+    let created = false;
+
+    if (!configFile && options.createIfMissing !== false) {
+        configFile = ensureConfigFile({ cwd, create: true });
+        created = Boolean(configFile);
+    } else if (!configFile) {
+        ensureConfigFile({ cwd, create: false });
+        return { config: {} };
+    }
+
+    if (!configFile) {
+        return { config: {} };
+    }
+
+    const env: NiftyConfigEnv = { ...DEFAULT_ENV(cwd), ...options.env };
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
+    const mod = await jiti.import(configFile);
+    const config = await resolveExport(normalizeExport(mod), env);
+    return { config, configFile, created };
+}
+
+/** Serialize `authorMap` for native helpers expecting JSON text. */
+export function authorMapToJson(authorMap: NiftyConfig["authorMap"]): string {
+    if (!authorMap || Object.keys(authorMap).length === 0) {
+        return "{}";
+    }
+    return JSON.stringify(authorMap);
+}

package/src/config/types.ts

@@ -0,0 +1,43 @@
+/** GitHub author entry in `authorMap` (same shape as `author-github.json`). */
+export type NiftyAuthorEntry = {
+    id?: number;
+    login?: string;
+};
+
+/** Nifty project configuration (`nifty.config.ts` / `nifty.config.js`). */
+export type NiftyConfig = {
+    /** GitHub personal access token for email search / profile fetch. */
+    githubToken?: string;
+    /** Email → GitHub author mapping. */
+    authorMap?: Record<string, NiftyAuthorEntry>;
+    /** Repository root override when discovering git metadata. */
+    repoRoot?: string;
+    /** Cargo workspace / crate root override. */
+    cargoRoot?: string;
+    /** npm package root override. */
+    npmRoot?: string;
+    /** Rule-based lint configuration. */
+    lint?: {
+        rules?: Array<{
+            id: string;
+            enabled?: boolean;
+            severity?: "error" | "warning" | "info";
+        }>;
+    };
+};
+
+export type NiftyConfigExport = NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>);
+
+export type NiftyConfigEnv = {
+    mode: string;
+    command: string;
+    /** Detected cargo + npm project layout for hybrid monorepos. */
+    layout: import("./detectProject.js").ProjectLayout;
+};
+
+export const CONFIG_FILE_NAMES = [
+    "nifty.config.ts",
+    "nifty.config.js",
+    "nifty.config.mjs",
+    "nifty.config.cjs",
+] as const;

package/src/git.ts

@@ -0,0 +1,61 @@
+import type { CommitRecord, RangeInfo, TagInfo } from "./types.js";
+import { loadNiftyNative, mapCommitRecord, mapRangeInfo, mapTagInfo, type GitExports } from "./native.js";
+
+export type ResolveRangeOptions = {
+    version?: string;
+    fromRef?: string;
+    toRef?: string;
+};
+
+/**
+ * Read-only git repository helpers (gix via Node-API, no `git` subprocess).
+ */
+export class Git {
+    constructor(private readonly wasm: GitExports) {}
+
+    static open(): Git {
+        const native = loadNiftyNative();
+        return new Git(native.git);
+    }
+
+    /** Walk upward from `startPath` to find the working tree root containing `.git`. */
+    discoverRoot(startPath: string): string {
+        return this.wasm["discover-root"](startPath);
+    }
+
+    /** List `v*` tags sorted by semver. */
+    listVersionTags(repoRoot: string): string[] {
+        return this.wasm["list-version-tags"](repoRoot);
+    }
+
+    listTagInfos(repoRoot: string): TagInfo[] {
+        return this.wasm["list-tag-infos"](repoRoot).map(mapTagInfo);
+    }
+
+    formatTagList(repoRoot: string): string {
+        return this.wasm["format-tag-list"](repoRoot);
+    }
+
+    resolveRange(repoRoot: string, options: ResolveRangeOptions = {}): RangeInfo {
+        return mapRangeInfo(
+            this.wasm["resolve-range"](repoRoot, options.version, options.fromRef, options.toRef),
+        );
+    }
+
+    /** Collect non-merge commits in `fromRef..toRef` (exclusive..inclusive). */
+    collectCommits(repoRoot: string, fromRef: string | undefined, toRef: string): CommitRecord[] {
+        return this.wasm["collect-commits"](repoRoot, fromRef, toRef).map(mapCommitRecord);
+    }
+
+    detectGithubRepo(repoRoot: string): string | undefined {
+        return this.wasm["detect-github-repo"](repoRoot);
+    }
+
+    parseGithubRemote(url: string): string | undefined {
+        return this.wasm["parse-github-remote"](url);
+    }
+}
+
+export function createGit(): Git {
+    return Git.open();
+}

package/src/github.ts

@@ -0,0 +1,184 @@
+import type { GithubAuthor } from "./types.js";
+
+const USER_AGENT = "nifty-github";
+const ACCEPT = "application/vnd.github+json";
+
+function parseUserJson(body: Record<string, unknown>, fallbackLogin?: string): GithubAuthor {
+    const id = typeof body.id === "number" ? BigInt(body.id) : undefined;
+    const login = typeof body.login === "string" ? body.login : fallbackLogin;
+    if (id === undefined && login === undefined) {
+        throw new Error("GitHub user response missing id and login");
+    }
+    return { id, login };
+}
+
+async function getJson(url: string, token?: string): Promise<Record<string, unknown>> {
+    const headers: Record<string, string> = {
+        Accept: ACCEPT,
+        "User-Agent": USER_AGENT,
+    };
+    if (token?.trim()) {
+        headers.Authorization = `Bearer ${token.trim()}`;
+    }
+    const response = await fetch(url, { headers });
+    if (response.status === 404) {
+        throw new Error("GitHub resource not found");
+    }
+    if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    return (await response.json()) as Record<string, unknown>;
+}
+
+function parseNoreplyEmail(email: string): GithubAuthor | undefined {
+    const trimmed = email.trim();
+    const suffix = "@users.noreply.github.com";
+    const lower = trimmed.toLowerCase();
+    if (!lower.endsWith(suffix)) {
+        return undefined;
+    }
+    const local = trimmed.slice(0, -suffix.length);
+    const plus = local.indexOf("+");
+    if (plus >= 0) {
+        const idPart = local.slice(0, plus);
+        const login = local.slice(plus + 1);
+        if (!login) {
+            return undefined;
+        }
+        return { id: BigInt(idPart), login };
+    }
+    if (!local) {
+        return undefined;
+    }
+    return { login: local };
+}
+
+function loadAuthorMap(json: string): Map<string, GithubAuthor> {
+    const map = new Map<string, GithubAuthor>();
+    if (!json.trim()) {
+        return map;
+    }
+    const parsed = JSON.parse(json) as Record<string, { id?: number; login?: string }>;
+    for (const [email, entry] of Object.entries(parsed)) {
+        const author: GithubAuthor = {};
+        if (typeof entry.id === "number") {
+            author.id = BigInt(entry.id);
+        }
+        if (typeof entry.login === "string" && entry.login.trim()) {
+            author.login = entry.login.trim();
+        }
+        if (author.id !== undefined || author.login !== undefined) {
+            map.set(email.trim().toLowerCase(), author);
+        }
+    }
+    return map;
+}
+
+function mergeAuthors(existing: GithubAuthor, incoming: GithubAuthor): GithubAuthor {
+    return {
+        id: existing.id ?? incoming.id,
+        login: existing.login ?? incoming.login,
+    };
+}
+
+async function enrichAuthor(author: GithubAuthor, token?: string, fetch = false): Promise<GithubAuthor> {
+    if (!fetch && author.id !== undefined && author.login !== undefined) {
+        return author;
+    }
+    if (!fetch && author.id !== undefined) {
+        return author;
+    }
+    if (author.login && (author.id === undefined || fetch)) {
+        const fetched = await userByLoginFetch(author.login, token);
+        return mergeAuthors(author, fetched);
+    }
+    return author;
+}
+
+async function userByLoginFetch(login: string, token?: string): Promise<GithubAuthor> {
+    const trimmed = login.trim();
+    if (!trimmed) {
+        throw new Error("login must not be empty");
+    }
+    const body = await getJson(`https://api.github.com/users/${trimmed}`, token);
+    return parseUserJson(body, trimmed);
+}
+
+async function searchUserByEmailFetch(email: string, token: string): Promise<GithubAuthor | undefined> {
+    const trimmed = email.trim();
+    const auth = token.trim();
+    if (!trimmed) {
+        throw new Error("email must not be empty");
+    }
+    if (!auth) {
+        throw new Error("GitHub token is required for email search");
+    }
+    const query = encodeURIComponent(`${trimmed} in:email`);
+    const body = await getJson(`https://api.github.com/search/users?q=${query}`, auth);
+    const items = body.items;
+    if (!Array.isArray(items) || items.length === 0) {
+        return undefined;
+    }
+    const first = items[0] as Record<string, unknown>;
+    return parseUserJson(first);
+}
+
+export type LookupUserOptions = {
+    authorMapJson?: string;
+    token?: string;
+    fetch?: boolean;
+};
+
+/**
+ * GitHub REST helpers via host `fetch` (Node 18+, browsers with CORS).
+ * Rust equivalent: `nifty-github` crate.
+ */
+export class Github {
+    constructor(private readonly token?: string) {}
+
+    static open(token?: string): Github {
+        return new Github(token);
+    }
+
+    async userByLogin(login: string, token?: string): Promise<GithubAuthor> {
+        return userByLoginFetch(login, token ?? this.token);
+    }
+
+    async searchUserByEmail(email: string, token?: string): Promise<GithubAuthor | undefined> {
+        const auth = token ?? this.token;
+        if (!auth) {
+            throw new Error("GitHub token is required for email search");
+        }
+        return searchUserByEmailFetch(email, auth);
+    }
+
+    async lookupUserByEmail(email: string, options: LookupUserOptions = {}): Promise<GithubAuthor | undefined> {
+        const token = options.token ?? this.token;
+        const fetch = options.fetch ?? false;
+        const mapJson = options.authorMapJson ?? "{}";
+
+        const fromNoreply = parseNoreplyEmail(email);
+        if (fromNoreply) {
+            return enrichAuthor(fromNoreply, token, fetch);
+        }
+
+        const map = loadAuthorMap(mapJson);
+        const mapped = map.get(email.trim().toLowerCase());
+        if (mapped) {
+            return enrichAuthor(mapped, token, fetch);
+        }
+
+        if (token) {
+            const found = await searchUserByEmailFetch(email, token);
+            if (found) {
+                return enrichAuthor(found, token, fetch);
+            }
+        }
+
+        return undefined;
+    }
+}
+
+export function createGithub(token?: string): Github {
+    return Github.open(token);
+}