@ozyman42/ozy-cli 0.4.8 → 0.4.9-darwin-arm64.0

package/src/modules/cli/git/submodule/fix.ts

@@ -1,298 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { readFile, writeFile, rename, mkdir, rm } from "node:fs/promises";
-import { resolve, join, dirname, relative } from "node:path";
-import { Effect } from "effect";
-import type { Gitmodules } from "./gitmodules";
-import type { ModuleDirInfo, IndexGitlink } from "./git-state";
-import { resolveGitDir } from "./resolve-git-dir";
-
-export interface Fix {
-  location: string[];
-  action: "synced" | "deleted";
-  detail?: string;
-}
-
-function parseConfigSubmoduleValues(content: string): Map<string, { url?: string; path?: string }> {
-  const entries = new Map<string, { url?: string; path?: string }>();
-  let current: { url?: string; path?: string } | null = null;
-
-  for (const line of content.split("\n")) {
-    const headerMatch = line.match(/^\[submodule "(.+)"\]$/);
-    if (headerMatch) {
-      current = {};
-      entries.set(headerMatch[1]!, current);
-      continue;
-    }
-    if (!current) continue;
-    const kvMatch = line.match(/^\s+(\w+)\s*=\s*(.+)$/);
-    if (!kvMatch) continue;
-    const [, key, value] = kvMatch;
-    if (key === "url" || key === "path") current[key] = value!.trim();
-  }
-
-  return entries;
-}
-
-// Drops any stanza whose name isn't a valid submodule, is a stale duplicate, or
-// has url/path values that no longer match .gitmodules — so it can be re-added fresh.
-function removeExtraConfigSubmodules(content: string, modules: Gitmodules): { result: string; removed: string[] } {
-  const byName = new Map(modules.list.map((m) => [m.name, m]));
-  const existingValues = parseConfigSubmoduleValues(content);
-
-  const staleNames = new Set<string>();
-  for (const [name, values] of existingValues) {
-    const m = byName.get(name);
-    if (!m || values.url !== m.url || values.path !== m.path) staleNames.add(name);
-  }
-
-  const removed: string[] = [];
-  const seen = new Set<string>();
-  const output: string[] = [];
-  let dropping = false;
-
-  for (const line of content.split("\n")) {
-    const submoduleMatch = line.match(/^\[submodule "(.+)"\]$/);
-    if (submoduleMatch) {
-      const name = submoduleMatch[1]!;
-      if (!staleNames.has(name) && !seen.has(name)) {
-        seen.add(name);
-        dropping = false;
-      } else {
-        removed.push(name);
-        dropping = true;
-      }
-    } else if (/^\[/.test(line)) {
-      dropping = false;
-    }
-    if (!dropping) output.push(line);
-  }
-
-  return { result: output.join("\n"), removed };
-}
-
-async function spawnGit(args: string[], cwd: string): Promise<void> {
-  const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
-  const code = await proc.exited;
-  if (code !== 0) {
-    const err = await new Response(proc.stderr).text();
-    throw new Error(`git ${args.join(" ")} exited with code ${code}\n${err.trim()}`);
-  }
-}
-
-export function fixGitConfig(repoRoot: string, modules: Gitmodules): Effect.Effect<Fix[], string> {
-  return Effect.tryPromise({
-    try: async () => {
-      const gitDir = await resolveGitDir(repoRoot);
-      const configPath = resolve(gitDir, "config");
-      const content = await readFile(configPath, "utf8");
-      const { result: afterRemoval, removed } = removeExtraConfigSubmodules(content, modules);
-
-      const existingNames = new Set<string>(
-        [...afterRemoval.matchAll(/^\[submodule "(.+)"\]$/gm)].map((m) => m[1]!)
-      );
-      const missing = modules.list.filter((m) => !existingNames.has(m.name));
-
-      let result = afterRemoval;
-      for (const m of missing) {
-        if (!result.endsWith("\n")) result += "\n";
-        result += `[submodule "${m.name}"]\n\tactive = true\n\turl = ${m.url}\n\tpath = ${m.path}\n`;
-      }
-
-      if (removed.length === 0 && missing.length === 0) return [];
-      await writeFile(configPath, result, "utf8");
-      return [
-        ...removed.map((name) => ({ location: [".git", "config", name], action: "deleted" as const })),
-        ...missing.map((m) => ({ location: [".git", "config", m.name], action: "synced" as const })),
-      ];
-    },
-    catch: (e) => e instanceof Error ? e.message : String(e),
-  });
-}
-
-const GIT_MODULES_MARKER = ".git/modules/";
-
-// A stale redirect's leading "../" prefix can be wrong after a path rename, but the
-// suffix starting at ".git/modules/" always describes a location under the single
-// top-level .git, at any nesting depth — so anchor on that marker instead of trusting
-// the relative resolution.
-function recoverStaleGitDirTarget(redirectContent: string, topLevelRoot: string): string | undefined {
-  const match = redirectContent.match(/^gitdir:\s*(.+)$/m);
-  if (!match) return undefined;
-  const idx = match[1]!.indexOf(GIT_MODULES_MARKER);
-  if (idx === -1) return undefined;
-  return resolve(topLevelRoot, match[1]!.slice(idx).trim());
-}
-
-// Moves existing git data into moduleGitDir instead of abandoning it, whether it's a
-// standalone clone's literal .git directory, or a redirect file (even a stale one
-// left over from a path rename) pointing at git data that still exists.
-async function migrateExistingGitDir(workingTreeDir: string, moduleGitDir: string, topLevelRoot: string): Promise<boolean> {
-  const dotGit = join(workingTreeDir, ".git");
-  if (!existsSync(dotGit)) return false;
-
-  if (statSync(dotGit).isDirectory()) {
-    await mkdir(dirname(moduleGitDir), { recursive: true });
-    await rename(dotGit, moduleGitDir);
-    return true;
-  }
-
-  const content = await readFile(dotGit, "utf8");
-  const target = recoverStaleGitDirTarget(content, topLevelRoot);
-  if (!target || target === moduleGitDir || !existsSync(target)) return false;
-  await mkdir(dirname(moduleGitDir), { recursive: true });
-  await rename(target, moduleGitDir);
-  return true;
-}
-
-export function fixModuleDirs(
-  repoRoot: string,
-  modules: Gitmodules,
-  moduleDirs: ModuleDirInfo[],
-  orphanModuleDirs: string[],
-  topLevelRoot: string,
-): Effect.Effect<Fix[], string> {
-  return Effect.tryPromise({
-    try: async () => {
-      const fixes: Fix[] = [];
-      const modulesRoot = resolve(await resolveGitDir(repoRoot), "modules");
-
-      // Establish each module's git dir (migrating existing data if any exists
-      // anywhere) before the orphan cleanup below runs, so nothing real gets deleted
-      // out from under a path rename.
-      for (const m of modules.list) {
-        const workingTreeDir = resolve(repoRoot, m.path);
-        const moduleGitDir = join(modulesRoot, m.path);
-        if (!existsSync(workingTreeDir)) continue;
-
-        const alreadyEstablished = existsSync(moduleGitDir);
-        let freshlyCloned = false;
-
-        if (!alreadyEstablished) {
-          const migrated = await migrateExistingGitDir(workingTreeDir, moduleGitDir, topLevelRoot);
-          if (migrated) {
-            fixes.push({ location: [".git", "modules", ...m.path.split("/")], action: "synced", detail: "migrated" });
-          } else {
-            await mkdir(dirname(moduleGitDir), { recursive: true });
-            await spawnGit(["clone", "--bare", m.url, moduleGitDir], repoRoot);
-            fixes.push({ location: [".git", "modules", ...m.path.split("/")], action: "synced", detail: "initialized" });
-            freshlyCloned = true;
-          }
-        }
-
-        if (freshlyCloned) {
-          const configFile = join(moduleGitDir, "config");
-          const worktree = relative(moduleGitDir, workingTreeDir);
-          await spawnGit(["config", "-f", configFile, "core.bare", "false"], repoRoot);
-          await spawnGit(["config", "-f", configFile, "core.worktree", worktree], repoRoot);
-        }
-
-        // A bare clone (whether just made above, or left over from a prior buggy
-        // run) never gets an index — populate it from HEAD whenever it's missing,
-        // not only right after we ourselves created it.
-        if (!existsSync(join(moduleGitDir, "index"))) {
-          const headCheck = Bun.spawn(["git", "--git-dir", moduleGitDir, "rev-parse", "--verify", "HEAD"], { stdout: "ignore", stderr: "ignore" });
-          if ((await headCheck.exited) !== 0) await spawnGit(["--git-dir", moduleGitDir, "fetch", "origin"], repoRoot);
-          await spawnGit(["--git-dir", moduleGitDir, "read-tree", "HEAD"], repoRoot);
-          fixes.push({ location: [".git", "modules", ...m.path.split("/")], action: "synced", detail: "populated index" });
-        }
-
-        // Always re-point the working tree's .git redirect — never assume an
-        // existing file is already correct.
-        const dotGit = join(workingTreeDir, ".git");
-        const rel = relative(workingTreeDir, moduleGitDir);
-        const desired = `gitdir: ${rel}\n`;
-        const current = existsSync(dotGit) && !statSync(dotGit).isDirectory()
-          ? await readFile(dotGit, "utf8")
-          : undefined;
-        if (current !== desired) {
-          await writeFile(dotGit, desired, "utf8");
-          fixes.push({ location: [...m.path.split("/"), ".git"], action: "synced" });
-        }
-      }
-
-      const gmByPath = new Map(modules.list.map((m) => [m.path, m]));
-
-      for (const d of moduleDirs) {
-        const gm = gmByPath.get(d.relativePath);
-        if (!gm && existsSync(join(modulesRoot, d.relativePath))) {
-          await rm(join(modulesRoot, d.relativePath), { recursive: true, force: true });
-          fixes.push({ location: [".git", "modules", ...d.relativePath.split("/")], action: "deleted" });
-        }
-      }
-
-      for (const rel of orphanModuleDirs) {
-        if (existsSync(join(modulesRoot, rel))) {
-          await rm(join(modulesRoot, rel), { recursive: true, force: true });
-          fixes.push({ location: [".git", "modules", ...rel.split("/")], action: "deleted" });
-        }
-      }
-
-      for (const m of modules.list) {
-        const moduleGitDir = join(modulesRoot, m.path);
-        if (!existsSync(moduleGitDir)) continue;
-        const configFile = join(moduleGitDir, "config");
-
-        const readConfig = (key: string) =>
-          Bun.spawn(["git", "config", "-f", configFile, key], { cwd: repoRoot, stdout: "pipe", stderr: "pipe" });
-
-        const [currentUrl, currentWorktree] = await Promise.all([
-          new Response(readConfig("remote.origin.url").stdout).text().then(t => t.trim()),
-          new Response(readConfig("core.worktree").stdout).text().then(t => t.trim()),
-        ]);
-
-        const worktree = relative(moduleGitDir, resolve(repoRoot, m.path));
-
-        if (currentUrl !== m.url) {
-          await spawnGit(["config", "-f", configFile, "remote.origin.url", m.url], repoRoot);
-          fixes.push({ location: [".git", "modules", ...m.path.split("/"), "config"], action: "synced", detail: "remote.origin.url" });
-        }
-        if (currentWorktree !== worktree) {
-          await spawnGit(["config", "-f", configFile, "core.worktree", worktree], repoRoot);
-          fixes.push({ location: [".git", "modules", ...m.path.split("/"), "config"], action: "synced", detail: "core.worktree" });
-        }
-      }
-
-      return fixes;
-    },
-    catch: (e) => e instanceof Error ? e.message : String(e),
-  });
-}
-
-export function fixIndexGitlinks(
-  repoRoot: string,
-  modules: Gitmodules,
-  currentIndex: IndexGitlink[],
-): Effect.Effect<Fix[], string> {
-  return Effect.tryPromise({
-    try: async () => {
-      const currentShas = new Map(currentIndex.map((e) => [e.path, e.commit]));
-      const validPaths = new Set(modules.list.map((m) => m.path));
-      const fixes: Fix[] = [];
-
-      for (const entry of currentIndex) {
-        if (!validPaths.has(entry.path)) {
-          await spawnGit(["update-index", "--force-remove", entry.path], repoRoot);
-          fixes.push({ location: [".git", "index"], action: "deleted", detail: entry.path });
-        }
-      }
-
-      for (const m of modules.list) {
-        const workingTree = resolve(repoRoot, m.path);
-        if (!existsSync(workingTree)) continue;
-
-        const shaProc = Bun.spawn(["git", "rev-parse", "HEAD"], { cwd: workingTree, stdout: "pipe", stderr: "pipe" });
-        const sha = (await new Response(shaProc.stdout).text()).trim();
-        if (!/^[0-9a-f]{40}$/.test(sha)) continue;
-
-        const current = currentShas.get(m.path);
-        await spawnGit(["update-index", "--add", "--cacheinfo", `160000,${sha},${m.path}`], repoRoot);
-        if (current !== sha) {
-          fixes.push({ location: [".git", "index"], action: "synced", detail: `${m.path}: ${sha.slice(0, 8)}` });
-        }
-      }
-
-      return fixes;
-    },
-    catch: (e) => e instanceof Error ? e.message : String(e),
-  });
-}

package/src/modules/cli/git/submodule/git-state.ts

@@ -1,217 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import { Effect, Option } from "effect";
-import { resolveGitDir } from "./resolve-git-dir";
-
-// --- types ---
-
-export interface GitConfigSubmodule {
-  name: string;
-  url?: string;
-  path?: string;
-  active?: boolean;
-}
-
-export interface ModuleDirInfo {
-  /** Path relative to .git/modules/ */
-  relativePath: string;
-  /** URL from this module dir's own git config [remote "origin"] */
-  remoteUrl?: string;
-}
-
-export interface WorkingTreeGitEntry {
-  /** Submodule path relative to repo root */
-  path: string;
-  /** Whether .git at this path is a gitdir-redirect file, a full directory, or absent */
-  type: "file" | "dir" | "missing";
-  /** Content of the gitdir: line when type === "file" */
-  gitdirTarget?: string;
-  /** Result of `git remote get-url origin` run inside the working tree dir */
-  remote?: string | { error: string };
-  /** Result of `git rev-parse HEAD` run inside the working tree dir */
-  headCommit?: string | { error: string };
-}
-
-export interface IndexGitlink {
-  path: string;
-  commit: string;
-}
-
-export interface GitState {
-  /** Submodule stanzas found in .git/config */
-  config: GitConfigSubmodule[];
-  /** Git dirs found under .git/modules/, each with their remote URL */
-  moduleDirs: ModuleDirInfo[];
-  /** Dirs under .git/modules/ that contain no HEAD file and aren't prefixes of any known module path */
-  orphanModuleDirs: string[];
-  /** Gitlink entries recorded in the index (mode 160000) */
-  index: IndexGitlink[];
-  /** State of .git file/dir in each known submodule working tree path */
-  workingTree: WorkingTreeGitEntry[];
-}
-
-// --- parsers ---
-
-function parseGitConfig(content: string): GitConfigSubmodule[] {
-  const entries: GitConfigSubmodule[] = [];
-  let current: Partial<GitConfigSubmodule> | null = null;
-
-  for (const line of content.split("\n")) {
-    const headerMatch = line.match(/^\[submodule "(.+)"\]$/);
-    if (headerMatch) {
-      if (current?.name) entries.push(current as GitConfigSubmodule);
-      current = { name: headerMatch[1] };
-      continue;
-    }
-    if (!current) continue;
-    const kvMatch = line.match(/^\s+(\w+)\s*=\s*(.+)$/);
-    if (!kvMatch) continue;
-    const [, key, value] = kvMatch;
-    if (key === "url") current.url = value!.trim();
-    else if (key === "path") current.path = value!.trim();
-    else if (key === "active") current.active = value!.trim() === "true";
-  }
-  if (current?.name) entries.push(current as GitConfigSubmodule);
-  return entries;
-}
-
-function parseIndexGitlinks(output: string): IndexGitlink[] {
-  return output
-    .split("\n")
-    .filter((l) => l.startsWith("160000 "))
-    .map((line) => {
-      const match = line.match(/^160000 ([0-9a-f]{40}) \d\t(.+)$/);
-      if (!match) throw new Error(`Unexpected ls-files line: ${line}`);
-      return { commit: match[1]!, path: match[2]! };
-    });
-}
-
-/**
- * Recursively scans .git/modules/, returning:
- * - gitDirs: paths of real git dirs (contain a HEAD file)
- * - orphanDirs: paths that are neither a git dir nor a prefix of any known module path
- */
-function scanModuleDirs(
-  root: string,
-  modulePaths: Set<string>,
-  rel = "",
-): { gitDirs: string[]; orphanDirs: string[] } {
-  const gitDirs: string[] = [];
-  const orphanDirs: string[] = [];
-  if (!existsSync(root)) return { gitDirs, orphanDirs };
-
-  for (const entry of readdirSync(root)) {
-    const abs = join(root, entry);
-    if (!statSync(abs).isDirectory()) continue;
-    const relPath = rel ? `${rel}/${entry}` : entry;
-
-    if (existsSync(join(abs, "HEAD"))) {
-      gitDirs.push(relPath);
-    } else {
-      const isPrefix = [...modulePaths].some((p) => p.startsWith(relPath + "/"));
-      if (isPrefix) {
-        const sub = scanModuleDirs(abs, modulePaths, relPath);
-        gitDirs.push(...sub.gitDirs);
-        orphanDirs.push(...sub.orphanDirs);
-      } else {
-        orphanDirs.push(relPath);
-      }
-    }
-  }
-
-  return { gitDirs, orphanDirs };
-}
-
-async function readModuleDirRemoteUrl(abs: string): Promise<Option.Option<string>> {
-  const configPath = join(abs, "config");
-  if (!existsSync(configPath)) return Option.none();
-  const content = await readFile(configPath, "utf8");
-  const match = content.match(/\[remote "origin"\][^\[]*\n\s+url\s*=\s*(.+)/);
-  return match?.[1] ? Option.some(match[1].trim()) : Option.none();
-}
-
-async function spawnGitInDir(args: string[], cwd: string): Promise<string | { error: string }> {
-  const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
-  const [code, out, err] = await Promise.all([
-    proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-  return code === 0 ? out.trim() : { error: err.trim().split("\n")[0]! };
-}
-
-async function readWorkingTreeEntry(repoRoot: string, subPath: string): Promise<WorkingTreeGitEntry> {
-  const workingTreeAbs = join(repoRoot, subPath);
-  const dotGit = join(workingTreeAbs, ".git");
-
-  let type: "file" | "dir" | "missing";
-  let gitdirTarget: string | undefined;
-
-  if (!existsSync(dotGit)) {
-    type = "missing";
-  } else if (statSync(dotGit).isDirectory()) {
-    type = "dir";
-  } else {
-    type = "file";
-    const content = await readFile(dotGit, "utf8");
-    const match = content.match(/^gitdir:\s*(.+)$/m);
-    gitdirTarget = match?.[1].trim();
-  }
-
-  if (!existsSync(workingTreeAbs)) return { path: subPath, type, gitdirTarget };
-
-  const [remote, headCommit] = await Promise.all([
-    spawnGitInDir(["remote", "get-url", "origin"], workingTreeAbs),
-    spawnGitInDir(["rev-parse", "HEAD"], workingTreeAbs),
-  ]);
-
-  return { path: subPath, type, gitdirTarget, remote, headCommit };
-}
-
-// --- main reader ---
-
-export function readGitState(repoRoot: string, extraPaths: string[] = []): Effect.Effect<GitState, string> {
-  return Effect.tryPromise({
-    try: async () => {
-      const gitDir = await resolveGitDir(repoRoot);
-
-      const [configContent, lsOutput] = await Promise.all([
-        readFile(resolve(gitDir, "config"), "utf8"),
-        new Response(
-          Bun.spawn(["git", "ls-files", "--stage"], { cwd: repoRoot, stdout: "pipe" }).stdout
-        ).text(),
-      ]);
-
-      const config = parseGitConfig(configContent);
-      const index = parseIndexGitlinks(lsOutput);
-
-      const modulePaths = new Set(extraPaths);
-      const modulesRoot = resolve(gitDir, "modules");
-      const { gitDirs: moduleDirPaths, orphanDirs: orphanModuleDirs } = scanModuleDirs(modulesRoot, modulePaths);
-      const moduleDirs = await Promise.all(
-        moduleDirPaths.map(async (rel) => {
-          const remoteUrlOption = await readModuleDirRemoteUrl(join(modulesRoot, rel));
-          return {
-            relativePath: rel,
-            remoteUrl: Option.isSome(remoteUrlOption) ? remoteUrlOption.value : undefined,
-          };
-        })
-      );
-
-      const allPaths = [
-        ...new Set([
-          ...index.map((e) => e.path),
-          ...config.flatMap((e) => (e.path ? [e.path] : [])),
-          ...extraPaths,
-        ]),
-      ];
-      const workingTree = await Promise.all(
-        allPaths.map((p) => readWorkingTreeEntry(repoRoot, p))
-      );
-
-      return { config, moduleDirs, orphanModuleDirs, index, workingTree };
-    },
-    catch: (e) => e instanceof Error ? e.message : String(e),
-  });
-}

package/src/modules/cli/git/submodule/gitmodules.ts

@@ -1,126 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { Effect } from "effect";
-import type { EffectGen } from "effective-modules";
-import { STANDARD_REMOTE_PREFIX } from "@/common/constants";
-
-export interface Submodule {
-  name: string;
-  path: string;
-  url: string;
-}
-
-// git@host:org/repo.git or git@host:repo.git
-const SSH_URL_RE = /^git@[^:]+:.+\.git$/;
-const SSH_URL_HOST_RE = /^git@[^:]+:(.+)$/;
-
-export class Gitmodules {
-  private constructor(
-    private readonly path: string,
-    private readonly repoRoot: string,
-    private readonly modules: Submodule[],
-    private readonly rawContent: string,
-  ) {
-    this.path;
-  }
-
-  public static *fromRepoRoot(repoRoot: string): EffectGen<Gitmodules, string> {
-    const path = resolve(repoRoot, ".gitmodules");
-
-    const content = yield* Effect.tryPromise({
-      try: () => readFile(path, "utf8"),
-      catch: (e) => e instanceof Error ? e.message : String(e),
-    });
-
-    const modules = Gitmodules
-      .parse(content)
-      .map(Gitmodules.normalizeRemote)
-      .sort((a, b) => a.name.localeCompare(b.name));
-
-    const serialized = modules
-      .map((m) => `[submodule "${m.name}"]\n\tpath = ${m.path}\n\turl = ${m.url}`)
-      .join("\n") + "\n";
-
-    const result = new Gitmodules(path, repoRoot, modules, serialized);
-    const errors = result.validate();
-    if (errors.length) {
-      return yield* Effect.fail(`Validation errors in .gitmodules:\n${errors.map(e => `  - ${e}`).join('\n')}`);
-    }
-
-    if (serialized !== content) {
-      yield* Effect.tryPromise({
-        try: () => writeFile(resolve(repoRoot, '.gitmodules'), serialized, 'utf8'),
-        catch: (e) => e instanceof Error ? e.message : String(e),
-      });
-      yield* Effect.log('Updated .gitmodules.');
-    }
-
-    return result;
-  }
-
-  private static parse(content: string): Submodule[] {
-    const modules: Submodule[] = [];
-    let current: Partial<Submodule> | null = null;
-
-    for (const line of content.split("\n")) {
-      const headerMatch = line.match(/^\[submodule "(.+)"\]$/);
-      if (headerMatch) {
-        if (current) modules.push(current as Submodule);
-        current = { name: headerMatch[1] };
-        continue;
-      }
-      const kvMatch = line.match(/^\s+(\w+)\s*=\s*(.+)$/);
-      if (kvMatch && current) {
-        const [, key, value] = kvMatch;
-        if (key === "path" || key === "url") current[key] = value.trim();
-      }
-    }
-    if (current) modules.push(current as Submodule);
-    return modules;
-  }
-
-  private static normalizeRemote(m: Submodule): Submodule {
-    if (m.url.startsWith(STANDARD_REMOTE_PREFIX)) return m;
-    const match = m.url.match(SSH_URL_HOST_RE);
-    // TODO: we should probably move this logic to be alongside validate
-    if (!match) return m; // malformed URL — left as-is, validate() will report it
-    const normalizedUrl = `${STANDARD_REMOTE_PREFIX}${match[1]}`;
-    console.warn(`- updating submodule "${m.name}" remote: ${m.url} -> ${normalizedUrl}`);
-    return { ...m, url: normalizedUrl };
-  }
-
-  get list(): readonly Submodule[] {
-    return this.modules;
-  }
-
-  get content(): string {
-    return this.rawContent;
-  }
-
-  private validate(): string[] {
-    const errors: string[] = [];
-    const names = new Set<string>();
-    const paths = new Set<string>();
-    const urls = new Set<string>();
-
-    for (const m of this.modules) {
-      if (names.has(m.name)) errors.push(`Duplicate name: "${m.name}"`);
-      else names.add(m.name);
-
-      if (paths.has(m.path)) errors.push(`Duplicate path: "${m.path}" (submodule "${m.name}")`);
-      else paths.add(m.path);
-
-      if (urls.has(m.url)) errors.push(`Duplicate url: "${m.url}" (submodule "${m.name}")`);
-      else urls.add(m.url);
-
-      if (!SSH_URL_RE.test(m.url))
-        errors.push(`Invalid url for "${m.name}": ${m.url}`);
-
-      if (!existsSync(resolve(this.repoRoot, m.path)))
-        errors.push(`Path does not exist for "${m.name}": ${m.path}`);
-    }
-
-    return errors;
-  }
-}