letmecook 0.0.21 → 0.0.22

package/src/reference-repo.ts

@@ -1,288 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { mkdir, symlink, readlink, lstat, readdir, rm } from "node:fs/promises";
-import type { RepoSpec } from "./types";
-import { readProcessOutputWithBuffer } from "./utils/stream";
-
-const LETMECOOK_DIR = join(homedir(), ".letmecook");
-export const REFERENCES_DIR = join(LETMECOOK_DIR, "references");
-
-export interface RefreshResult {
-  repo: RepoSpec;
-  status: "updated" | "up-to-date" | "skipped" | "error";
-  reason?: string;
-}
-
-export type RefreshProgressStatus = "refreshing" | "updated" | "up-to-date" | "skipped" | "error";
-
-/**
- * Get the path where a reference repo should be cached.
- * Format: ~/.letmecook/references/{owner}/{name}/{branch|HEAD}
- */
-export function getReferencePath(repo: RepoSpec): string {
-  const branchDir = repo.branch || "HEAD";
-  return join(REFERENCES_DIR, repo.owner, repo.name, branchDir);
-}
-
-/**
- * Ensure the references directory exists.
- */
-export async function ensureReferencesDir(): Promise<void> {
-  await mkdir(REFERENCES_DIR, { recursive: true });
-}
-
-/**
- * Check if a path is a symlink.
- */
-export async function isSymlink(path: string): Promise<boolean> {
-  try {
-    const stats = await lstat(path);
-    return stats.isSymbolicLink();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Clone a repo to the reference cache if not already present.
- * Returns the path to the cached repo.
- */
-export async function ensureReferenceRepo(
-  repo: RepoSpec,
-  onProgress?: (status: "cloning" | "done" | "error", outputLines?: string[]) => void,
-): Promise<string> {
-  const refPath = getReferencePath(repo);
-
-  // Check if already cached
-  const gitDir = join(refPath, ".git");
-  const gitDirFile = Bun.file(gitDir);
-  if (await gitDirFile.exists()) {
-    onProgress?.("done", ["Already cached"]);
-    return refPath;
-  }
-
-  // Ensure parent directories exist
-  await mkdir(join(REFERENCES_DIR, repo.owner, repo.name), { recursive: true });
-
-  onProgress?.("cloning");
-
-  const url = `https://github.com/${repo.owner}/${repo.name}.git`;
-  const args = repo.branch
-    ? [
-        "git",
-        "clone",
-        "--depth",
-        "1",
-        "--single-branch",
-        "--branch",
-        repo.branch,
-        "--progress",
-        url,
-        refPath,
-      ]
-    : ["git", "clone", "--depth", "1", "--single-branch", "--progress", url, refPath];
-
-  const proc = Bun.spawn(args, {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const { success, output } = await readProcessOutputWithBuffer(proc, {
-    maxBufferLines: 5,
-    onBufferUpdate: (buffer) => onProgress?.("cloning", buffer),
-  });
-
-  if (!success) {
-    onProgress?.("error", output);
-    throw new Error(`Failed to clone reference repo ${repo.owner}/${repo.name}`);
-  }
-
-  onProgress?.("done", output);
-  return refPath;
-}
-
-/**
- * Refresh a cached reference repo with git pull.
- */
-export async function refreshReferenceRepo(
-  repo: RepoSpec,
-  onProgress?: (status: RefreshProgressStatus, outputLines?: string[]) => void,
-): Promise<RefreshResult> {
-  const refPath = getReferencePath(repo);
-
-  // Check if cached repo exists
-  const gitDir = join(refPath, ".git");
-  const gitDirFile = Bun.file(gitDir);
-  if (!(await gitDirFile.exists())) {
-    // Try to clone it
-    try {
-      await ensureReferenceRepo(repo, (status, lines) => {
-        if (status === "cloning") onProgress?.("refreshing", lines);
-        else if (status === "done") onProgress?.("updated", lines);
-        else onProgress?.("error", lines);
-      });
-      return { repo, status: "updated", reason: "newly cloned" };
-    } catch (error) {
-      return {
-        repo,
-        status: "error",
-        reason: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  onProgress?.("refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
-
-  const proc = Bun.spawn(["git", "-C", refPath, "pull", "--ff-only", "--depth", "1"], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-    maxBufferLines: 5,
-    onBufferUpdate: (buffer) => onProgress?.("refreshing", buffer),
-  });
-
-  if (!success) {
-    const reason = fullOutput.trim() || "git pull failed";
-    onProgress?.("error", output.length > 0 ? output : [reason]);
-    return { repo, status: "error", reason };
-  }
-
-  const normalized = fullOutput.toLowerCase();
-  const upToDate =
-    normalized.includes("already up to date") || normalized.includes("already up-to-date");
-
-  const status = upToDate ? "up-to-date" : "updated";
-  onProgress?.(status, output);
-  return { repo, status };
-}
-
-/**
- * Create a symlink from session directory to the cached reference repo.
- */
-export async function linkReferenceRepo(repo: RepoSpec, sessionPath: string): Promise<void> {
-  const refPath = getReferencePath(repo);
-  const linkPath = join(sessionPath, repo.dir);
-
-  // Check if link already exists and is valid
-  if (await isSymlink(linkPath)) {
-    try {
-      const target = await readlink(linkPath);
-      if (target === refPath) {
-        return; // Already correctly linked
-      }
-      // Remove incorrect symlink
-      await rm(linkPath);
-    } catch {
-      // Remove broken symlink
-      await rm(linkPath);
-    }
-  }
-
-  await symlink(refPath, linkPath);
-}
-
-/**
- * Verify that a symlink is valid and points to the correct reference.
- * Returns true if valid, false if needs repair.
- */
-export async function verifyReferenceLink(repo: RepoSpec, sessionPath: string): Promise<boolean> {
-  const refPath = getReferencePath(repo);
-  const linkPath = join(sessionPath, repo.dir);
-
-  if (!(await isSymlink(linkPath))) {
-    return false;
-  }
-
-  try {
-    const target = await readlink(linkPath);
-    // Check if target matches expected reference path
-    if (target !== refPath) {
-      return false;
-    }
-    // Check if target actually exists
-    const gitDir = Bun.file(join(refPath, ".git"));
-    return await gitDir.exists();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Repair a broken reference link by re-ensuring the cache and re-linking.
- */
-export async function repairReferenceLink(
-  repo: RepoSpec,
-  sessionPath: string,
-  onProgress?: (status: "cloning" | "done" | "error", outputLines?: string[]) => void,
-): Promise<void> {
-  const linkPath = join(sessionPath, repo.dir);
-
-  // Remove existing link/directory
-  try {
-    await rm(linkPath, { recursive: true, force: true });
-  } catch {
-    // Ignore
-  }
-
-  // Ensure reference is cached
-  await ensureReferenceRepo(repo, onProgress);
-
-  // Create symlink
-  await linkReferenceRepo(repo, sessionPath);
-}
-
-/**
- * Clean up orphaned references that aren't used by any session.
- * Returns the number of references removed.
- */
-export async function cleanOrphanedReferences(): Promise<number> {
-  // This is a placeholder for future implementation
-  // Would need to:
-  // 1. List all sessions
-  // 2. Collect all reference paths in use
-  // 3. Walk references dir and remove unused entries
-  return 0;
-}
-
-/**
- * List all cached references.
- */
-export async function listCachedReferences(): Promise<
-  Array<{ owner: string; name: string; branch: string; path: string }>
-> {
-  const refs: Array<{ owner: string; name: string; branch: string; path: string }> = [];
-
-  try {
-    const owners = await readdir(REFERENCES_DIR);
-
-    for (const owner of owners) {
-      const ownerPath = join(REFERENCES_DIR, owner);
-      const ownerStat = await lstat(ownerPath);
-      if (!ownerStat.isDirectory()) continue;
-
-      const names = await readdir(ownerPath);
-
-      for (const name of names) {
-        const namePath = join(ownerPath, name);
-        const nameStat = await lstat(namePath);
-        if (!nameStat.isDirectory()) continue;
-
-        const branches = await readdir(namePath);
-
-        for (const branch of branches) {
-          const branchPath = join(namePath, branch);
-          const branchStat = await lstat(branchPath);
-          if (!branchStat.isDirectory()) continue;
-
-          refs.push({ owner, name, branch, path: branchPath });
-        }
-      }
-    }
-  } catch {
-    // References dir doesn't exist yet
-  }
-
-  return refs;
-}