@doki-land/nifty 0.0.0

package/src/cli/trust.ts

@@ -0,0 +1,77 @@
+import { loadNiftyNative } from "../native.js";
+import { authPayload, parseAuthArgs } from "./authArgs.js";
+
+export type TrustReport = {
+    root: string;
+    configured: string[];
+    skipped: string[];
+    failed: string[];
+};
+
+export async function runTrust(argv: string[]): Promise<void> {
+    const options = parseTrustArgs(argv);
+    const native = loadNiftyNative();
+    const report = native.publisher["trust-workspace"]({
+        cwd: options.cwd,
+        dryRun: options.dryRun,
+        only: options.only,
+        ...authPayload(options.auth),
+    });
+    printReport(report);
+}
+
+function parseTrustArgs(argv: string[]) {
+    let cwd: string | undefined;
+    let dryRun = false;
+    let only: string | undefined;
+    const auth = parseAuthArgs(argv);
+
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run") {
+            dryRun = true;
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
+        } else if (arg === "--only") {
+            only = argv[++i];
+        } else if (arg === "-h" || arg === "--help") {
+            printTrustHelp();
+            process.exit(0);
+        }
+    }
+
+    return { cwd, dryRun, only, auth };
+}
+
+function printReport(report: TrustReport): void {
+    console.log(`trust workspace ${report.root}`);
+    console.log(`  configured: ${report.configured.length}`);
+    for (const name of report.configured) {
+        console.log(`    + ${name}`);
+    }
+    console.log(`  skipped: ${report.skipped.length}`);
+    for (const name of report.skipped) {
+        console.log(`    = ${name}`);
+    }
+    if (report.failed.length > 0) {
+        console.log(`  failed: ${report.failed.length}`);
+        for (const name of report.failed) {
+            console.log(`    ! ${name}`);
+        }
+    }
+}
+
+function printTrustHelp(): void {
+    console.log(`nifty trust — configure npm Trusted Publisher for workspace packages
+
+Reads NPM_TOTP_SECRET / NPM_OTP / NPM_TOKEN from env or .env.placeholder.local.
+
+Usage:
+  nifty trust
+  nifty trust --only @doki-land/nifty
+  nifty trust --dry-run
+  nifty trust --totp-secret <base32>
+  nifty trust --otp 123456
+  nifty trust -C <cwd>
+`);
+}

package/src/cli/update.ts

@@ -0,0 +1,182 @@
+import { spawnSync } from "node:child_process";
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { dirname } from "node:path";
+
+import { detectProjectLayout, discoverPackageDirs } from "../config/detectProject.js";
+
+type UpdateOptions = {
+    interactive: boolean;
+    cwd?: string;
+};
+
+type CargoUpgrade = {
+    crate: string;
+    from: string;
+    to: string;
+};
+
+type NpmOutdated = {
+    name: string;
+    current: string;
+    wanted: string;
+    latest: string;
+};
+
+export async function runUpdate(argv: string[]): Promise<void> {
+    const options = parseUpdateArgs(argv);
+    const cwd = options.cwd ?? process.cwd();
+    const layout = detectProjectLayout(cwd);
+
+    if (layout.kind === "unknown") {
+        throw new Error(`no Cargo.toml or package.json found from ${cwd}`);
+    }
+
+    if (layout.kind === "cargo" || layout.kind === "hybrid") {
+        await updateCargo(layout, options.interactive);
+    }
+    if (layout.kind === "npm" || layout.kind === "hybrid") {
+        await updateNpm(layout, options.interactive);
+    }
+}
+
+function parseUpdateArgs(argv: string[]): UpdateOptions {
+    let interactive = false;
+    let cwd: string | undefined;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "-i" || arg === "--interactive") {
+            interactive = true;
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
+        }
+    }
+    return { interactive, cwd };
+}
+
+function cargoRoot(layout: ReturnType<typeof detectProjectLayout>): string | undefined {
+    return (
+        layout.cargoWorkspaceRoot ??
+        (layout.cargoManifest ? dirname(layout.cargoManifest) : undefined)
+    );
+}
+
+async function updateCargo(layout: ReturnType<typeof detectProjectLayout>, interactive: boolean): Promise<void> {
+    const root = cargoRoot(layout);
+    if (!root) {
+        throw new Error("cargo project not found");
+    }
+
+    const dry = spawnSync("cargo", ["upgrade", "--workspace", "--dry-run"], {
+        cwd: root,
+        encoding: "utf8",
+    });
+    const combined = `${dry.stdout ?? ""}${dry.stderr ?? ""}`;
+    const upgrades = parseCargoUpgrades(combined);
+    if (dry.status !== 0 && !combined.includes("no upgrades found") && upgrades.length === 0) {
+        throw new Error(`cargo upgrade --dry-run failed:\n${combined}`);
+    }
+
+    if (upgrades.length === 0) {
+        console.log("cargo: dependencies already up to date");
+        return;
+    }
+
+    if (interactive) {
+        const selected = await pickItems(
+            "Select cargo upgrades",
+            upgrades.map((item) => `${item.crate} ${item.from} -> ${item.to}`),
+        );
+        for (const index of selected) {
+            const item = upgrades[index];
+            run("cargo", ["upgrade", "--workspace", "-p", item.crate], root);
+        }
+    } else {
+        run("cargo", ["upgrade", "--workspace"], root);
+    }
+}
+
+async function updateNpm(layout: ReturnType<typeof detectProjectLayout>, interactive: boolean): Promise<void> {
+    const packages = discoverPackageDirs(layout);
+    if (packages.length === 0) {
+        console.log("npm: no package.json directories found");
+        return;
+    }
+    for (const packageDir of packages) {
+        await updateNpmDir(packageDir, interactive);
+    }
+}
+
+async function updateNpmDir(packageDir: string, interactive: boolean): Promise<void> {
+    const outdated = listNpmOutdated(packageDir);
+    if (outdated.length === 0) {
+        console.log(`npm (${packageDir}): dependencies already up to date`);
+        return;
+    }
+
+    if (interactive) {
+        const selected = await pickItems(
+            `Select npm upgrades (${packageDir})`,
+            outdated.map((item) => `${item.name} ${item.current} -> ${item.wanted}`),
+        );
+        for (const index of selected) {
+            const item = outdated[index];
+            run("npm", ["install", `${item.name}@${item.wanted}`], packageDir);
+        }
+    } else {
+        run("npm", ["update"], packageDir);
+    }
+}
+
+function parseCargoUpgrades(text: string): CargoUpgrade[] {
+    const upgrades: CargoUpgrade[] = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/^\s*(\S+)\s+v(\S+)\s+->\s+v(\S+)/);
+        if (match) {
+            upgrades.push({ crate: match[1], from: match[2], to: match[3] });
+        }
+    }
+    return upgrades;
+}
+
+function listNpmOutdated(packageDir: string): NpmOutdated[] {
+    const result = spawnSync("npm", ["outdated", "--json"], { cwd: packageDir, encoding: "utf8" });
+    if (!result.stdout?.trim()) {
+        return [];
+    }
+    const parsed = JSON.parse(result.stdout) as Record<
+        string,
+        { current: string; wanted: string; latest: string }
+    >;
+    return Object.entries(parsed).map(([name, entry]) => ({
+        name,
+        current: entry.current,
+        wanted: entry.wanted,
+        latest: entry.latest,
+    }));
+}
+
+async function pickItems(prompt: string, labels: string[]): Promise<number[]> {
+    console.log(prompt);
+    for (const [index, label] of labels.entries()) {
+        console.log(`  [${index}] ${label}`);
+    }
+    const rl = createInterface({ input, output });
+    const answer = await rl.question("Indexes (comma-separated, empty = all): ");
+    rl.close();
+    const trimmed = answer.trim();
+    if (!trimmed) {
+        return labels.map((_, index) => index);
+    }
+    return trimmed
+        .split(",")
+        .map((part) => Number.parseInt(part.trim(), 10))
+        .filter((index) => Number.isInteger(index) && index >= 0 && index < labels.length);
+}
+
+function run(command: string, args: string[], cwd: string): void {
+    const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`${command} ${args.join(" ")} failed`);
+    }
+}

package/src/cli/upload.ts

@@ -0,0 +1,280 @@
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdtempSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, relative, resolve } from "node:path";
+
+import { detectProjectLayout } from "../config/detectProject.js";
+import { loadNiftyNative } from "../native.js";
+
+const USER_AGENT = "nifty-upload";
+
+type UploadOptions = {
+    release: boolean;
+    pages: boolean;
+    both: boolean;
+    dir: string;
+    tag?: string;
+    repo?: string;
+    token?: string;
+    name?: string;
+    notes?: string;
+    notesFile?: string;
+    draft: boolean;
+    generateNotes: boolean;
+    githubAction: boolean;
+    cwd?: string;
+};
+
+type GithubRelease = {
+    id: number;
+};
+
+export async function runUpload(argv: string[]): Promise<void> {
+    const options = parseUploadArgs(argv);
+    if (options.githubAction) {
+        applyGithubActionDefaults(options);
+    }
+
+    const token = options.token ?? process.env.GITHUB_TOKEN;
+    if (!token) {
+        throw new Error("GitHub token is required (set --token or GITHUB_TOKEN)");
+    }
+
+    const cwd = options.cwd ?? process.cwd();
+    const layout = detectProjectLayout(cwd);
+    const native = loadNiftyNative();
+    const repo =
+        options.repo ??
+        native.git["detect-github-repo"](layout.root) ??
+        process.env.GITHUB_REPOSITORY;
+    if (!repo) {
+        throw new Error("could not detect GitHub repo (use --repo owner/name)");
+    }
+
+    const tag = options.tag ?? process.env.GITHUB_REF_NAME;
+    if (!tag) {
+        throw new Error("release tag is required (use --tag or push a git tag)");
+    }
+
+    const target = parseTarget(options);
+    const notes = await resolveNotes(options, layout.root, tag, native);
+
+    if (target === "release" || target === "both") {
+        await uploadReleaseAssets(repo, token, tag, options, notes);
+    }
+    if (target === "pages" || target === "both") {
+        await deployGithubPages(repo, token, options.dir);
+    }
+}
+
+function parseUploadArgs(argv: string[]): UploadOptions {
+    const options: UploadOptions = {
+        release: false,
+        pages: false,
+        both: false,
+        dir: "dist",
+        draft: false,
+        generateNotes: true,
+        githubAction: false,
+    };
+
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--release") options.release = true;
+        else if (arg === "--pages") options.pages = true;
+        else if (arg === "--both") options.both = true;
+        else if (arg === "-d" || arg === "--dir") options.dir = argv[++i];
+        else if (arg === "-t" || arg === "--tag") options.tag = argv[++i];
+        else if (arg === "--repo") options.repo = argv[++i];
+        else if (arg === "--token") options.token = argv[++i];
+        else if (arg === "--name") options.name = argv[++i];
+        else if (arg === "--notes") options.notes = argv[++i];
+        else if (arg === "--notes-file") options.notesFile = argv[++i];
+        else if (arg === "--draft") options.draft = true;
+        else if (arg === "--no-generate-notes") options.generateNotes = false;
+        else if (arg === "--github-action") options.githubAction = true;
+        else if (arg === "-C" || arg === "--cwd") options.cwd = argv[++i];
+    }
+
+    return options;
+}
+
+function parseTarget(options: UploadOptions): "release" | "pages" | "both" {
+    if (options.both) return "both";
+    if (options.pages) return "pages";
+    if (options.release) return "release";
+    throw new Error("specify --release, --pages, or --both");
+}
+
+function applyGithubActionDefaults(options: UploadOptions): void {
+    options.token ??= process.env.GITHUB_TOKEN;
+    options.repo ??= process.env.GITHUB_REPOSITORY;
+    options.tag ??= process.env.GITHUB_REF_NAME;
+    options.cwd ??= process.env.GITHUB_WORKSPACE;
+}
+
+async function resolveNotes(
+    options: UploadOptions,
+    repoRoot: string,
+    tag: string,
+    native: ReturnType<typeof loadNiftyNative>,
+): Promise<string> {
+    if (options.notes) return options.notes;
+    if (options.notesFile) return readFileSync(options.notesFile, "utf8");
+    if (!options.generateNotes) return "";
+    try {
+        const range = native.git["resolve-range"](repoRoot, tag.replace(/^v/, ""), undefined, tag);
+        const commits = native.git["collect-commits"](repoRoot, range.fromRef, range.toRef);
+        return commits.map((commit) => `- ${commit.body}`).join("\n");
+    } catch {
+        return "";
+    }
+}
+
+async function uploadReleaseAssets(
+    repo: string,
+    token: string,
+    tag: string,
+    options: UploadOptions,
+    notes: string,
+): Promise<void> {
+    const [owner, name] = splitRepo(repo);
+    let release = await apiReleaseByTag(owner, name, tag, token);
+    if (!release) {
+        release = await apiCreateRelease(owner, name, tag, options.name ?? tag, notes, options.draft, token);
+    }
+    const dir = resolve(options.cwd ?? process.cwd(), options.dir);
+    for (const file of collectFiles(dir)) {
+        const asset = relative(dir, file).split(/[/\\]/).join("-") || basename(file);
+        await apiUploadAsset(owner, name, release.id, asset, file, token);
+        console.log(`release: uploaded ${asset}`);
+    }
+}
+
+async function deployGithubPages(repo: string, token: string, dir: string): Promise<void> {
+    const [owner, name] = splitRepo(repo);
+    const source = resolve(dir);
+    const work = mkdtempSync(join(tmpdir(), "nifty-pages-"));
+    cpSync(source, work, { recursive: true });
+    const nojekyll = join(work, ".nojekyll");
+    if (!existsSync(nojekyll)) {
+        writeFileSync(nojekyll, "");
+    }
+    git(work, ["init"]);
+    git(work, ["config", "user.name", "github-actions[bot]"]);
+    git(work, ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"]);
+    git(work, ["add", "."]);
+    git(work, ["commit", "-m", "Deploy GitHub Pages"]);
+    const remote = `https://x-access-token:${token}@github.com/${owner}/${name}.git`;
+    git(work, ["remote", "add", "origin", remote]);
+    git(work, ["push", "--force", "origin", "HEAD:gh-pages"]);
+    console.log(`pages: pushed ${source} to gh-pages`);
+}
+
+function collectFiles(dir: string): string[] {
+    const out: string[] = [];
+    for (const entry of walk(dir)) {
+        if (statSync(entry).isFile()) {
+            out.push(entry);
+        }
+    }
+    return out;
+}
+
+function walk(dir: string): string[] {
+    const files: string[] = [];
+    for (const entry of readdirSync(dir)) {
+        const path = join(dir, entry);
+        if (statSync(path).isDirectory()) {
+            files.push(...walk(path));
+        } else {
+            files.push(path);
+        }
+    }
+    return files;
+}
+
+function splitRepo(repo: string): [string, string] {
+    const parts = repo.split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error(`invalid repo ${repo}, expected owner/name`);
+    }
+    return [parts[0], parts[1]];
+}
+
+async function apiReleaseByTag(
+    owner: string,
+    name: string,
+    tag: string,
+    token: string,
+): Promise<GithubRelease | null> {
+    const response = await fetch(
+        `https://api.github.com/repos/${owner}/${name}/releases/tags/${encodeURIComponent(tag)}`,
+        { headers: githubHeaders(token) },
+    );
+    if (response.status === 404) return null;
+    if (!response.ok) {
+        throw new Error(`GitHub API ${response.status}: ${await response.text()}`);
+    }
+    return (await response.json()) as GithubRelease;
+}
+
+async function apiCreateRelease(
+    owner: string,
+    name: string,
+    tag: string,
+    title: string,
+    body: string,
+    draft: boolean,
+    token: string,
+): Promise<GithubRelease> {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${name}/releases`, {
+        method: "POST",
+        headers: { ...githubHeaders(token), "Content-Type": "application/json" },
+        body: JSON.stringify({ tag_name: tag, name: title, body, draft }),
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub API ${response.status}: ${await response.text()}`);
+    }
+    return (await response.json()) as GithubRelease;
+}
+
+async function apiUploadAsset(
+    owner: string,
+    name: string,
+    releaseId: number,
+    assetName: string,
+    filePath: string,
+    token: string,
+): Promise<void> {
+    const url = `https://uploads.github.com/repos/${owner}/${name}/releases/${releaseId}/assets?name=${encodeURIComponent(assetName)}`;
+    const body = readFileSync(filePath);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...githubHeaders(token),
+            "Content-Type": "application/octet-stream",
+            "Content-Length": String(body.length),
+        },
+        body,
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub upload ${response.status}: ${await response.text()}`);
+    }
+}
+
+function githubHeaders(token: string): Record<string, string> {
+    return {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "User-Agent": USER_AGENT,
+        "X-GitHub-Api-Version": "2022-11-28",
+    };
+}
+
+function git(cwd: string, args: string[]): void {
+    const result = spawnSync("git", args, { cwd, stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`git ${args.join(" ")} failed`);
+    }
+}

package/src/cli/workspace.ts

@@ -0,0 +1,124 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { detectProjectLayout } from "../config/detectProject.js";
+
+export type WorkspacePackage = {
+    name: string;
+    version: string;
+    dir: string;
+    manifestPath: string;
+    private: boolean;
+    manifest: PackageManifest;
+};
+
+export type PackageManifest = {
+    name: string;
+    version: string;
+    private?: boolean;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+};
+
+const DEPENDENCY_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+] as const;
+
+export function findWorkspaceRoot(cwd: string): string {
+    const layout = detectProjectLayout(cwd);
+    const candidates = [layout.root, resolve(cwd)];
+    for (const candidate of candidates) {
+        const crates = join(candidate, "projects", "crates");
+        const packages = join(candidate, "projects", "packages");
+        if (existsSync(crates) && existsSync(packages)) {
+            return candidate;
+        }
+    }
+    throw new Error("could not find Nifty workspace (expected projects/crates and projects/packages)");
+}
+
+export function listWorkspacePackages(root: string): WorkspacePackage[] {
+    const packagesDir = join(root, "projects", "packages");
+    if (!existsSync(packagesDir)) {
+        return [];
+    }
+
+    const packages: WorkspacePackage[] = [];
+    for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name === "node_modules") {
+            continue;
+        }
+        const manifestPath = join(packagesDir, entry.name, "package.json");
+        if (!existsSync(manifestPath)) {
+            continue;
+        }
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as PackageManifest;
+        if (!manifest.name || !manifest.version) {
+            throw new Error(`package.json missing name or version: ${manifestPath}`);
+        }
+        packages.push({
+            name: manifest.name,
+            version: manifest.version,
+            dir: join(packagesDir, entry.name),
+            manifestPath,
+            private: manifest.private === true,
+            manifest,
+        });
+    }
+
+    return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function collectInternalDependencyNames(
+    pkg: WorkspacePackage,
+    byName: Map<string, WorkspacePackage>,
+): Set<string> {
+    const deps = new Set<string>();
+    for (const field of DEPENDENCY_FIELDS) {
+        const entries = pkg.manifest[field];
+        if (!entries) {
+            continue;
+        }
+        for (const [depName, spec] of Object.entries(entries)) {
+            if (byName.has(depName)) {
+                deps.add(depName);
+                continue;
+            }
+            const resolved = resolveWorkspaceDependencyName(spec, pkg.dir, byName);
+            if (resolved) {
+                deps.add(resolved);
+            }
+        }
+    }
+    return deps;
+}
+
+function resolveWorkspaceDependencyName(
+    spec: string,
+    packageDir: string,
+    byName: Map<string, WorkspacePackage>,
+): string | undefined {
+    if (spec.startsWith("workspace:")) {
+        return undefined;
+    }
+    if (!spec.startsWith("file:")) {
+        return undefined;
+    }
+    const targetDir = resolve(packageDir, spec.slice("file:".length));
+    for (const candidate of byName.values()) {
+        if (candidate.dir === targetDir) {
+            return candidate.name;
+        }
+    }
+    const manifestPath = join(targetDir, "package.json");
+    if (!existsSync(manifestPath)) {
+        return undefined;
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as PackageManifest;
+    return manifest.name;
+}

package/src/config/defineConfig.ts

@@ -0,0 +1,12 @@
+import type { NiftyConfig, NiftyConfigEnv } from "./types.js";
+
+/** Type-safe helper for `nifty.config.ts` / `nifty.config.js`. */
+export function defineConfig(config: NiftyConfig): NiftyConfig;
+export function defineConfig(
+    config: (env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>,
+): (env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>;
+export function defineConfig(
+    config: NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>),
+): NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>) {
+    return config;
+}