@ozyman42/ozy-cli 0.4.6-linux-x64.0 → 0.4.6

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

@@ -0,0 +1,217 @@
+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

@@ -0,0 +1,126 @@
+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;
+  }
+}

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

@@ -0,0 +1,256 @@
+import type { Gitmodules } from "./gitmodules";
+import type { GitState, ModuleDirInfo, IndexGitlink, WorkingTreeGitEntry } from "./git-state";
+import type { Fix } from "./fix";
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+const ok = `${GREEN}✓${RESET}`;
+const fail = (msg: string) => `${RED}✗ ${msg}${RESET}`;
+const fsName = (s: string) => `${CYAN}${s}${RESET}`;
+const key = (s: string) => `${DIM}${s}${RESET}`;
+
+interface Line {
+  label: string;
+  isKey?: boolean;  // dim key style instead of cyan fs style
+  value?: string;
+  status?: string;
+  children?: Line[];
+}
+
+function render(lines: Line[], prefix = ""): void {
+  for (let i = 0; i < lines.length; i++) {
+    const last = i === lines.length - 1;
+    const branch = last ? "└── " : "├── ";
+    const child = last ? "    " : "│   ";
+    const l = lines[i];
+    const label = l.isKey ? key(l.label) : fsName(l.label);
+    let out = `${prefix}${branch}${label}`;
+    if (l.value !== undefined) out += `: ${l.value}`;
+    if (l.status !== undefined) out += `  ${l.status}`;
+    console.log(out);
+    if (l.children?.length) render(l.children, prefix + child);
+  }
+}
+
+function buildPathTree(parts: string[], children: Line[]): Line {
+  if (parts.length === 1) return { label: parts[0], children };
+  return { label: parts[0], children: [buildPathTree(parts.slice(1), children)] };
+}
+
+function resultLine(label: string, result: string | { error: string } | undefined): Line {
+  if (result === undefined) return { label, isKey: true, status: fail("unknown") };
+  if (typeof result === "string") return { label, isKey: true, value: result };
+  return { label, isKey: true, status: fail(result.error) };
+}
+
+function moduleHasIssues(
+  m: { path: string; url: string },
+  cfg: { path?: string; url?: string } | undefined,
+  dir: ModuleDirInfo | undefined,
+  idx: IndexGitlink | undefined,
+  headSha: string | undefined,
+  wt: WorkingTreeGitEntry | undefined,
+): boolean {
+  if (!cfg) return true;
+  if (cfg.path !== m.path || cfg.url !== m.url) return true;
+  if (!dir) return true;
+  if (!idx) return true;
+  if (headSha && idx.commit !== headSha) return true;
+  if (!wt || wt.type === "missing" || wt.type === "dir") return true;
+  if (typeof wt.headCommit !== "string") return true;
+  if (typeof wt.remote !== "string" || wt.remote !== m.url) return true;
+  return false;
+}
+
+export function printSyncState(modules: Gitmodules, state: GitState): void {
+  const byName = new Map(state.config.map((c) => [c.name, c]));
+  const byPath = new Map(state.moduleDirs.map((d) => [d.relativePath, d]));
+  const byIndexPath = new Map(state.index.map((i) => [i.path, i]));
+  const byTreePath = new Map(state.workingTree.map((w) => [w.path, w]));
+  const modulePaths = new Set(modules.list.map((m) => m.path));
+  const moduleNames = new Set(modules.list.map((m) => m.name));
+
+  console.log("=== syncing submodules ===");
+
+  for (const m of modules.list) {
+    const cfg = byName.get(m.name);
+    const dir = byPath.get(m.path);
+    const idx = byIndexPath.get(m.path);
+    const wt = byTreePath.get(m.path);
+    const headSha = typeof wt?.headCommit === "string" ? wt.headCommit : undefined;
+
+    if (!moduleHasIssues(m, cfg, dir, idx, headSha, wt)) {
+      console.log(`${BOLD}[${m.name}]${RESET} ${ok}`);
+      continue;
+    }
+
+    console.log(`${BOLD}[${m.name}]${RESET}`);
+
+    // .gitmodules
+    const gitmodulesNode: Line = {
+      label: ".gitmodules",
+      children: [
+        { label: "path", isKey: true, value: m.path },
+        { label: "url", isKey: true, value: m.url },
+      ],
+    };
+
+    // .git/config
+    let configNode: Line;
+    if (!cfg) {
+      configNode = { label: "config", status: fail("missing") };
+    } else {
+      configNode = {
+        label: "config",
+        children: [
+          {
+            label: "path",
+            isKey: true,
+            value: cfg.path ?? "(missing)",
+            status: cfg.path === m.path ? ok : fail(`expected ${m.path}`),
+          },
+          {
+            label: "url",
+            isKey: true,
+            value: cfg.url ?? "(missing)",
+            status: cfg.url === m.url ? ok : fail(`expected ${m.url}`),
+          },
+        ],
+      };
+    }
+
+    // .git/modules
+    const modulesNode: Line = {
+      label: "modules",
+      children: [{ label: m.path, status: dir ? ok : fail("missing") }],
+    };
+
+    // .git/index
+    let indexNode: Line;
+    if (!idx) {
+      indexNode = { label: "index", status: fail("missing") };
+    } else {
+      const idxSha8 = idx.commit.slice(0, 8);
+      const matches = headSha && idx.commit === headSha;
+      const mismatches = headSha && idx.commit !== headSha;
+      indexNode = {
+        label: "index",
+        value: idxSha8,
+        status: matches ? ok : mismatches ? fail(`head is ${headSha.slice(0, 8)}`) : undefined,
+      };
+    }
+
+    const dotGitNode: Line = {
+      label: ".git",
+      children: [configNode, modulesNode, indexNode],
+    };
+
+    // working tree leaves
+    const wtLeaves: Line[] = [];
+
+    if (!wt || wt.type === "missing") {
+      wtLeaves.push({ label: ".git", status: fail("missing") });
+    } else if (wt.type === "dir") {
+      wtLeaves.push({ label: ".git", status: fail("directory (standalone clone)") });
+    } else {
+      wtLeaves.push({ label: ".git", value: `gitdir → ${wt.gitdirTarget}` });
+    }
+
+    if (wt) {
+      const head = headSha ?? wt.headCommit;
+      wtLeaves.push(resultLine("head", typeof head === "string" ? head.slice(0, 8) : head));
+
+      if (typeof wt.remote === "string") {
+        wtLeaves.push({
+          label: "remote",
+          isKey: true,
+          value: wt.remote,
+          status: wt.remote === m.url ? ok : fail(`expected ${m.url}`),
+        });
+      } else {
+        wtLeaves.push(resultLine("remote", wt.remote));
+      }
+    }
+
+    const workingTreeNode = buildPathTree(m.path.split("/"), wtLeaves);
+
+    render([gitmodulesNode, dotGitNode, workingTreeNode]);
+  }
+
+  // Stale entries
+  const staleConfig = state.config.filter((c) => !moduleNames.has(c.name));
+  const staleDirs = state.moduleDirs.filter((d) => !modulePaths.has(d.relativePath));
+  const staleIndex = state.index.filter((i) => !modulePaths.has(i.path));
+
+  if (staleConfig.length || staleDirs.length || state.orphanModuleDirs.length || staleIndex.length) {
+    console.log(`\n${RED}${BOLD}=== stale (not in .gitmodules) ===${RESET}`);
+    const staleNodes: Line[] = [];
+
+    if (staleConfig.length) {
+      staleNodes.push({
+        label: ".git/config",
+        children: staleConfig.map((c) => ({ label: c.name })),
+      });
+    }
+    if (staleDirs.length || state.orphanModuleDirs.length) {
+      staleNodes.push({
+        label: ".git/modules",
+        children: [
+          ...staleDirs.map((d) => ({ label: d.relativePath })),
+          ...state.orphanModuleDirs.map((d) => ({ label: d })),
+        ],
+      });
+    }
+    if (staleIndex.length) {
+      staleNodes.push({
+        label: ".git/index",
+        children: staleIndex.map((i) => ({ label: i.path, isKey: true, value: i.commit.slice(0, 8) })),
+      });
+    }
+
+    render(staleNodes);
+  }
+}
+
+type FixTree = Map<string, { subtree: FixTree; fixes: Fix[] }>;
+
+function addToFixTree(tree: FixTree, fix: Fix, depth = 0): void {
+  const seg = fix.location[depth];
+  if (!tree.has(seg)) tree.set(seg, { subtree: new Map(), fixes: [] });
+  const node = tree.get(seg)!;
+  if (depth === fix.location.length - 1) {
+    node.fixes.push(fix);
+  } else {
+    addToFixTree(node.subtree, fix, depth + 1);
+  }
+}
+
+function fixTreeToLines(tree: FixTree): Line[] {
+  const lines: Line[] = [];
+  for (const [label, { subtree, fixes }] of tree) {
+    const children = fixTreeToLines(subtree);
+    if (fixes.length > 0) {
+      for (const fix of fixes) {
+        const actionStr = fix.action === "deleted" ? `${RED}deleted${RESET}` : `${GREEN}synced${RESET}`;
+        const status = fix.detail ? `${actionStr}  ${fix.detail}` : actionStr;
+        lines.push({ label, status, children: children.length > 0 ? children : undefined });
+      }
+    } else {
+      lines.push({ label, children });
+    }
+  }
+  return lines;
+}
+
+export function printFixes(fixes: Fix[]): void {
+  if (fixes.length === 0) return;
+  const tree: FixTree = new Map();
+  for (const fix of fixes) addToFixTree(tree, fix);
+  console.log("\napplied fixes:");
+  render(fixTreeToLines(tree));
+}

package/src/modules/cli/git/submodule/resolve-git-dir.ts

@@ -0,0 +1,14 @@
+import { statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+// A submodule's .git is a redirect file ("gitdir: <relative path>"), not a directory —
+// resolve it to the real git dir so callers don't try to treat the file as a directory.
+export async function resolveGitDir(repoRoot: string): Promise<string> {
+  const dotGit = resolve(repoRoot, ".git");
+  if (statSync(dotGit).isDirectory()) return dotGit;
+  const content = await readFile(dotGit, "utf8");
+  const match = content.match(/^gitdir:\s*(.+)$/m);
+  if (!match) throw new Error(`Malformed .git file at ${dotGit}`);
+  return resolve(repoRoot, match[1]!.trim());
+}