@ozyman42/ozy-cli 0.4.6 → 0.4.7-darwin-x64.0

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;
-  }
-}

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

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

@@ -1,14 +0,0 @@
-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());
-}