monoverse 0.0.11 → 0.0.12

package/dist/cli.js

@@ -1,483 +1,699 @@
-#!/usr/bin/env node
-
-// cli.ts
-import * as trpcExpress from "@trpc/server/adapters/express";
-import express from "express";
-import { fileURLToPath } from "url";
-import path4 from "path";
-
-// trpc/server.ts
-import { z as z5 } from "zod";
-
-// domain/core/schema/schema.ts
-import { z } from "zod";
-var dependencySchema = z.object({
-  name: z.string(),
-  versionRange: z.string(),
-  type: z.enum([
-    "dependency",
-    "devDependency",
-    "peerDependency",
-    "optionalDependency"
-  ])
+import { Command, Args, Options, CliConfig } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Data, Effect, Schema, Either, Console, Layer } from "effect";
+import yaml from "js-yaml";
+import * as fs from "node:fs/promises";
+import * as nodePath from "node:path";
+import { glob as glob$1 } from "tinyglobby";
+import sortPackageJson from "sort-package-json";
+import * as semver from "semver";
+class FsError extends Data.TaggedError("FsError") {
+}
+Effect.sync(() => process.cwd());
+const getParentDirectory = (dirPath) => Effect.sync(() => nodePath.dirname(dirPath));
+const readFile = (filePath) => Effect.tryPromise({
+  try: () => fs.readFile(filePath, "utf-8"),
+  catch: (cause) => new FsError({ path: filePath, cause })
 });
-var workspaceSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  dependencies: z.array(dependencySchema)
+const writeFile = (filePath, content) => Effect.tryPromise({
+  try: () => fs.writeFile(filePath, content, "utf-8"),
+  catch: (cause) => new FsError({ path: filePath, cause })
 });
-var monorepoSchema = z.object({
-  workspaces: z.array(workspaceSchema)
+const fileExists = (filePath) => Effect.tryPromise({
+  try: async () => {
+    await fs.access(filePath);
+    return true;
+  },
+  catch: () => false
+}).pipe(Effect.catchAll(() => Effect.succeed(false)));
+const joinPath = (...paths) => nodePath.join(...paths);
+const basename = (path) => nodePath.basename(path);
+const dirname = (path) => nodePath.dirname(path);
+const isRootPath = (dirPath) => nodePath.dirname(dirPath) === dirPath;
+const glob = (patterns, options) => Effect.tryPromise({
+  try: () => glob$1(patterns, {
+    cwd: options.cwd,
+    ignore: options.ignore ?? [],
+    absolute: options.absolute ?? true
+  }),
+  catch: (cause) => new FsError({ path: options.cwd, cause })
 });
-var dependencyRecordSchema = z.record(z.string());
-var packageJsonSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  version: z.string().optional(),
-  // Dependencies
-  dependencies: dependencyRecordSchema.optional(),
-  devDependencies: dependencyRecordSchema.optional(),
-  peerDependencies: dependencyRecordSchema.optional(),
-  optionalDependencies: dependencyRecordSchema.optional()
-}).passthrough();
-
-// domain/tools/ts.ts
-var removeUndefined = (obj) => {
-  const result = { ...obj };
-  for (const key in result) {
-    const value = result[key];
-    if (value === void 0) {
-      delete result[key];
-    }
+class NotAMonorepoError extends Data.TaggedError("NotAMonorepoError") {
+}
+const PackageJsonSchema = Schema.Struct({
+  workspaces: Schema.optional(
+    Schema.Union(
+      Schema.mutable(Schema.Array(Schema.String)),
+      Schema.Struct({
+        packages: Schema.optional(Schema.mutable(Schema.Array(Schema.String)))
+      })
+    )
+  )
+});
+const PnpmWorkspaceSchema = Schema.Struct({
+  packages: Schema.optional(Schema.mutable(Schema.Array(Schema.String)))
+});
+const LOCK_FILES = [
+  { file: "pnpm-lock.yaml", pm: "pnpm" },
+  { file: "yarn.lock", pm: "yarn" },
+  { file: "package-lock.json", pm: "npm" },
+  { file: "bun.lockb", pm: "bun" }
+];
+const detectPackageManager = (dirPath) => Effect.gen(function* () {
+  for (const { file, pm } of LOCK_FILES) {
+    const exists = yield* fileExists(joinPath(dirPath, file));
+    if (exists) return pm;
   }
-  return result;
-};
-
-// domain/core/schema/transform.ts
-var transformPackageJsonToWorkspace = (packageJson) => {
-  const validatedPackageJson = packageJsonSchema.parse(packageJson);
-  const {
-    dependencies,
-    devDependencies,
-    peerDependencies,
-    optionalDependencies
-  } = validatedPackageJson;
-  const getDependencies = (list, type) => {
-    if (!list)
-      return [];
-    return Object.entries(list).map(([name, versionRange]) => {
+  return "unknown";
+});
+const parseYaml = (content) => Effect.try(() => yaml.load(content)).pipe(
+  Effect.flatMap(Schema.decodeUnknown(PnpmWorkspaceSchema))
+);
+const parsePackageJson$1 = (content) => Effect.try(() => JSON.parse(content)).pipe(
+  Effect.flatMap(Schema.decodeUnknown(PackageJsonSchema))
+);
+const getPnpmWorkspacePatterns = (dirPath) => Effect.gen(function* () {
+  const wsPath = joinPath(dirPath, "pnpm-workspace.yaml");
+  const exists = yield* fileExists(wsPath);
+  if (!exists) return null;
+  const content = yield* readFile(wsPath).pipe(
+    Effect.catchAll(() => Effect.succeed(""))
+  );
+  if (!content) return null;
+  const result = yield* parseYaml(content).pipe(
+    Effect.catchAll(() => Effect.succeed(null))
+  );
+  return result?.packages ?? null;
+});
+const getPackageJsonWorkspacePatterns = (dirPath) => Effect.gen(function* () {
+  const pkgPath = joinPath(dirPath, "package.json");
+  const exists = yield* fileExists(pkgPath);
+  if (!exists) return null;
+  const content = yield* readFile(pkgPath).pipe(
+    Effect.catchAll(() => Effect.succeed(""))
+  );
+  if (!content) return null;
+  const pkg = yield* parsePackageJson$1(content).pipe(
+    Effect.catchAll(() => Effect.succeed(null))
+  );
+  if (!pkg) return null;
+  if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+  if (Array.isArray(pkg.workspaces?.packages)) return pkg.workspaces.packages;
+  return null;
+});
+const hasPackageJson = (dirPath) => fileExists(joinPath(dirPath, "package.json"));
+const toPackageJsonGlob = (patterns) => patterns.map((p) => joinPath(p, "package.json"));
+const findMonorepoRoot = (startPath, options = {}) => Effect.gen(function* () {
+  let currentPath = startPath;
+  let singleRepoCandidate = null;
+  const stopAt = options.stopAt;
+  while (true) {
+    const pnpmPatterns = yield* getPnpmWorkspacePatterns(currentPath);
+    if (pnpmPatterns) {
       return {
-        name,
-        versionRange,
-        type
+        root: currentPath,
+        packageManager: "pnpm",
+        patterns: toPackageJsonGlob(pnpmPatterns)
       };
-    });
-  };
-  return workspaceSchema.parse(
-    // removeUndefined to ensure that the workspace doesn't have any undefined
-    removeUndefined({
-      name: validatedPackageJson.name,
-      description: validatedPackageJson.description,
-      dependencies: [
-        ...getDependencies(dependencies, "dependency"),
-        ...getDependencies(devDependencies, "devDependency"),
-        ...getDependencies(peerDependencies, "peerDependency"),
-        ...getDependencies(optionalDependencies, "optionalDependency")
-      ]
+    }
+    const pkgPatterns = yield* getPackageJsonWorkspacePatterns(currentPath);
+    if (pkgPatterns) {
+      const pm = yield* detectPackageManager(currentPath);
+      return {
+        root: currentPath,
+        packageManager: pm,
+        patterns: toPackageJsonGlob(pkgPatterns)
+      };
+    }
+    if (!singleRepoCandidate) {
+      const hasPkg = yield* hasPackageJson(currentPath);
+      if (hasPkg) {
+        singleRepoCandidate = currentPath;
+      }
+    }
+    if (isRootPath(currentPath)) break;
+    if (stopAt && currentPath === stopAt) break;
+    currentPath = yield* getParentDirectory(currentPath);
+  }
+  if (singleRepoCandidate) {
+    const pm = yield* detectPackageManager(singleRepoCandidate);
+    return {
+      root: singleRepoCandidate,
+      packageManager: pm,
+      patterns: ["./package.json"]
+    };
+  }
+  return yield* Effect.fail(
+    new NotAMonorepoError({
+      startPath,
+      message: "No package.json found in directory tree"
     })
   );
+});
+const parseDependencySource = (versionRange) => {
+  if (versionRange.startsWith("file:") || versionRange.startsWith("./") || versionRange.startsWith("../") || versionRange.startsWith("/")) {
+    return "file";
+  }
+  if (versionRange.startsWith("git+") || versionRange.startsWith("git://") || versionRange.startsWith("github:") || versionRange.startsWith("gitlab:") || versionRange.startsWith("bitbucket:")) {
+    return "git";
+  }
+  if (versionRange.startsWith("http://") || versionRange.startsWith("https://")) {
+    return "url";
+  }
+  return "npm";
 };
-
-// domain/core/version.ts
-import { gt, maxSatisfying, minSatisfying } from "semver";
-
-// domain/implementation/api/bundlephobia.ts
-import { z as z2 } from "zod";
-var requestSchema = z2.string();
-var responseSchema = z2.object({
-  assets: z2.array(
-    z2.object({
-      gzip: z2.number(),
-      name: z2.string(),
-      size: z2.number(),
-      type: z2.string()
-    })
+const parseDependencies = (deps, dependencyType, workspaceNames) => {
+  if (!deps) return [];
+  return Object.entries(deps).map(([name, versionRange]) => ({
+    name,
+    versionRange,
+    dependencyType,
+    source: workspaceNames.has(name) ? "workspace" : parseDependencySource(versionRange)
+  }));
+};
+const RawPackageJsonSchema = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  private: Schema.optional(Schema.Boolean),
+  dependencies: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.String })
+  ),
+  devDependencies: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.String })
   ),
-  dependencyCount: z2.number(),
-  dependencySizes: z2.array(
-    z2.object({ approximateSize: z2.number(), name: z2.string() })
+  peerDependencies: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.String })
   ),
-  description: z2.string().optional(),
-  name: z2.string(),
-  version: z2.string()
+  optionalDependencies: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.String })
+  )
 });
-
-// domain/implementation/api/package-info.ts
-import { z as z4 } from "zod";
-
-// domain/implementation/api/schema.ts
-import { z as z3 } from "zod";
-var packageSchema = z3.object({
-  name: z3.string(),
-  description: z3.string().optional(),
-  repository: z3.string().optional(),
-  licence: z3.string().optional(),
-  versions: z3.array(z3.string())
+const parseWorkspace = (pkgPath, raw, workspaceNames) => ({
+  name: raw.name ?? basename(dirname(pkgPath)),
+  version: raw.version ?? "0.0.0",
+  path: dirname(pkgPath),
+  private: raw.private ?? false,
+  dependencies: [
+    ...parseDependencies(raw.dependencies, "dependency", workspaceNames),
+    ...parseDependencies(raw.devDependencies, "devDependency", workspaceNames),
+    ...parseDependencies(
+      raw.peerDependencies,
+      "peerDependency",
+      workspaceNames
+    ),
+    ...parseDependencies(
+      raw.optionalDependencies,
+      "optionalDependency",
+      workspaceNames
+    )
+  ]
 });
-
-// domain/implementation/api/package-info.ts
-var requestSchema2 = z4.string();
-var responseSchema2 = z4.object({
-  name: z4.string(),
-  versions: z4.record(z4.any()),
-  description: z4.string().optional(),
-  repository: z4.object({
-    url: z4.string().optional()
-  }).optional(),
-  licence: z4.string().optional()
+const parsePackageJson = (content) => Effect.try(() => JSON.parse(content)).pipe(
+  Effect.flatMap(Schema.decodeUnknown(RawPackageJsonSchema))
+);
+const discoverWorkspaces = (root, patterns) => Effect.gen(function* () {
+  const workspaces = [];
+  const errors = [];
+  const workspacePaths = yield* glob(patterns, {
+    cwd: root,
+    ignore: ["**/node_modules/**"],
+    absolute: true
+  }).pipe(Effect.catchAll(() => Effect.succeed([])));
+  const rawPackages = [];
+  const workspaceNames = /* @__PURE__ */ new Set();
+  for (const workspacePath of workspacePaths) {
+    const result = yield* readFile(workspacePath).pipe(
+      Effect.flatMap(parsePackageJson),
+      Effect.either
+    );
+    if (Either.isRight(result)) {
+      const rawPackageJson = result.right;
+      const name = rawPackageJson.name ?? basename(dirname(workspacePath));
+      workspaceNames.add(name);
+      rawPackages.push({ path: workspacePath, raw: rawPackageJson });
+    } else {
+      errors.push({
+        path: workspacePath,
+        message: "Failed to parse package.json",
+        cause: result.left
+      });
+    }
+  }
+  for (const { path: pkgPath, raw } of rawPackages) {
+    workspaces.push(parseWorkspace(pkgPath, raw, workspaceNames));
+  }
+  return { workspaces, errors };
 });
-
-// domain/implementation/filesystem/filesystem.ts
-import { getPackages as getWorkspaces } from "@monorepo-utils/package-utils";
-import fs from "fs";
-import path from "path";
-import invariant from "tiny-invariant";
-var getMonorepoInfo = (dirPath) => {
-  const monorepoDir = detectMonorepoDir(dirPath);
-  const workspaceDir = detectWorkspaceDir(dirPath);
-  if (monorepoDir) {
-    const workspaces = getMonorepoWorkspacesAtDir(monorepoDir);
-    invariant(workspaces !== void 0, "monorepo should be defined");
-    return {
-      workspaces
-    };
-  } else if (workspaceDir) {
-    const workspace = getWorkspaceAtDir(workspaceDir);
-    invariant(workspace !== void 0, "workspace should be defined");
-    return {
-      workspaces: [workspace]
-    };
+const getPackageJsonStr = (workspace) => readFile(joinPath(workspace.path, "package.json"));
+const analyzeMonorepo = (startPath) => Effect.gen(function* () {
+  const { root, packageManager, patterns } = yield* findMonorepoRoot(startPath);
+  const { workspaces, errors } = yield* discoverWorkspaces(root, patterns);
+  return {
+    root,
+    packageManager,
+    workspaces,
+    errors
+  };
+});
+class ModifyError extends Data.TaggedError("ModifyError") {
+}
+class DependencyNotFoundError extends Data.TaggedError(
+  "DependencyNotFoundError"
+) {
+}
+class PackageJsonParseError extends Data.TaggedError(
+  "PackageJsonParseError"
+) {
+}
+class PackageJsonWriteError extends Data.TaggedError(
+  "PackageJsonWriteError"
+) {
+}
+const ALL_DEPENDENCY_KEYS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const readPackageJson = (workspace) => Effect.gen(function* () {
+  const filePath = joinPath(workspace.path, "package.json");
+  const raw = yield* readFile(filePath).pipe(
+    Effect.mapError(
+      (e) => new PackageJsonParseError({ workspace: workspace.name, cause: e })
+    )
+  );
+  return yield* Effect.try({
+    try: () => JSON.parse(raw),
+    catch: (cause) => new PackageJsonParseError({ workspace: workspace.name, cause })
+  });
+});
+const writePackageJson = (workspace, content) => Effect.gen(function* () {
+  const filePath = joinPath(workspace.path, "package.json");
+  const formatted = sortPackageJson(content);
+  const current = yield* readFile(filePath).pipe(
+    Effect.mapError(
+      (e) => new PackageJsonWriteError({ workspace: workspace.name, cause: e })
+    )
+  );
+  if (current === formatted) {
+    return;
   }
-  return void 0;
+  yield* writeFile(filePath, formatted).pipe(
+    Effect.mapError(
+      (e) => new PackageJsonWriteError({ workspace: workspace.name, cause: e })
+    )
+  );
+});
+const DEPENDENCY_TYPE_TO_KEY = {
+  dependency: "dependencies",
+  devDependency: "devDependencies",
+  peerDependency: "peerDependencies",
+  optionalDependency: "optionalDependencies"
 };
-var detectMonorepoDir = (dirPath) => {
-  dirPath = path.resolve(dirPath);
-  while (true) {
-    const monorepo = getMonorepoWorkspacesAtDir(dirPath);
-    if (monorepo)
-      return dirPath;
-    const parentDir = path.dirname(dirPath);
-    if (parentDir === dirPath)
-      return void 0;
-    dirPath = parentDir;
+const upsertDependency = (options) => Effect.gen(function* () {
+  const { workspace, dependencyName, versionRange, dependencyType } = options;
+  const content = yield* readPackageJson(workspace).pipe(
+    Effect.mapError(
+      (e) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to read package.json",
+        cause: e
+      })
+    )
+  );
+  const targetKey = DEPENDENCY_TYPE_TO_KEY[dependencyType];
+  for (const key of ALL_DEPENDENCY_KEYS) {
+    if (key === targetKey) continue;
+    const deps = content[key];
+    if (deps && dependencyName in deps) {
+      delete deps[dependencyName];
+      if (Object.keys(deps).length === 0) {
+        delete content[key];
+      }
+    }
   }
-};
-function getMonorepoWorkspacesAtDir(dir) {
-  const workspaces = getWorkspaces(dir);
-  if (!workspaces || workspaces.length === 0)
-    return void 0;
-  return workspaces.map((workspace) => {
-    const { packageJSON, location } = workspace;
-    const parsedPackageJson = packageJsonSchema.parse(packageJSON);
-    return {
-      workspace: transformPackageJsonToWorkspace(packageJSON),
-      location,
-      packageJSON: parsedPackageJson
-    };
-  });
-}
-function detectWorkspaceDir(dirPath) {
-  while (true) {
-    const workspace = getWorkspaceAtDir(dirPath);
-    if (workspace)
-      return dirPath;
-    const parentDir = path.dirname(dirPath);
-    if (parentDir === dirPath)
-      return void 0;
-    dirPath = parentDir;
+  if (!content[targetKey]) {
+    content[targetKey] = {};
   }
-}
-function getWorkspaceAtDir(dir) {
-  const workspacePackageJson = path.resolve(dir, "package.json");
-  try {
-    const packageJson = JSON.parse(
-      fs.readFileSync(workspacePackageJson, "utf-8")
+  content[targetKey][dependencyName] = versionRange;
+  yield* writePackageJson(workspace, JSON.stringify(content)).pipe(
+    Effect.mapError(
+      (e) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to write package.json",
+        cause: e
+      })
+    )
+  );
+});
+const formatPackageJson = (workspace) => Effect.gen(function* () {
+  const filePath = joinPath(workspace.path, "package.json");
+  const content = yield* readFile(filePath).pipe(
+    Effect.mapError(
+      (cause) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to read package.json",
+        cause
+      })
+    )
+  );
+  yield* writePackageJson(workspace, content).pipe(
+    Effect.mapError(
+      (cause) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to write package.json",
+        cause
+      })
+    )
+  );
+});
+const removeDependency = (options) => Effect.gen(function* () {
+  const { workspace, dependencyName } = options;
+  const content = yield* readPackageJson(workspace).pipe(
+    Effect.mapError(
+      (e) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to read package.json",
+        cause: e
+      })
+    )
+  );
+  let removed = false;
+  for (const key of ALL_DEPENDENCY_KEYS) {
+    const deps = content[key];
+    if (deps && dependencyName in deps) {
+      delete deps[dependencyName];
+      removed = true;
+      if (Object.keys(deps).length === 0) {
+        delete content[key];
+      }
+    }
+  }
+  if (!removed) {
+    return yield* Effect.fail(
+      new DependencyNotFoundError({
+        workspace: workspace.name,
+        dependencyName
+      })
     );
-    const parsedPackageJson = packageJsonSchema.parse(packageJson);
-    return {
-      location: dir,
-      packageJSON: parsedPackageJson,
-      workspace: transformPackageJsonToWorkspace(packageJson)
-    };
-  } catch {
-    return void 0;
   }
+  yield* writePackageJson(workspace, JSON.stringify(content)).pipe(
+    Effect.mapError(
+      (e) => new ModifyError({
+        workspace: workspace.name,
+        message: "Failed to write package.json",
+        cause: e
+      })
+    )
+  );
+});
+function groupDependenciesByPackage(analysis, filterBySources = ["npm"]) {
+  const sourceSet = new Set(filterBySources);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const workspace of analysis.workspaces) {
+    for (const dep of workspace.dependencies) {
+      if (!sourceSet.has(dep.source)) {
+        continue;
+      }
+      const instance = {
+        workspace: workspace.name,
+        versionRange: dep.versionRange,
+        type: dep.dependencyType
+      };
+      const existing = grouped.get(dep.name);
+      if (existing) {
+        existing.push(instance);
+      } else {
+        grouped.set(dep.name, [instance]);
+      }
+    }
+  }
+  return Array.from(grouped.entries()).map(([name, instances]) => ({ name, instances })).sort((a, b) => a.name.localeCompare(b.name));
 }
-
-// domain/implementation/filesystem/sync-dependency-versions.ts
-import fs2 from "fs";
-import path2 from "path";
-import { sortPackageJson } from "sort-package-json";
-var syncDependencyVersions = (monorepoInfo, updates) => {
-  try {
-    const updatedWorkspaces = /* @__PURE__ */ new Set();
-    for (const update of updates) {
-      for (const { packageJSON, workspace } of monorepoInfo.workspaces) {
-        if (packageJSON.dependencies?.[update.dependencyName]) {
-          packageJSON.dependencies[update.dependencyName] = update.versionRange;
-          updatedWorkspaces.add(workspace.name);
-        }
-        if (packageJSON.devDependencies?.[update.dependencyName]) {
-          packageJSON.devDependencies[update.dependencyName] = update.versionRange;
-          updatedWorkspaces.add(workspace.name);
-        }
-        if (packageJSON.peerDependencies?.[update.dependencyName]) {
-          packageJSON.peerDependencies[update.dependencyName] = update.versionRange;
-          updatedWorkspaces.add(workspace.name);
+class InvalidSemverRangeError extends Data.TaggedError(
+  "InvalidSemverRangeError"
+) {
+}
+const isPinnedVersion = (versionRange) => semver.valid(versionRange.trim()) !== null;
+function detectUnpinnedVersions(analysis) {
+  return Effect.sync(() => {
+    const violations = [];
+    const dependenciesByPackage = groupDependenciesByPackage(analysis, ["npm"]);
+    for (const dep of dependenciesByPackage) {
+      for (const instance of dep.instances) {
+        if (instance.type === "peerDependency") continue;
+        if (!isPinnedVersion(instance.versionRange)) {
+          violations.push({
+            _tag: "ViolationUnpinnedVersion",
+            package: dep.name,
+            workspace: instance.workspace,
+            message: `Version range "${instance.versionRange}" is not pinned`,
+            versionRange: instance.versionRange,
+            dependencyType: instance.type
+          });
         }
       }
     }
-    for (const {
-      location,
-      workspace,
-      packageJSON
-    } of monorepoInfo.workspaces) {
-      if (updatedWorkspaces.has(workspace.name)) {
-        fs2.writeFileSync(
-          path2.join(location, "package.json"),
-          sortPackageJson(JSON.stringify(packageJSON, null, 2))
-        );
+    return violations;
+  });
+}
+function detectVersionMismatches(analysis) {
+  return Effect.sync(() => {
+    const violations = [];
+    const dependenciesByPackage = groupDependenciesByPackage(analysis, ["npm"]);
+    for (const dep of dependenciesByPackage) {
+      const instances = dep.instances.filter((i) => i.type !== "peerDependency");
+      if (instances.length < 2) continue;
+      const versions = new Set(instances.map((i) => i.versionRange));
+      if (versions.size === 1) continue;
+      const versionList = Array.from(versions).join(", ");
+      const allVersions = Array.from(versions);
+      for (const instance of instances) {
+        violations.push({
+          _tag: "ViolationVersionMismatch",
+          package: dep.name,
+          workspace: instance.workspace,
+          message: `Multiple versions found: ${versionList}`,
+          versionRange: instance.versionRange,
+          dependencyType: instance.type,
+          allVersions
+        });
+      }
+    }
+    return violations;
+  });
+}
+function detectFormatPackageJson(analysis) {
+  return Effect.gen(function* () {
+    const violations = [];
+    for (const workspace of analysis.workspaces) {
+      const content = yield* getPackageJsonStr(workspace).pipe(
+        Effect.catchAll(() => Effect.succeed(null))
+      );
+      if (content === null) continue;
+      const sorted = sortPackageJson(content);
+      if (content !== sorted) {
+        violations.push({
+          _tag: "ViolationFormatPackageJson",
+          package: workspace.name,
+          workspace: workspace.name,
+          message: "package.json is not sorted"
+        });
       }
     }
-  } catch {
-    return { success: false };
+    return violations;
+  });
+}
+class Monoverse extends Effect.Service()("Monoverse", {
+  succeed: {
+    analyze: (startPath) => analyzeMonorepo(startPath),
+    validate: (analysis) => Effect.gen(function* () {
+      const mismatches = yield* detectVersionMismatches(analysis);
+      const unpinned = yield* detectUnpinnedVersions(analysis);
+      const formatting = yield* detectFormatPackageJson(analysis);
+      return [...mismatches, ...unpinned, ...formatting];
+    }),
+    addPackage: (options) => upsertDependency({
+      workspace: options.workspace,
+      dependencyName: options.packageName,
+      versionRange: options.versionRange,
+      dependencyType: options.dependencyType
+    }),
+    removePackage: (options) => removeDependency({
+      workspace: options.workspace,
+      dependencyName: options.packageName
+    }),
+    formatWorkspace: (workspace) => formatPackageJson(workspace),
+    formatAllWorkspaces: (analysis) => Effect.forEach(analysis.workspaces, formatPackageJson, {
+      discard: true
+    })
   }
-  return { success: true };
-};
-
-// domain/implementation/git/clone.ts
-import AdmZip from "adm-zip";
-import fs3, { createWriteStream } from "fs";
-import { mkdtemp, rm } from "fs/promises";
-import os from "os";
-import path3 from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-var downloadGitRepo = async (url) => {
-  const tempDir = await mkdtemp(path3.join(os.tmpdir(), "monoverse-"));
-  const outputPath = path3.join(tempDir, "github-zip.zip");
-  const outputDir = path3.join(tempDir, "github-extract");
-  await rm(outputDir, { recursive: true, force: true });
-  await rm(outputPath, { force: true });
-  const { ok } = await downloadZip(url, outputPath);
-  if (!ok) {
-    throw new Error("Failed to download the zip file");
+}) {
+}
+const tui = Command.make("tui", {}, () => Effect.void);
+const cwd = process.cwd();
+const findCurrentWorkspace = Effect.gen(function* () {
+  const monoverse2 = yield* Monoverse;
+  const analysis = yield* monoverse2.analyze(cwd);
+  const workspace = analysis.workspaces.find((ws) => cwd.startsWith(ws.path));
+  if (!workspace) {
+    return yield* Effect.fail(
+      new Error("Not inside a workspace. Run from within a workspace directory.")
+    );
   }
-  const zip = new AdmZip(outputPath);
-  zip.extractAllTo(outputDir, true);
-  return {
-    projectDir: await getInnerDirPath(outputDir),
-    cleanupDir: () => {
-      return rm(tempDir, { recursive: true, force: true });
-    }
+  return { analysis, workspace };
+});
+const toDependencyType = (type) => {
+  const map = {
+    dependency: "dependency",
+    dev: "devDependency",
+    peer: "peerDependency",
+    optional: "optionalDependency"
   };
+  return map[type];
 };
-async function downloadZip(url, outputPath) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    return { ok: false, error: "Failed to fetch the zip file" };
-  }
-  if (!response.body) {
-    return { ok: false, error: "Response body is empty" };
-  }
-  const nodeReadableStream = Readable.fromWeb(response.body);
-  await pipeline(nodeReadableStream, createWriteStream(outputPath));
-  return { ok: true };
-}
-var getInnerDirPath = (dirPath) => {
-  return new Promise((resolve, reject) => {
-    const files = fs3.readdirSync(dirPath);
-    const innerDir = files.find((f) => {
-      console.log("f", path3.join(dirPath, f));
-      return fs3.statSync(path3.join(dirPath, f)).isDirectory();
-    });
-    if (!innerDir) {
-      return reject("No inner directory found");
-    }
-    resolve(path3.join(dirPath, innerDir));
+const packageArg$1 = Args.text({ name: "package" });
+const typeOption = Options.choice("type", [
+  "dependency",
+  "dev",
+  "peer",
+  "optional"
+]).pipe(Options.withAlias("t"), Options.withDefault("dependency"));
+const versionOption = Options.text("version").pipe(
+  Options.withAlias("v"),
+  Options.withDefault("latest")
+);
+const handler$1 = ({
+  package: pkg,
+  type,
+  version
+}) => Effect.gen(function* () {
+  const monoverse2 = yield* Monoverse;
+  const { workspace } = yield* findCurrentWorkspace;
+  const dependencyType = toDependencyType(type);
+  yield* monoverse2.addPackage({
+    packageName: pkg,
+    versionRange: version,
+    dependencyType,
+    workspace
   });
+  yield* Console.log(`Added ${pkg}@${version} to ${workspace.name}`);
+});
+const add = Command.make(
+  "add",
+  { package: packageArg$1, type: typeOption, version: versionOption },
+  handler$1
+);
+const packageArg = Args.text({ name: "package" });
+const handler = ({ package: pkg }) => Effect.gen(function* () {
+  const monoverse2 = yield* Monoverse;
+  const { workspace } = yield* findCurrentWorkspace;
+  yield* monoverse2.removePackage({
+    packageName: pkg,
+    workspace
+  });
+  yield* Console.log(`Removed ${pkg} from ${workspace.name}`);
+});
+const remove = Command.make("remove", { package: packageArg }, handler);
+const rm = Command.make("rm", { package: packageArg }, handler);
+const deleteCmd = Command.make("delete", { package: packageArg }, handler);
+const format = Command.make(
+  "format",
+  {},
+  () => Effect.gen(function* () {
+    const monoverse2 = yield* Monoverse;
+    const analysis = yield* monoverse2.analyze(cwd);
+    yield* monoverse2.formatAllWorkspaces(analysis);
+    yield* Console.log(`Formatted ${analysis.workspaces.length} workspaces`);
+  })
+);
+const c = {
+  reset: "\x1B[0m",
+  red: "\x1B[38;2;238;136;136m",
+  green: "\x1B[38;2;136;238;136m",
+  gray: "\x1B[38;2;136;136;136m",
+  dim: "\x1B[38;2;102;102;102m",
+  white: "\x1B[38;2;255;255;255m"
 };
-
-// trpc/functionality/overview.ts
-var getOverview = (dirPath) => {
-  const monorepoInfo = getMonorepoInfo(dirPath);
-  if (!monorepoInfo) {
-    return null;
-  }
-  const workspacesMap = monorepoInfo.workspaces.reduce(
-    (acc, { workspace }) => {
-      acc[workspace.name] = workspace;
-      return acc;
-    },
-    {}
+const formatViolations = (violations, workspaces, root) => {
+  const pathByName = new Map(
+    workspaces.map((w) => [
+      w.name,
+      w.path === root ? "." : w.path.replace(root + "/", "")
+    ])
   );
-  const dependencyLinks = monorepoInfo.workspaces.map(({ workspace }) => {
-    const internalDependencies = workspace.dependencies.filter((dep) => !!workspacesMap[dep.name]).map((v) => v.name);
-    return {
-      workspaceName: workspace.name,
-      internalDependencies
-    };
-  });
-  const getDependencyType = (workspace) => {
-    const hasDecendants = dependencyLinks.find((v) => v.workspaceName === workspace).internalDependencies.length > 0;
-    const hasAncestors = dependencyLinks.filter((v) => {
-      if (v.workspaceName === workspace)
-        return false;
-      if (v.internalDependencies.includes(workspace))
-        return true;
-      return false;
-    }).length > 0;
-    if (hasDecendants && hasAncestors) {
-      return "internal";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    if (!grouped.has(v.workspace)) {
+      grouped.set(v.workspace, /* @__PURE__ */ new Map());
     }
-    if (hasAncestors) {
-      return "leaf";
+    const pkgMap = grouped.get(v.workspace);
+    if (!pkgMap.has(v.package)) {
+      pkgMap.set(v.package, []);
     }
-    return "standalone";
-  };
-  return dependencyLinks.map((link) => {
-    return {
-      ...link,
-      dependenciesCount: workspacesMap[link.workspaceName].dependencies.length,
-      type: getDependencyType(link.workspaceName)
-    };
-  });
-};
-
-// trpc/functionality/sync-updates.ts
-var getSyncUpdates = (dirPath) => {
-  const monorepoInfo = getMonorepoInfo(dirPath);
-  if (!monorepoInfo) {
-    return null;
+    pkgMap.get(v.package).push(v);
   }
-  const workspaceMap = monorepoInfo.workspaces.reduce(
-    (acc, { workspace }) => {
-      acc[workspace.name] = true;
-      return acc;
-    },
-    {}
-  );
-  return monorepoInfo.workspaces.flatMap(({ workspace }) => {
-    return workspace.dependencies.map((dependency) => {
-      return {
-        dependencyName: dependency.name,
-        dependencyType: dependency.type,
-        workspaceName: workspace.name,
-        versionRange: dependency.versionRange,
-        isInternalDependency: !!workspaceMap[dependency.name]
-      };
-    });
-  });
-};
-
-// trpc/functionality/sync-versions.ts
-var syncVersions = (dirPath, updates) => {
-  const monorepoInfo = getMonorepoInfo(dirPath);
-  if (!monorepoInfo) {
-    return null;
+  const formatDetail = (v) => {
+    const tag = v._tag.replace("Violation", "");
+    if (v._tag === "ViolationVersionMismatch" && v.allVersions) {
+      return `${tag} (${v.allVersions.join(", ")})`;
+    }
+    if (v._tag === "ViolationUnpinnedVersion" && v.versionRange) {
+      return `${tag} (${v.versionRange})`;
+    }
+    return tag;
+  };
+  const lines = [];
+  for (const [workspace, packages] of grouped) {
+    const path = pathByName.get(workspace) ?? "";
+    lines.push(`${c.white}${workspace}${c.dim} (${path})${c.reset}`);
+    for (const [pkg, vList] of packages) {
+      const details = vList.map(formatDetail).join(", ");
+      lines.push(`${c.gray}  ${pkg.padEnd(28)}${c.red}${details}${c.reset}`);
+    }
   }
-  return syncDependencyVersions(monorepoInfo, updates);
+  return lines.join("\n");
 };
-
-// trpc/setup.ts
-import { initTRPC } from "@trpc/server";
-var t = initTRPC.create();
-var router = t.router;
-var publicProcedure = t.procedure;
-
-// trpc/server.ts
-var appRouter = router({
-  helloWorld: publicProcedure.query(async () => {
-    return "Hello, World!";
-  }),
-  getOverview: publicProcedure.input(
-    z5.object({
-      type: z5.union([z5.literal("filepath"), z5.literal("url")]),
-      value: z5.string()
-    })
-  ).query(async ({ input }) => {
-    const { type, value } = input;
-    if (type === "filepath") {
-      const dirPath = value;
-      const result = getOverview(dirPath);
-      return {
-        success: true,
-        result
-      };
-    } else {
-      const { projectDir, cleanupDir } = await downloadGitRepo(value);
-      const result = getOverview(projectDir);
-      await cleanupDir();
-      return {
-        success: true,
-        result
-      };
-    }
-  }),
-  getSyncUpdates: publicProcedure.input(
-    z5.object({
-      type: z5.union([z5.literal("filepath"), z5.literal("url")]),
-      value: z5.string()
-    })
-  ).query(async ({ input }) => {
-    const { type, value } = input;
-    if (type === "filepath") {
-      const dirPath = value;
-      const result = getSyncUpdates(dirPath);
-      return {
-        success: true,
-        result
-      };
-    } else {
-      const { projectDir, cleanupDir } = await downloadGitRepo(value);
-      const result = getSyncUpdates(projectDir);
-      await cleanupDir();
-      return {
-        success: true,
-        result
-      };
+const lint = Command.make(
+  "lint",
+  {},
+  () => Effect.gen(function* () {
+    const monoverse2 = yield* Monoverse;
+    const analysis = yield* monoverse2.analyze(cwd);
+    const violations = yield* monoverse2.validate(analysis);
+    if (violations.length === 0) {
+      yield* Console.log(`${c.green}No issues found${c.reset}`);
+      return;
     }
-  }),
-  syncDependencies: publicProcedure.input(
-    z5.object({
-      dirPath: z5.string(),
-      updates: z5.array(
-        z5.object({
-          dependencyName: z5.string(),
-          versionRange: z5.string()
-        })
-      )
-    })
-  ).mutation(async ({ input }) => {
-    const result = syncVersions(input.dirPath, input.updates);
-    return result;
+    yield* Console.error(
+      `${c.red}Found ${violations.length} issues${c.reset}
+`
+    );
+    yield* Console.error(
+      formatViolations(violations, analysis.workspaces, analysis.root)
+    );
+    yield* Effect.sync(() => process.exit(1));
   })
+);
+const monoverse = Command.make(
+  "monoverse",
+  {},
+  () => Console.log("Use --help to see available commands")
+);
+const command = monoverse.pipe(
+  Command.withSubcommands([tui, add, remove, rm, deleteCmd, format, lint])
+);
+const cli = Command.run(command, {
+  name: "monoverse",
+  version: "v0.0.12"
 });
-
-// cli.ts
-var __DIRNAME = fileURLToPath(new URL(".", import.meta.url));
-var app = express();
-app.use(
-  "/api",
-  trpcExpress.createExpressMiddleware({
-    router: appRouter
+const MainLayer = Layer.mergeAll(
+  NodeContext.layer,
+  Monoverse.Default,
+  CliConfig.layer({
+    isCaseSensitive: true,
+    showBuiltIns: false,
+    showTypes: false
   })
 );
-app.use(express.static("dist"));
-app.get("*", (_, res) => {
-  res.sendFile(path4.join(__DIRNAME, "dist", "index.html"));
-});
-var port = 21212;
-app.listen(port, () => {
-  console.log(`Server listening... http://localhost:${port}/`);
-});
+cli(process.argv).pipe(Effect.provide(MainLayer), NodeRuntime.runMain);