@mxpicture/gcp-functions-code 0.2.0 → 0.2.2

package/dist/changelog/ChangeDetector.d.ts

@@ -1,7 +1,7 @@
 import { DocumentData } from "@mxpicture/gcp-functions-common/types";
 import { GitChangesCommit } from "../git/GitChanges.js";
 import { Changelog } from "./Changelog.js";
-import { PackageVersion } from "./changelog.util.js";
+import { PackageVersion } from "../common/code.common.js";
 export declare enum ChangeWatchType {
     changelog = "changelog",
     gitHistory = "gitHistory"

package/dist/changelog/Changelog.d.ts

@@ -1,10 +1,8 @@
 import { GitChanges } from "../git/GitChanges.js";
-import { ChangelogEntry, PackageVersion } from "./changelog.util.js";
+import { ChangelogEntry } from "./changelog.util.js";
+import { PackageVersion } from "../common/code.common.js";
 export declare class Changelog {
     protected readonly git: GitChanges;
-    protected readonly changelogPath: string;
-    protected readonly packageJsonPath: string;
-    protected readonly rootDir: string;
     constructor(git: GitChanges);
     run(): Promise<ChangelogEntry | null>;
     readChangelogEntries(sinceVersion?: PackageVersion): Promise<ChangelogEntry[]>;

package/dist/changelog/Changelog.js

@@ -1,35 +1,28 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { changelogEntriesSchema, changelogEntrySchema, resolveBaselineCommit, readChangedTsFiles, mapChangedPackages, mapAffectedPackages, readMinPackageVersion, splitVersion, compareVersionsGT, } from "./changelog.util.js";
+import { changelogEntriesSchema, changelogEntrySchema, readChangedTsFiles, mapChangedPackages, mapAffectedPackages, resolveBaselineCommit, } from "./changelog.util.js";
 import pkg from "json5";
-import { fileURLToPath } from "node:url";
 import { lastCommitHash } from "../git/git.util.js";
-import { formatJson2Spaces } from "../common/code.common.js";
+import { compareVersionsGT, formatJson2Spaces, splitVersion, } from "../common/code.common.js";
+import { readMinPackageVersion } from "../vscode/workspaceAsync.vscode.js";
+import { basePaths, changelogPath, packageJsonPath, WsPathType, } from "@mxpicture/gcp-functions-common/path";
 const changelogLimit = 10;
-const __dirname = dirname(fileURLToPath(import.meta.url));
 export class Changelog {
     git;
-    changelogPath;
-    packageJsonPath;
-    rootDir;
     constructor(git) {
         this.git = git;
-        this.changelogPath = resolve(__dirname, "../../changelog.json");
-        this.packageJsonPath = resolve(__dirname, "../../package.json");
-        this.rootDir = resolve(__dirname, "../../../..");
     }
     async run() {
         const existingEntries = await this.readChangelogEntries();
-        const currentCommitHash = await lastCommitHash(this.rootDir);
+        const currentCommitHash = await lastCommitHash(basePaths.root);
         if (!currentCommitHash)
             throw new Error("No current git commit hash found");
-        const baselineCommit = await resolveBaselineCommit(existingEntries, this.git.rootDir, this.packageJsonPath);
+        const baselineCommit = await resolveBaselineCommit(existingEntries, this.git.rootDir, packageJsonPath(WsPathType.code));
         const changedFiles = await readChangedTsFiles(baselineCommit, this.git);
         if (changedFiles.length === 0)
             return null;
         const changedPackages = mapChangedPackages(changedFiles);
         const affectedPackages = mapAffectedPackages(changedPackages);
-        const version = await readMinPackageVersion(this.rootDir);
+        const version = await readMinPackageVersion(basePaths.root);
         if (!version)
             throw new Error("No version found");
         const entry = {
@@ -46,12 +39,12 @@ export class Changelog {
         if (!condenseResult.hasChanged)
             return null;
         await changelogEntriesSchema.parseAsync(condenseResult.entries);
-        await writeFile(this.changelogPath, await formatJson2Spaces(pkg.stringify(condenseResult.entries)));
+        await writeFile(changelogPath, await formatJson2Spaces(pkg.stringify(condenseResult.entries)));
         return entry;
     }
     async readChangelogEntries(sinceVersion) {
         try {
-            const content = await readFile(this.changelogPath, "utf8");
+            const content = await readFile(changelogPath, "utf8");
             const parsed = pkg.parse(content);
             const entries = await changelogEntriesSchema.parseAsync(parsed);
             if (!sinceVersion)

package/dist/changelog/changelog.util.d.ts

@@ -1,45 +1,11 @@
 import { z } from "zod";
 import { GitChanges } from "../git/GitChanges.js";
+import { PackageVersion } from "../common/code.common.js";
+import { WsPathType } from "@mxpicture/gcp-functions-common/path";
 export type ProcessMode = "fix" | "restore";
-export interface PackageVersion {
-    major: number;
-    minor: number | null;
-    patch: number | null;
-    prefix: string | null;
-}
-export declare const packageVersionSchema: z.ZodObject<{
-    major: z.ZodNumber;
-    minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
-    patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
-    prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
-}, z.core.$strip>;
-export interface PnpmWorkspace {
-    packages: string[];
-}
-export interface PackageJson {
-    name: string;
-    version: string;
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
-    [key: string]: unknown;
-}
-export interface PackageEntry {
-    jsonPath: string;
-    repoPath: string;
-    wsName: string;
-    content: PackageJson;
-    modified: boolean;
-}
-export interface MapEntry {
-    fromPkg: PackageEntry;
-    toPkg: PackageEntry;
-    relPath: string;
-}
-export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
-export declare const changelogPackageNames: readonly ["common", "backend", "frontend", "code"];
+export declare const changelogPackageNames: WsPathType[];
 export type ChangelogPackageName = (typeof changelogPackageNames)[number];
-export declare const changelogDependents: Record<ChangelogPackageName, string[]>;
+export declare const changelogDependents: Record<ChangelogPackageName, WsPathType[]>;
 export interface ChangelogEntry {
     version: string;
     versionParts: PackageVersion;
@@ -77,18 +43,7 @@ export declare const changelogEntriesSchema: z.ZodArray<z.ZodObject<{
     affectedPackages: z.ZodArray<z.ZodString>;
     changedFiles: z.ZodArray<z.ZodString>;
 }, z.core.$strip>>;
-export declare const splitVersion: (version: string) => PackageVersion;
-export declare const concatVersion: (version: PackageVersion) => string;
-export declare const compareVersions: (a: PackageVersion | string, b: PackageVersion | string) => number;
-export declare const compareVersionsGT: (a: PackageVersion | string, b: PackageVersion | string) => boolean;
-export declare const readWorkspaceYaml: (repoRoot: string) => Promise<PnpmWorkspace>;
-export declare const readPackageJsons: (repoRoot: string) => Promise<PackageEntry[]>;
-export declare const writePackageJsons: (entries: PackageEntry[]) => Promise<void[]>;
-export declare const buildMapEntries: (pkgEntries: PackageEntry[]) => MapEntry[];
 export declare const resolveBaselineCommit: (entries: ChangelogEntry[], rootDir: string, packageJsonPath: string) => Promise<string>;
-export declare const ensureCommitRef: (ref: string, fallback: string, rootDir: string) => Promise<string>;
 export declare const readChangedTsFiles: (baselineCommit: string, git: GitChanges) => Promise<string[]>;
 export declare const mapChangedPackages: (files: string[]) => string[];
 export declare const mapAffectedPackages: (changedPackages: string[]) => string[];
-export declare const readPackageVersions: (rootDir: string) => Promise<Record<string, string>>;
-export declare const readMinPackageVersion: (rootDir: string) => Promise<string | null>;

package/dist/changelog/changelog.util.js

@@ -1,40 +1,23 @@
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import pkg from "json5";
 import { z } from "zod";
-import { parse } from "yaml";
-import { verifiedGit } from "../git/git.util.js";
-export const packageVersionSchema = z.object({
-    major: z.number().min(0),
-    minor: z.xor([z.number(), z.null()]),
-    patch: z.xor([z.number(), z.null()]),
-    prefix: z.xor([z.string(), z.null()]),
-});
-export const readPackageJson = async (dirOrFilepath) => {
-    try {
-        const pkgPath = dirOrFilepath.endsWith("/package.json")
-            ? dirOrFilepath
-            : join(dirOrFilepath, "package.json");
-        const content = await readFile(pkgPath, "utf8");
-        return pkg.parse(content);
-    }
-    catch {
-        return null;
-    }
-};
-// todo get dynamically
-export const changelogPackageNames = [
-    "common",
-    "backend",
-    "frontend",
-    "code",
-];
-// todo get dynamically
+import { ensureCommitRef, verifiedGit } from "../git/git.util.js";
+import { packageVersionSchema } from "../common/code.common.js";
+import { readPackageJson } from "../vscode/workspaceAsync.vscode.js";
+import { WsPathType } from "@mxpicture/gcp-functions-common/path";
+export const changelogPackageNames = Object.values(WsPathType);
 export const changelogDependents = {
-    common: ["common", "backend", "frontend", "code"],
-    backend: ["backend", "code"],
-    frontend: ["frontend", "code"],
-    code: ["code"],
+    [WsPathType.backend]: [WsPathType.backend, WsPathType.generator],
+    [WsPathType.code]: [WsPathType.fs, WsPathType.generator],
+    [WsPathType.common]: [
+        WsPathType.common,
+        WsPathType.backend,
+        WsPathType.code,
+        WsPathType.frontend,
+        WsPathType.fs,
+        WsPathType.generator,
+    ],
+    [WsPathType.frontend]: [WsPathType.frontend, WsPathType.generator],
+    [WsPathType.fs]: [WsPathType.fs],
+    [WsPathType.generator]: [WsPathType.generator],
 };
 export const changelogEntrySchema = z.object({
     version: z.string().min(1),
@@ -46,110 +29,6 @@ export const changelogEntrySchema = z.object({
     changedFiles: z.array(z.string()),
 });
 export const changelogEntriesSchema = z.array(changelogEntrySchema);
-export const splitVersion = (version) => {
-    const parts = version.split(".");
-    let major = parts.shift();
-    const prefix = major.startsWith("v") ? "v" : null;
-    if (major.startsWith("v"))
-        major = major.substring(1);
-    const minor = parts.shift();
-    const patch = parts.shift();
-    return {
-        major: Number(major),
-        minor: minor ? Number(minor) : null,
-        patch: patch ? Number(patch) : null,
-        prefix,
-    };
-};
-export const concatVersion = (version) => {
-    let result = version.major.toString();
-    if (version.prefix)
-        result = version.prefix + result;
-    if (version.minor)
-        result += "." + version.minor.toString();
-    if (version.patch)
-        result += "." + version.patch.toString();
-    return result;
-};
-export const compareVersions = (a, b) => {
-    a = typeof a === "string" ? splitVersion(a) : a;
-    b = typeof b === "string" ? splitVersion(b) : b;
-    if (a.major !== b.major)
-        return a.major - b.major;
-    if (a.minor === null || b.minor === null)
-        return 0;
-    if (a.minor !== b.minor)
-        return a.minor - b.minor;
-    if (a.patch === null || b.patch === null)
-        return 0;
-    if (a.patch !== b.patch)
-        return a.patch - b.patch;
-    return 0;
-};
-export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;
-export const readWorkspaceYaml = async (repoRoot) => {
-    const workspaceFilePath = resolve(repoRoot, "pnpm-workspace.yaml");
-    const fileContent = await readFile(workspaceFilePath, "utf8");
-    const parsed = parse(fileContent);
-    if (!parsed || !parsed.packages || !Array.isArray(parsed.packages))
-        throw new Error("No 'packages' field found in pnpm-workspace.yaml");
-    const packageColletions = await Promise.all(parsed.packages.map(async (p) => {
-        if (!p.endsWith("/*"))
-            return [p];
-        const base = p.substring(0, p.length - 2);
-        const pkgs = await readdir(join(repoRoot, base));
-        return pkgs
-            .filter((pkg) => !pkg.startsWith("."))
-            .map((pkg) => join(base, pkg));
-    }));
-    const packages = [];
-    for (const packageColletion of packageColletions)
-        packages.push(...packageColletion);
-    return { packages };
-};
-export const readPackageJsons = async (repoRoot) => {
-    try {
-        const pnpmWS = await readWorkspaceYaml(repoRoot);
-        return Promise.all(pnpmWS.packages.map(async (repoPath) => {
-            const jsonPath = join(repoRoot, repoPath, "package.json");
-            const content = JSON.parse(await readFile(jsonPath, "utf8"));
-            return {
-                jsonPath,
-                repoPath,
-                content,
-                modified: false,
-                wsName: repoPath.startsWith("packages/")
-                    ? repoPath.substring(9)
-                    : repoPath,
-            };
-        }));
-    }
-    catch {
-        return [];
-    }
-};
-export const writePackageJsons = async (entries) => Promise.all(entries.map(async (entry) => {
-    if (entry.modified) {
-        await writeFile(entry.jsonPath, JSON.stringify(entry.content, null, 2) + "\n", "utf8");
-        console.log(`  ✅ Updated ${entry.content.name}\n`);
-    }
-    else {
-        console.log(`  ⏭️  No workspace dependencies to fix. ${entry.content.name}\n`);
-    }
-}));
-// Build a map of package names to their versions
-export const buildMapEntries = (pkgEntries) => {
-    const versionEntries = [];
-    for (const fromPkg of pkgEntries)
-        for (const toPkg of pkgEntries)
-            if (fromPkg.content.name !== toPkg.content.name)
-                versionEntries.push({
-                    fromPkg,
-                    toPkg,
-                    relPath: relative(fromPkg.repoPath, toPkg.repoPath),
-                });
-    return versionEntries;
-};
 export const resolveBaselineCommit = async (entries, rootDir, packageJsonPath) => {
     if (entries.length > 0 &&
         entries[0].gitCommitHashs.length > 0 &&
@@ -166,16 +45,6 @@ export const resolveBaselineCommit = async (entries, rootDir, packageJsonPath) =
     }
     return ensureCommitRef("HEAD~1", "HEAD", rootDir);
 };
-export const ensureCommitRef = async (ref, fallback, rootDir) => {
-    try {
-        await verifiedGit(rootDir, ref);
-        return ref;
-    }
-    catch {
-        await verifiedGit(rootDir, fallback);
-        return fallback;
-    }
-};
 export const readChangedTsFiles = async (baselineCommit, git) => {
     git.sinceCommit = baselineCommit;
     const [result, simplegit] = await Promise.all([
@@ -211,18 +80,3 @@ export const mapAffectedPackages = (changedPackages) => {
     }
     return [...affected].sort();
 };
-export const readPackageVersions = async (rootDir) => {
-    const versions = {};
-    const packageJsons = await readPackageJsons(rootDir);
-    for (const packageJson of packageJsons)
-        versions[packageJson.repoPath] = packageJson.content.version;
-    return versions;
-};
-export const readMinPackageVersion = async (rootDir) => {
-    const versions = await readPackageVersions(rootDir);
-    const splitVersions = Object.values(versions).map(splitVersion);
-    if (splitVersions.length === 0)
-        return null;
-    splitVersions.sort(compareVersions);
-    return concatVersion(splitVersions[0]);
-};

package/dist/common/code.common.d.ts

@@ -1,5 +1,6 @@
 import { MetaFileExtension, MetaFileType } from "@mxpicture/gcp-functions-common/meta";
 import { ExtractFileParts, SourceFile } from "./types.common.js";
+import { z } from "zod";
 export declare const isTemplateFile: (filename: string) => boolean;
 export declare const isTsFile: (filename: string, type: MetaFileType) => boolean;
 export declare const isAnyFile: (filename: string, type?: MetaFileType, ext?: MetaFileExtension) => boolean;
@@ -15,3 +16,19 @@ export declare const formatCode: (...lines: string[]) => Promise<string>;
 export declare const formatJson: (...lines: string[]) => Promise<string>;
 export declare const formatJson2Spaces: (...lines: string[]) => Promise<string>;
 export declare const createSourceFiles: (filePaths: string[]) => SourceFile[];
+export interface PackageVersion {
+    major: number;
+    minor: number | null;
+    patch: number | null;
+    prefix: string | null;
+}
+export declare const packageVersionSchema: z.ZodObject<{
+    major: z.ZodNumber;
+    minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+export declare const splitVersion: (version: string) => PackageVersion;
+export declare const concatVersion: (version: PackageVersion) => string;
+export declare const compareVersions: (a: PackageVersion | string, b: PackageVersion | string) => number;
+export declare const compareVersionsGT: (a: PackageVersion | string, b: PackageVersion | string) => boolean;

package/dist/common/code.common.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { format } from "prettier";
 import { guardMetaFileExtension, guardMetaFileType, MetaFileExtension, MetaFileType, } from "@mxpicture/gcp-functions-common/meta";
+import { z } from "zod";
 export const isTemplateFile = (filename) => isTsFile(filename, MetaFileType.template);
 export const isTsFile = (filename, type) => isAnyFile(filename, type, MetaFileExtension.ts);
 export const isAnyFile = (filename, type, ext) => {
@@ -63,3 +64,50 @@ export const createSourceFiles = (filePaths) => {
     }
     return results;
 };
+export const packageVersionSchema = z.object({
+    major: z.number().min(0),
+    minor: z.xor([z.number(), z.null()]),
+    patch: z.xor([z.number(), z.null()]),
+    prefix: z.xor([z.string(), z.null()]),
+});
+export const splitVersion = (version) => {
+    const parts = version.split(".");
+    let major = parts.shift();
+    const prefix = major.startsWith("v") ? "v" : null;
+    if (major.startsWith("v"))
+        major = major.substring(1);
+    const minor = parts.shift();
+    const patch = parts.shift();
+    return {
+        major: Number(major),
+        minor: minor ? Number(minor) : null,
+        patch: patch ? Number(patch) : null,
+        prefix,
+    };
+};
+export const concatVersion = (version) => {
+    let result = version.major.toString();
+    if (version.prefix)
+        result = version.prefix + result;
+    if (version.minor)
+        result += "." + version.minor.toString();
+    if (version.patch)
+        result += "." + version.patch.toString();
+    return result;
+};
+export const compareVersions = (a, b) => {
+    a = typeof a === "string" ? splitVersion(a) : a;
+    b = typeof b === "string" ? splitVersion(b) : b;
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor === null || b.minor === null)
+        return 0;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch === null || b.patch === null)
+        return 0;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    return 0;
+};
+export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;

package/dist/common/types.common.d.ts

@@ -1,5 +1,4 @@
 import ts from "typescript";
-import type { PackageJson } from "type-fest";
 import { MetaFileExtension, MetaFileType, MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
 export interface ExtractFileParts {
     filename: string;
@@ -18,3 +17,26 @@ export interface TargetPackage {
     filePath: string;
     pkg: PackageJson;
 }
+export interface PnpmWorkspace {
+    packages: string[];
+}
+export interface PackageJson {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface PackageEntry {
+    jsonPath: string;
+    repoPath: string;
+    wsName: string;
+    content: PackageJson;
+    modified: boolean;
+}
+export interface MapEntry {
+    fromPkg: PackageEntry;
+    toPkg: PackageEntry;
+    relPath: string;
+}

package/dist/deps/IFixWorkspaceDeps.d.ts

@@ -1,4 +1,5 @@
-import { MapEntry, ProcessMode, PackageEntry } from "../changelog/changelog.util.js";
+import { ProcessMode } from "../changelog/changelog.util.js";
+import { MapEntry, PackageEntry } from "../common/types.common.js";
 export interface FixWorkspaceDepsMain {
     mapEntries: MapEntry[];
     consumingPkg: PackageEntry;

package/dist/deps/IFixWorkspaceDeps.js

@@ -1,4 +1,4 @@
-import { buildMapEntries, readPackageJsons, writePackageJsons, } from "../changelog/changelog.util.js";
+import { readPackageJsons, buildMapEntries, writePackageJsons, } from "../vscode/workspaceAsync.vscode.js";
 export class IFixWorkspaceDeps {
     repoRoot;
     mode;

package/dist/git/git.util.d.ts

@@ -7,3 +7,4 @@ import { GitCommitHash } from "./types.git.js";
 export declare const verifiedGit: (rootDir: string, commitRef?: string) => Promise<SimpleGit>;
 export declare const lastCommitHash: (rootDir: string) => Promise<string | null>;
 export declare const commitHashs: (rootDir: string) => Promise<GitCommitHash[]>;
+export declare const ensureCommitRef: (ref: string, fallback: string, rootDir: string) => Promise<string>;

package/dist/git/git.util.js

@@ -31,3 +31,13 @@ export const commitHashs = async (rootDir) => (await (await verifiedGit(rootDir)
     hash: a.hash,
     diff: a.diff,
 }));
+export const ensureCommitRef = async (ref, fallback, rootDir) => {
+    try {
+        await verifiedGit(rootDir, ref);
+        return ref;
+    }
+    catch {
+        await verifiedGit(rootDir, fallback);
+        return fallback;
+    }
+};

package/dist/vscode/workspaceAsync.vscode.d.ts

@@ -1,2 +1,11 @@
 import { WorkspaceFile } from "./types.vscode.js";
+import { MapEntry, PackageEntry, PackageJson, PnpmWorkspace } from "../common/types.common.js";
 export declare const findWorkspaceRootAsync: (startPath?: string) => Promise<WorkspaceFile>;
+export declare const readWorkspaceYaml: (repoRoot: string) => Promise<PnpmWorkspace>;
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
+export declare const readPackageJsonThrow: (dirOrFilepath: string) => Promise<PackageJson>;
+export declare const readPackageJsons: (repoRoot: string) => Promise<PackageEntry[]>;
+export declare const writePackageJsons: (entries: PackageEntry[]) => Promise<void[]>;
+export declare const buildMapEntries: (pkgEntries: PackageEntry[]) => MapEntry[];
+export declare const readPackageVersions: (rootDir: string) => Promise<Record<string, string>>;
+export declare const readMinPackageVersion: (rootDir: string) => Promise<string | null>;

package/dist/vscode/workspaceAsync.vscode.js

@@ -1,14 +1,17 @@
-import { dirname, join } from "path";
+import { dirname, join, relative, resolve } from "path";
+import { parse } from "yaml";
 import { fileURLToPath } from "url";
+import pkg from "json5";
 import { WorkspaceFileType } from "./types.vscode.js";
 import { getFileType } from "./common.vscode.js";
-import { readdir } from "fs/promises";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { compareVersions, concatVersion, splitVersion, } from "../common/code.common.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let __workspaceRoot = null;
-export const findWorkspaceRootAsync = async (startPath) => __workspaceRoot ??
-    (__workspaceRoot = await _findWorkspaceRoot(startPath ?? __dirname));
-const _findWorkspaceRoot = async (dirPath) => {
-    let path = dirPath;
+export const findWorkspaceRootAsync = async (startPath) => {
+    if (__workspaceRoot)
+        return __workspaceRoot;
+    let path = startPath ?? __dirname;
     let level = 0;
     const promises = [];
     while (path.length > 0) {
@@ -50,5 +53,98 @@ const _findWorkspaceRoot = async (dirPath) => {
         results.find((r) => r.value.type === WorkspaceFileType.package)?.value;
     if (!result)
         throw new Error("findWorkspaceRoot: no file found");
+    __workspaceRoot = result;
     return result;
 };
+export const readWorkspaceYaml = async (repoRoot) => {
+    const workspaceFilePath = resolve(repoRoot, "pnpm-workspace.yaml");
+    const fileContent = await readFile(workspaceFilePath, "utf8");
+    const parsed = parse(fileContent);
+    if (!parsed || !parsed.packages || !Array.isArray(parsed.packages))
+        throw new Error("No 'packages' field found in pnpm-workspace.yaml");
+    const packageColletions = await Promise.all(parsed.packages.map(async (p) => {
+        if (!p.endsWith("/*"))
+            return [p];
+        const base = p.substring(0, p.length - 2);
+        const pkgs = await readdir(join(repoRoot, base));
+        return pkgs
+            .filter((pkg) => !pkg.startsWith("."))
+            .map((pkg) => join(base, pkg));
+    }));
+    const packages = [];
+    for (const packageColletion of packageColletions)
+        packages.push(...packageColletion);
+    return { packages };
+};
+export const readPackageJson = async (dirOrFilepath) => {
+    try {
+        return readPackageJsonThrow(dirOrFilepath);
+    }
+    catch {
+        return null;
+    }
+};
+export const readPackageJsonThrow = async (dirOrFilepath) => {
+    const pkgPath = dirOrFilepath.endsWith("/package.json")
+        ? dirOrFilepath
+        : join(dirOrFilepath, "package.json");
+    return pkg.parse(await readFile(pkgPath, "utf8"));
+};
+export const readPackageJsons = async (repoRoot) => {
+    try {
+        const pnpmWS = await readWorkspaceYaml(repoRoot);
+        return Promise.all(pnpmWS.packages.map(async (repoPath) => {
+            const jsonPath = join(repoRoot, repoPath, "package.json");
+            const content = await readPackageJsonThrow(jsonPath);
+            return {
+                jsonPath,
+                repoPath,
+                content,
+                modified: false,
+                wsName: repoPath.startsWith("packages/")
+                    ? repoPath.substring(9)
+                    : repoPath,
+            };
+        }));
+    }
+    catch {
+        return [];
+    }
+};
+export const writePackageJsons = async (entries) => Promise.all(entries.map(async (entry) => {
+    if (entry.modified) {
+        await writeFile(entry.jsonPath, JSON.stringify(entry.content, null, 2) + "\n", "utf8");
+        console.log(`  ✅ Updated ${entry.content.name}\n`);
+    }
+    else {
+        console.log(`  ⏭️  No workspace dependencies to fix. ${entry.content.name}\n`);
+    }
+}));
+// Build a map of package names to their versions
+export const buildMapEntries = (pkgEntries) => {
+    const versionEntries = [];
+    for (const fromPkg of pkgEntries)
+        for (const toPkg of pkgEntries)
+            if (fromPkg.content.name !== toPkg.content.name)
+                versionEntries.push({
+                    fromPkg,
+                    toPkg,
+                    relPath: relative(fromPkg.repoPath, toPkg.repoPath),
+                });
+    return versionEntries;
+};
+export const readPackageVersions = async (rootDir) => {
+    const versions = {};
+    const packageJsons = await readPackageJsons(rootDir);
+    for (const packageJson of packageJsons)
+        versions[packageJson.repoPath] = packageJson.content.version;
+    return versions;
+};
+export const readMinPackageVersion = async (rootDir) => {
+    const versions = await readPackageVersions(rootDir);
+    const splitVersions = Object.values(versions).map(splitVersion);
+    if (splitVersions.length === 0)
+        return null;
+    splitVersions.sort(compareVersions);
+    return concatVersion(splitVersions[0]);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-code",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Tools for google cloud functions",
   "type": "module",
   "author": "MXPicture",
@@ -26,28 +26,24 @@
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo tsconfig.tsbuildinfo node_modules",
     "lint": "eslint \"src/**/*.{ts,tsx}\" --ext .ts,.tsx",
-    "build": "tsc -b .",
-    "test:clean": "rm -rf src/4testing/generator-test-*",
-    "run:test": "pnpm exec tsx src/scripts/test.mts"
+    "build": "tsc -b ."
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@mxpicture/gcp-functions-common": "^0.2.0",
-    "json5": "^1.0.2",
+    "@mxpicture/gcp-functions-common": "^0.2.2",
+    "json5": "^2.2.3",
     "micromatch": "^4.0.8",
     "prettier": "^3.8.1",
     "simple-git": "^3.31.1",
-    "type-fest": "^5.4.4",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/micromatch": "^4.0.10",
-    "@types/node": "^25.2.0",
-    "@types/prettier": "^3.0.0",
-    "eslint": "^9.39.2",
+    "@types/node": "^25.2.3",
+    "eslint": "^10.0.2",
     "typescript": "^5.9.3"
   }
 }

package/dist/scripts/generate-barrels.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/generate-barrels.js

@@ -1,81 +0,0 @@
-import { basename, dirname, join } from "node:path";
-import { readdir, writeFile } from "node:fs/promises";
-import { VSCodeWorkspace } from "../vscode/VSCodeWorkspace.js";
-// ─── Configuration ───────────────────────────────────────────────────────────
-// /** File patterns to exclude from barrel exports */
-const EXCLUDED_PATTERNS = [
-    /\.test\.ts$/,
-    /\.spec\.ts$/,
-    /\.d\.ts$/,
-    /index\.ts$/,
-];
-// /** Header comment added to every generated barrel file */
-const HEADER = "// This file is auto-generated. Do not edit manually.\n";
-const isExcluded = (fileName) => EXCLUDED_PATTERNS.some((pattern) => pattern.test(fileName));
-// ─── Generator ───────────────────────────────────────────────────────────────
-const createBarrels = async () => {
-    const rootDir = (await VSCodeWorkspace.loadAsync()).root;
-    const packagesDir = join(rootDir, "packages");
-    const packages = (await readdir(packagesDir)).map((p) => join(packagesDir, p));
-    const promises = [];
-    for (const pkg of packages) {
-        try {
-            const baseDirPath = join(pkg, "src");
-            const items = (await readdir(baseDirPath, { recursive: true })).sort();
-            let currentGroup;
-            for (const item of items) {
-                const filename = basename(item);
-                if (isExcluded(filename) || !filename.endsWith(".ts"))
-                    continue;
-                const dirPath = join(baseDirPath, dirname(item));
-                if (dirPath !== currentGroup?.dirPath) {
-                    if (currentGroup)
-                        promises.push(persistBarrel({ ...currentGroup }));
-                    currentGroup = { dirPath, files: [] };
-                }
-                currentGroup.files.push(filename);
-            }
-            if (currentGroup)
-                promises.push(persistBarrel({ ...currentGroup }));
-        }
-        catch {
-            continue;
-        }
-    }
-    await Promise.all(promises);
-};
-const persistBarrel = async (group) => {
-    if (group.files.length === 0)
-        return;
-    const content = `${HEADER}${group.files
-        .sort()
-        .map((f) => `export * from "./${basename(f, ".ts")}.js";`)
-        .join("\n")}\n`;
-    const barrelPath = join(group.dirPath, "index.ts");
-    return writeFile(barrelPath, content);
-};
-// ─── Entry Point ─────────────────────────────────────────────────────────────
-const run = async () => {
-    await createBarrels();
-    // // Allow overriding paths via CLI arguments:
-    // //   npx tsx scripts/generate-barrels.ts ./src/hooks ./src/types
-    // const cliPaths = process.argv.slice(2);
-    // const paths = cliPaths.length > 0 ? cliPaths : BARREL_PATHS;
-    // console.log("🛢️  Generating barrel files...\n");
-    // console.log(
-    //   `📂 Target directories:\n${paths
-    //     .map((p) => `   - ${resolve(p)}`)
-    //     .join("\n")}\n`,
-    // );
-    // let generated = 0;
-    // for (const targetPath of paths) {
-    //   const resolved = resolve(targetPath);
-    //   if (await generateBarrel(resolved)) {
-    //     generated++;
-    //   }
-    // }
-    // console.log(
-    //   `\n🎉 Done! Barrels generated for ${generated}/${paths.length} directories.`,
-    // );
-};
-run().catch(console.error);

package/dist/scripts/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./fix-workspace-deps.js";
-export * from "./generate-barrels.js";
-export * from "./generate-changelog.js";

package/dist/scripts/index.js

@@ -1,4 +0,0 @@
-// This file is auto-generated. Do not edit manually.
-export * from "./fix-workspace-deps.js";
-export * from "./generate-barrels.js";
-export * from "./generate-changelog.js";