takos-control 1.0.0

package/src/application/services/git-smart/client/fetch-refs.ts

@@ -0,0 +1,134 @@
+/**
+ * Git Smart HTTP Client — fetch remote refs.
+ *
+ * Speaks the client side of the git smart HTTP info/refs protocol.
+ * This is the inverse of `handleInfoRefs` in `smart-http/info-refs.ts`:
+ * the server *constructs* the pkt-line response; this module *parses* it.
+ *
+ * Usage:
+ *   const { refs, capabilities } = await fetchRemoteRefs(
+ *     'https://github.com/owner/repo.git',
+ *     null, // no auth for public repos
+ *   );
+ */
+
+import { parsePktLines, pktLineText } from '../protocol/pkt-line';
+import { logWarn } from '../../../../shared/utils/logger';
+
+export interface RemoteRef {
+  /** Fully qualified ref name, e.g. `refs/heads/main`. */
+  name: string;
+  /** 40-character hex SHA-1. */
+  sha: string;
+}
+
+export interface FetchRefsResult {
+  refs: RemoteRef[];
+  capabilities: string[];
+  /** The SHA advertised as HEAD (if present via symref). */
+  headSha: string | null;
+  /** The branch HEAD points to (parsed from symref capability). */
+  headTarget: string | null;
+}
+
+/**
+ * Fetch the ref list from a remote git HTTP server.
+ *
+ * Sends `GET <url>/info/refs?service=git-upload-pack` and parses the
+ * pkt-line response into structured ref entries and capabilities.
+ */
+export async function fetchRemoteRefs(
+  url: string,
+  authHeader: string | null,
+): Promise<FetchRefsResult> {
+  const normalizedUrl = url.replace(/\/$/, '');
+  const infoRefsUrl = `${normalizedUrl}/info/refs?service=git-upload-pack`;
+
+  const headers: Record<string, string> = {
+    'User-Agent': 'takos-git-client/1.0',
+  };
+  if (authHeader) {
+    headers['Authorization'] = authHeader;
+  }
+
+  const response = await fetch(infoRefsUrl, { headers });
+
+  if (!response.ok) {
+    const body = await response.text().catch((err) => {
+      logWarn('Failed to read error response body from remote git server', { module: 'fetch-refs', error: err instanceof Error ? err.message : String(err) });
+      return '';
+    });
+    throw new Error(
+      `Failed to fetch refs from ${normalizedUrl}: HTTP ${response.status}${body ? ` — ${body.slice(0, 200)}` : ''}`,
+    );
+  }
+
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const lines = parsePktLines(buffer);
+
+  const refs: RemoteRef[] = [];
+  let capabilities: string[] = [];
+  let headSha: string | null = null;
+  let headTarget: string | null = null;
+  let firstDataLine = true;
+
+  for (const line of lines) {
+    if (line.type !== 'data' || !line.data) continue;
+
+    const text = pktLineText(line);
+
+    // Skip the service announcement line (e.g. "# service=git-upload-pack")
+    if (text.startsWith('#')) continue;
+
+    if (firstDataLine) {
+      // First data line contains: "<sha> <refname>\0<capabilities>"
+      firstDataLine = false;
+      const nulIndex = text.indexOf('\0');
+      if (nulIndex >= 0) {
+        const refPart = text.slice(0, nulIndex);
+        const capsPart = text.slice(nulIndex + 1);
+        capabilities = capsPart.split(' ').filter(Boolean);
+
+        // Parse symref capability: symref=HEAD:refs/heads/main
+        for (const cap of capabilities) {
+          if (cap.startsWith('symref=HEAD:')) {
+            headTarget = cap.slice('symref=HEAD:'.length);
+          }
+        }
+
+        const ref = parseRefLine(refPart);
+        if (ref) {
+          refs.push(ref);
+          if (ref.name === 'HEAD') headSha = ref.sha;
+        }
+      } else {
+        const ref = parseRefLine(text);
+        if (ref) {
+          refs.push(ref);
+          if (ref.name === 'HEAD') headSha = ref.sha;
+        }
+      }
+    } else {
+      const ref = parseRefLine(text);
+      if (ref) {
+        refs.push(ref);
+      }
+    }
+  }
+
+  return { refs, capabilities, headSha, headTarget };
+}
+
+function parseRefLine(line: string): RemoteRef | null {
+  // Format: "<40-char sha> <refname>"
+  const spaceIndex = line.indexOf(' ');
+  if (spaceIndex < 0) return null;
+
+  const sha = line.slice(0, spaceIndex);
+  const name = line.slice(spaceIndex + 1);
+
+  if (sha.length !== 40 || !/^[a-f0-9]{40}$/.test(sha)) return null;
+  if (!name) return null;
+
+  return { sha, name };
+}

package/src/application/services/git-smart/client/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Git Smart HTTP Client — public API.
+ *
+ * Provides the client-side counterpart to the server-side git smart HTTP
+ * handlers in `smart-http/`. Enables fetching refs and packfiles from
+ * any remote git HTTP server (GitHub, GitLab, self-hosted, etc.).
+ */
+
+export { fetchRemoteRefs, type RemoteRef, type FetchRefsResult } from './fetch-refs';
+export { fetchPackFromRemote } from './fetch-pack';

package/src/application/services/git-smart/core/commit-index.ts

@@ -0,0 +1,436 @@
+/**
+ * Commit creation, D1 indexing, and DAG traversal.
+ *
+ * Adapted from git-store/commit.ts with native git object format.
+ */
+
+import type { D1Database, R2Bucket } from '../../../../shared/types/bindings.ts';
+import type { GitCommit, GitSignature, CreateCommitParams } from '../git-objects';
+import { isValidSha } from '../git-objects';
+import { putCommit, getCommitData } from './object-store';
+import { getDb, commits } from '../../../../infra/db';
+import { eq, and } from 'drizzle-orm';
+import { generateId, now, toIsoString } from '../../../../shared/utils';
+
+interface CommitIndexRow {
+  sha: string;
+  treeSha: string;
+  parentShas: string | null;
+  message: string;
+  authorName: string;
+  authorEmail: string;
+  authorDate: string | Date;
+  committerName: string;
+  committerEmail: string;
+  commitDate: string | Date;
+}
+
+function indexedToCommit(row: CommitIndexRow): GitCommit {
+  return {
+    sha: row.sha,
+    tree: row.treeSha,
+    parents: row.parentShas ? (() => { try { return JSON.parse(row.parentShas!) as string[]; } catch { return []; } })() : [],
+    message: row.message,
+    author: {
+      name: row.authorName,
+      email: row.authorEmail,
+      timestamp: Math.floor(new Date(row.authorDate).getTime() / 1000),
+      tzOffset: '+0000',
+    },
+    committer: {
+      name: row.committerName,
+      email: row.committerEmail,
+      timestamp: Math.floor(new Date(row.commitDate).getTime() / 1000),
+      tzOffset: '+0000',
+    },
+  };
+}
+
+function makeSignature(sig?: GitSignature): GitSignature {
+  const ts = now();
+  return sig || {
+    name: 'System',
+    email: 'system@takos.dev',
+    timestamp: Math.floor(new Date(ts).getTime() / 1000),
+    tzOffset: '+0000',
+  };
+}
+
+function sigTimestampToIso(sig: GitSignature): string {
+  return new Date(sig.timestamp * 1000).toISOString();
+}
+
+export async function createCommit(
+  dbBinding: D1Database,
+  bucket: R2Bucket,
+  repoId: string,
+  params: CreateCommitParams,
+): Promise<GitCommit> {
+  const author = makeSignature(params.author);
+  const committer = makeSignature(params.committer);
+
+  const sha = await putCommit(bucket, {
+    tree: params.tree,
+    parents: params.parents,
+    author,
+    committer,
+    message: params.message,
+  });
+
+  const db = getDb(dbBinding);
+  const id = generateId();
+  await db.insert(commits).values({
+    id,
+    repoId,
+    sha,
+    treeSha: params.tree,
+    parentShas: params.parents.length > 0 ? JSON.stringify(params.parents) : null,
+    authorName: author.name,
+    authorEmail: author.email,
+    authorDate: sigTimestampToIso(author),
+    committerName: committer.name,
+    committerEmail: committer.email,
+    commitDate: sigTimestampToIso(committer),
+    message: params.message,
+  });
+
+  return {
+    sha,
+    tree: params.tree,
+    parents: params.parents,
+    message: params.message,
+    author,
+    committer,
+  };
+}
+
+/**
+ * Index an existing commit (received via push) into D1.
+ */
+export async function indexCommit(
+  dbBinding: D1Database,
+  repoId: string,
+  commit: GitCommit,
+): Promise<void> {
+  const db = getDb(dbBinding);
+
+  const existing = await db.select({ id: commits.id }).from(commits)
+    .where(and(eq(commits.repoId, repoId), eq(commits.sha, commit.sha)))
+    .get();
+  if (existing) return;
+
+  const id = generateId();
+  await db.insert(commits).values({
+    id,
+    repoId,
+    sha: commit.sha,
+    treeSha: commit.tree,
+    parentShas: commit.parents.length > 0 ? JSON.stringify(commit.parents) : null,
+    authorName: commit.author.name,
+    authorEmail: commit.author.email,
+    authorDate: sigTimestampToIso(commit.author),
+    committerName: commit.committer.name,
+    committerEmail: commit.committer.email,
+    commitDate: sigTimestampToIso(commit.committer),
+    message: commit.message,
+  });
+}
+
+export async function getCommitFromIndex(
+  dbBinding: D1Database, repoId: string, sha: string,
+): Promise<GitCommit | null> {
+  const db = getDb(dbBinding);
+  const indexed = await db.select().from(commits)
+    .where(and(eq(commits.repoId, repoId), eq(commits.sha, sha)))
+    .get();
+  if (!indexed) return null;
+  return indexedToCommit({
+    sha: indexed.sha,
+    treeSha: indexed.treeSha,
+    parentShas: indexed.parentShas,
+    message: indexed.message,
+    authorName: indexed.authorName,
+    authorEmail: indexed.authorEmail,
+    authorDate: toIsoString(indexed.authorDate) ?? new Date(0).toISOString(),
+    committerName: indexed.committerName,
+    committerEmail: indexed.committerEmail,
+    commitDate: toIsoString(indexed.commitDate) ?? new Date(0).toISOString(),
+  });
+}
+
+export async function getCommit(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, sha: string,
+): Promise<GitCommit | null> {
+  const indexed = await getCommitFromIndex(dbBinding, repoId, sha);
+  if (indexed) return indexed;
+  if (!isValidSha(sha)) return null;
+  return getCommitData(bucket, sha);
+}
+
+export async function getCommitLog(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, startSha: string, limit = 50,
+): Promise<GitCommit[]> {
+  if (!startSha || limit <= 0) return [];
+
+  const commitList: GitCommit[] = [];
+  const visited = new Set<string>();
+  let cursorSha: string | null = startSha;
+
+  while (cursorSha && commitList.length < limit) {
+    if (visited.has(cursorSha)) break;
+    visited.add(cursorSha);
+
+    const commit = await getCommit(dbBinding, bucket, repoId, cursorSha);
+    if (!commit) break;
+
+    commitList.push(commit);
+    cursorSha = commit.parents[0] || null;
+  }
+
+  return commitList;
+}
+
+export async function getCommitsFromRef(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, startSha: string, limit = 50,
+): Promise<GitCommit[]> {
+  const visited = new Set<string>();
+  const commitList: GitCommit[] = [];
+  const queue: string[] = [startSha];
+
+  while (queue.length > 0 && commitList.length < limit) {
+    const sha = queue.shift()!;
+    if (visited.has(sha)) continue;
+    visited.add(sha);
+
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (!commit) continue;
+
+    commitList.push(commit);
+    for (const parentSha of commit.parents) {
+      if (!visited.has(parentSha)) queue.push(parentSha);
+    }
+  }
+
+  commitList.sort((a, b) => b.committer.timestamp - a.committer.timestamp);
+  return commitList.slice(0, limit);
+}
+
+export async function isAncestor(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, ancestorSha: string, descendantSha: string,
+): Promise<boolean> {
+  if (ancestorSha === descendantSha) return true;
+
+  const visited = new Set<string>();
+  const queue: string[] = [descendantSha];
+
+  while (queue.length > 0) {
+    const sha = queue.shift()!;
+    if (visited.has(sha)) continue;
+    visited.add(sha);
+    if (sha === ancestorSha) return true;
+
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (!commit) continue;
+    for (const parentSha of commit.parents) {
+      if (!visited.has(parentSha)) queue.push(parentSha);
+    }
+  }
+
+  return false;
+}
+
+export async function findMergeBase(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, sha1: string, sha2: string,
+): Promise<string | null> {
+  const ancestors1 = new Set<string>();
+  const queue1: string[] = [sha1];
+
+  while (queue1.length > 0) {
+    const sha = queue1.shift()!;
+    if (ancestors1.has(sha)) continue;
+    ancestors1.add(sha);
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (commit) {
+      for (const parent of commit.parents) queue1.push(parent);
+    }
+  }
+
+  const queue2: string[] = [sha2];
+  const visited2 = new Set<string>();
+
+  while (queue2.length > 0) {
+    const sha = queue2.shift()!;
+    if (visited2.has(sha)) continue;
+    visited2.add(sha);
+    if (ancestors1.has(sha)) return sha;
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (commit) {
+      for (const parent of commit.parents) queue2.push(parent);
+    }
+  }
+
+  return null;
+}
+
+export async function countCommitsBetween(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, baseSha: string, headSha: string,
+): Promise<{ ahead: number; behind: number; has_merge_base: boolean }> {
+  const mergeBase = await findMergeBase(dbBinding, bucket, repoId, baseSha, headSha);
+  if (!mergeBase) return { ahead: 0, behind: 0, has_merge_base: false };
+
+  const ahead = await countCommitsTo(dbBinding, bucket, repoId, headSha, mergeBase);
+  const behind = await countCommitsTo(dbBinding, bucket, repoId, baseSha, mergeBase);
+  return { ahead, behind, has_merge_base: true };
+}
+
+async function countCommitsTo(
+  dbBinding: D1Database, bucket: R2Bucket, repoId: string, fromSha: string, stopAtSha: string,
+): Promise<number> {
+  let commitCount = 0;
+  const visited = new Set<string>();
+  const queue: string[] = [fromSha];
+
+  while (queue.length > 0) {
+    const sha = queue.shift()!;
+    if (visited.has(sha) || sha === stopAtSha) continue;
+    visited.add(sha);
+    commitCount++;
+
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (commit) {
+      for (const parent of commit.parents) queue.push(parent);
+    }
+  }
+
+  return commitCount;
+}
+
+/**
+ * Collect all object SHAs reachable from want set, stopping at have set.
+ * Used for upload-pack negotiation.
+ */
+export async function collectReachableObjects(
+  dbBinding: D1Database,
+  bucket: R2Bucket,
+  repoId: string,
+  wants: string[],
+  haves: Set<string>,
+): Promise<string[]> {
+  const result: string[] = [];
+  const visited = new Set<string>();
+  const commitQueue: string[] = [...wants];
+
+  while (commitQueue.length > 0) {
+    const sha = commitQueue.shift()!;
+    if (visited.has(sha) || haves.has(sha)) continue;
+    visited.add(sha);
+    result.push(sha);
+
+    const commit = await getCommit(dbBinding, bucket, repoId, sha);
+    if (!commit) continue;
+
+    // Add tree and walk it
+    if (!visited.has(commit.tree) && !haves.has(commit.tree)) {
+      await collectTreeObjects(bucket, commit.tree, result, visited, haves);
+    }
+
+    for (const parent of commit.parents) {
+      if (!visited.has(parent) && !haves.has(parent)) {
+        commitQueue.push(parent);
+      }
+    }
+  }
+
+  return result;
+}
+
+async function collectTreeObjects(
+  bucket: R2Bucket,
+  treeSha: string,
+  result: string[],
+  visited: Set<string>,
+  haves: Set<string>,
+): Promise<void> {
+  if (visited.has(treeSha) || haves.has(treeSha)) return;
+  visited.add(treeSha);
+  result.push(treeSha);
+
+  const { getTreeEntries } = await import('./object-store');
+  const entries = await getTreeEntries(bucket, treeSha);
+  if (!entries) return;
+
+  for (const entry of entries) {
+    if (visited.has(entry.sha) || haves.has(entry.sha)) continue;
+
+    if (entry.mode === '040000' || entry.mode === '40000') {
+      await collectTreeObjects(bucket, entry.sha, result, visited, haves);
+    } else {
+      visited.add(entry.sha);
+      result.push(entry.sha);
+    }
+  }
+}
+
+/**
+ * Collect all object SHAs reachable from all refs in a repository.
+ * Used for GC / cleanup (determining which objects are still live).
+ */
+export async function collectReachableObjectShas(
+  dbBinding: D1Database,
+  bucket: R2Bucket,
+  repoId: string,
+): Promise<Set<string>> {
+  const { listAllRefs } = await import('./refs');
+  const { getTreeEntries } = await import('./object-store');
+
+  const refs = await listAllRefs(dbBinding, repoId);
+
+  const reachable = new Set<string>();
+  const visitedCommits = new Set<string>();
+  const visitedTrees = new Set<string>();
+  const commitQueue: string[] = [];
+
+  for (const ref of refs) {
+    if (!reachable.has(ref.target)) {
+      reachable.add(ref.target);
+      commitQueue.push(ref.target);
+    }
+  }
+
+  while (commitQueue.length > 0) {
+    const commitSha = commitQueue.shift();
+    if (!commitSha || visitedCommits.has(commitSha)) continue;
+    visitedCommits.add(commitSha);
+
+    const commit = await getCommit(dbBinding, bucket, repoId, commitSha);
+    if (!commit) continue;
+
+    reachable.add(commit.tree);
+
+    for (const parentSha of commit.parents) {
+      reachable.add(parentSha);
+      if (!visitedCommits.has(parentSha)) {
+        commitQueue.push(parentSha);
+      }
+    }
+
+    const treeQueue: string[] = [commit.tree];
+    while (treeQueue.length > 0) {
+      const treeSha = treeQueue.shift();
+      if (!treeSha || visitedTrees.has(treeSha)) continue;
+      visitedTrees.add(treeSha);
+
+      const entries = await getTreeEntries(bucket, treeSha);
+      if (!entries) continue;
+
+      for (const entry of entries) {
+        reachable.add(entry.sha);
+        if ((entry.mode === '040000' || entry.mode === '40000') && !visitedTrees.has(entry.sha)) {
+          treeQueue.push(entry.sha);
+        }
+      }
+    }
+  }
+
+  return reachable;
+}

package/src/application/services/git-smart/core/merge.ts

@@ -0,0 +1,102 @@
+/**
+ * 3-way tree merge — path-level OID/mode comparison.
+ *
+ * Adapted from git-store/merge.ts for native git format.
+ */
+
+import type { R2Bucket } from '../../../../shared/types/bindings.ts';
+import type { MergeConflictType, MergeConflict } from '../git-objects';
+import { buildTreeFromPaths, flattenTree } from './tree-ops';
+
+interface TreeFileEntry {
+  sha: string;
+  mode: string;
+}
+
+function entriesEqual(a: TreeFileEntry | null, b: TreeFileEntry | null): boolean {
+  if (a === null && b === null) return true;
+  if (a === null || b === null) return false;
+  return a.sha === b.sha && a.mode === b.mode;
+}
+
+function classifyConflict(
+  base: TreeFileEntry | null,
+  local: TreeFileEntry | null,
+  upstream: TreeFileEntry | null,
+): MergeConflictType {
+  if (base === null && local !== null && upstream !== null) return 'add-add';
+
+  const localDeleted = base !== null && local === null;
+  const upstreamDeleted = base !== null && upstream === null;
+  if ((localDeleted && upstream !== null) || (upstreamDeleted && local !== null)) return 'delete-modify';
+
+  return 'content';
+}
+
+export async function mergeTrees3Way(
+  bucket: R2Bucket,
+  baseTreeSha: string,
+  localTreeSha: string,
+  upstreamTreeSha: string,
+): Promise<{ tree_sha: string | null; conflicts: MergeConflict[] }> {
+  const [baseFiles, localFiles, upstreamFiles] = await Promise.all([
+    flattenTree(bucket, baseTreeSha),
+    flattenTree(bucket, localTreeSha),
+    flattenTree(bucket, upstreamTreeSha),
+  ]);
+
+  const toMap = (files: Array<{ path: string; sha: string; mode: string }>): Map<string, TreeFileEntry> =>
+    new Map(files.map(f => [f.path, { sha: f.sha, mode: f.mode }]));
+
+  const baseMap = toMap(baseFiles);
+  const localMap = toMap(localFiles);
+  const upstreamMap = toMap(upstreamFiles);
+
+  const mergedMap = new Map<string, TreeFileEntry>();
+  const conflicts: MergeConflict[] = [];
+
+  const allPaths = new Set([...baseMap.keys(), ...localMap.keys(), ...upstreamMap.keys()]);
+
+  for (const path of allPaths) {
+    const baseEntry = baseMap.get(path) || null;
+    const localEntry = localMap.get(path) || null;
+    const upstreamEntry = upstreamMap.get(path) || null;
+
+    const localChanged = !entriesEqual(baseEntry, localEntry);
+    const upstreamChanged = !entriesEqual(baseEntry, upstreamEntry);
+
+    if (!localChanged && !upstreamChanged) {
+      if (baseEntry) mergedMap.set(path, baseEntry);
+      continue;
+    }
+
+    if (localChanged && !upstreamChanged) {
+      if (localEntry) mergedMap.set(path, localEntry);
+      continue;
+    }
+
+    if (!localChanged && upstreamChanged) {
+      if (upstreamEntry) mergedMap.set(path, upstreamEntry);
+      continue;
+    }
+
+    if (entriesEqual(localEntry, upstreamEntry)) {
+      if (localEntry) mergedMap.set(path, localEntry);
+      continue;
+    }
+
+    conflicts.push({ path, type: classifyConflict(baseEntry, localEntry, upstreamEntry) });
+  }
+
+  if (conflicts.length > 0) {
+    conflicts.sort((a, b) => a.path.localeCompare(b.path));
+    return { tree_sha: null, conflicts };
+  }
+
+  const mergedFiles = Array.from(mergedMap.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([path, entry]) => ({ path, sha: entry.sha, mode: entry.mode }));
+
+  const tree_sha = await buildTreeFromPaths(bucket, mergedFiles);
+  return { tree_sha, conflicts: [] };
+}