@rainy-updates/cli 0.4.0

package/dist/workspace/discover.js

@@ -0,0 +1,88 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function discoverPackageDirs(cwd, workspaceMode) {
+    if (!workspaceMode) {
+        return [cwd];
+    }
+    const roots = new Set([cwd]);
+    const packagePatterns = await readPackageJsonWorkspacePatterns(cwd);
+    const pnpmPatterns = await readPnpmWorkspacePatterns(cwd);
+    for (const pattern of [...packagePatterns, ...pnpmPatterns]) {
+        const dirs = await expandSingleLevelPattern(cwd, pattern);
+        for (const dir of dirs) {
+            roots.add(dir);
+        }
+    }
+    const existing = [];
+    for (const dir of roots) {
+        const packageJsonPath = path.join(dir, "package.json");
+        try {
+            await fs.access(packageJsonPath);
+            existing.push(dir);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return existing.sort();
+}
+async function readPackageJsonWorkspacePatterns(cwd) {
+    const packagePath = path.join(cwd, "package.json");
+    try {
+        const content = await fs.readFile(packagePath, "utf8");
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed.workspaces)) {
+            return parsed.workspaces;
+        }
+        if (parsed.workspaces && Array.isArray(parsed.workspaces.packages)) {
+            return parsed.workspaces.packages;
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+async function readPnpmWorkspacePatterns(cwd) {
+    const workspacePath = path.join(cwd, "pnpm-workspace.yaml");
+    try {
+        const content = await fs.readFile(workspacePath, "utf8");
+        const lines = content.split(/\r?\n/);
+        const patterns = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("-"))
+                continue;
+            const value = trimmed.replace(/^-\s*/, "").replace(/^['\"]|['\"]$/g, "");
+            if (value.length > 0) {
+                patterns.push(value);
+            }
+        }
+        return patterns;
+    }
+    catch {
+        return [];
+    }
+}
+async function expandSingleLevelPattern(cwd, pattern) {
+    if (!pattern.includes("*")) {
+        return [path.resolve(cwd, pattern)];
+    }
+    const normalized = pattern.replace(/\\/g, "/");
+    const starIndex = normalized.indexOf("*");
+    const basePart = normalized.slice(0, starIndex).replace(/\/$/, "");
+    const suffix = normalized.slice(starIndex + 1);
+    if (suffix.length > 0 && suffix !== "/") {
+        return [];
+    }
+    const baseDir = path.resolve(cwd, basePart);
+    try {
+        const entries = await fs.readdir(baseDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(baseDir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/workspace/graph.d.ts

@@ -0,0 +1,13 @@
+import type { DependencyKind, PackageManifest } from "../types/index.js";
+export interface WorkspaceNode {
+    packagePath: string;
+    packageName: string;
+    dependsOn: string[];
+}
+export interface WorkspaceGraphResult {
+    nodes: WorkspaceNode[];
+    orderedPaths: string[];
+    localPackageNames: Set<string>;
+    cycles: string[][];
+}
+export declare function buildWorkspaceGraph(manifestsByPath: Map<string, PackageManifest>, includeKinds: DependencyKind[]): WorkspaceGraphResult;

package/dist/workspace/graph.js

@@ -0,0 +1,86 @@
+export function buildWorkspaceGraph(manifestsByPath, includeKinds) {
+    const nodes = [];
+    const localPackageNames = new Set();
+    for (const manifest of manifestsByPath.values()) {
+        if (typeof manifest.name === "string" && manifest.name.length > 0) {
+            localPackageNames.add(manifest.name);
+        }
+    }
+    for (const [packagePath, manifest] of manifestsByPath) {
+        const packageName = typeof manifest.name === "string" ? manifest.name : packagePath;
+        const dependsOn = new Set();
+        for (const kind of includeKinds) {
+            const section = manifest[kind];
+            if (!section)
+                continue;
+            for (const [depName, depRange] of Object.entries(section)) {
+                if (!localPackageNames.has(depName))
+                    continue;
+                if (depRange.startsWith("workspace:"))
+                    continue;
+                dependsOn.add(depName);
+            }
+        }
+        nodes.push({
+            packagePath,
+            packageName,
+            dependsOn: Array.from(dependsOn),
+        });
+    }
+    const byName = new Map(nodes.map((node) => [node.packageName, node]));
+    const inDegree = new Map();
+    const edges = new Map();
+    for (const node of nodes) {
+        inDegree.set(node.packageName, 0);
+        edges.set(node.packageName, []);
+    }
+    for (const node of nodes) {
+        for (const dep of node.dependsOn) {
+            if (!byName.has(dep))
+                continue;
+            const list = edges.get(dep);
+            if (list)
+                list.push(node.packageName);
+            inDegree.set(node.packageName, (inDegree.get(node.packageName) ?? 0) + 1);
+        }
+    }
+    const queue = [];
+    for (const [name, degree] of inDegree) {
+        if (degree === 0)
+            queue.push(name);
+    }
+    const orderedNames = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        orderedNames.push(current);
+        for (const next of edges.get(current) ?? []) {
+            const degree = (inDegree.get(next) ?? 0) - 1;
+            inDegree.set(next, degree);
+            if (degree === 0)
+                queue.push(next);
+        }
+    }
+    const cycles = [];
+    if (orderedNames.length !== nodes.length) {
+        const remaining = nodes
+            .map((node) => node.packageName)
+            .filter((name) => !orderedNames.includes(name));
+        if (remaining.length > 0)
+            cycles.push(remaining);
+    }
+    const orderedPaths = orderedNames
+        .map((name) => byName.get(name))
+        .filter((node) => Boolean(node))
+        .map((node) => node.packagePath);
+    for (const node of nodes) {
+        if (!orderedPaths.includes(node.packagePath)) {
+            orderedPaths.push(node.packagePath);
+        }
+    }
+    return {
+        nodes,
+        orderedPaths,
+        localPackageNames,
+        cycles,
+    };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@rainy-updates/cli",
+  "version": "0.4.0",
+  "description": "Agentic CLI to check and upgrade npm/pnpm dependencies for CI workflows",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ferxalbs/rainy-updates.git"
+  },
+  "homepage": "https://github.com/ferxalbs/rainy-updates#readme",
+  "bugs": {
+    "url": "https://github.com/ferxalbs/rainy-updates/issues"
+  },
+  "keywords": [
+    "dependencies",
+    "updates",
+    "cli",
+    "ci",
+    "npm",
+    "pnpm",
+    "monorepo"
+  ],
+  "bin": {
+    "rainy-updates": "./dist/bin/cli.js"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "bunx biome check src tests",
+    "check": "bun run typecheck && bun test",
+    "test:prod": "node dist/bin/cli.js --help && node dist/bin/cli.js --version",
+    "prepublishOnly": "bun run check && bun run build && bun run test:prod"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9.3"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.6.2",
+    "undici": "^7.22.0"
+  }
+}