collabmd 0.1.18

package/src/server/infrastructure/git/git-service.js

@@ -0,0 +1,216 @@
+import { createGitRequestError } from './errors.js';
+import { normalizeRelativeGitPath } from './path-utils.js';
+import { GitCommandRunner } from './command-runner.js';
+import { GitDiffService } from './diff-service.js';
+import { parseNameStatusOutput } from './parsers.js';
+import { createEmptyWorkspaceChange, createWorkspaceChange } from './responses.js';
+import { GitStatusService } from './status-service.js';
+import { GitUntrackedFileService } from './untracked-files.js';
+
+export class GitService {
+  constructor({
+    commandEnv = null,
+    enabled = true,
+    execFileImpl,
+    maxInitialPatchBytes = 250_000,
+    maxInitialPatchLines = 1_500,
+    statusCacheTtlMs = 2_000,
+    vaultDir,
+  }) {
+    this.commandRunner = new GitCommandRunner({
+      commandEnv,
+      enabled,
+      execFileImpl,
+      vaultDir,
+    });
+    this.untrackedFileService = new GitUntrackedFileService({ vaultDir });
+    this.statusService = new GitStatusService({
+      commandRunner: this.commandRunner,
+      statusCacheTtlMs,
+      untrackedFileService: this.untrackedFileService,
+    });
+    this.diffService = new GitDiffService({
+      commandRunner: this.commandRunner,
+      maxInitialPatchBytes,
+      maxInitialPatchLines,
+      statusService: this.statusService,
+      untrackedFileService: this.untrackedFileService,
+    });
+  }
+
+  async isGitRepo() {
+    return this.commandRunner.isGitRepo();
+  }
+
+  async execGit(args) {
+    return this.commandRunner.execGit(args);
+  }
+
+  invalidateStatusCache() {
+    this.statusService.invalidate();
+    this.diffService.invalidate();
+  }
+
+  async getStatus(options = {}) {
+    return this.statusService.getStatus(options);
+  }
+
+  async stageFile(path) {
+    const normalizedPath = normalizeRelativeGitPath(path);
+    await this.commandRunner.execGit(['add', '-A', '--', normalizedPath]);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      path: normalizedPath,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
+  async unstageFile(path) {
+    const normalizedPath = normalizeRelativeGitPath(path);
+    await this.commandRunner.execGit(['reset', 'HEAD', '--', normalizedPath]);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      path: normalizedPath,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
+  async commitStaged({ message } = {}) {
+    const normalizedMessage = String(message ?? '').trim();
+    if (!normalizedMessage) {
+      throw createGitRequestError(400, 'Missing commit message');
+    }
+
+    const status = await this.getStatus({ force: true });
+    if (Number(status.summary?.staged || 0) === 0) {
+      throw createGitRequestError(409, 'No staged changes to commit');
+    }
+
+    await this.commandRunner.execGit(['commit', '-m', normalizedMessage]);
+    const hash = (await this.commandRunner.execGit(['rev-parse', 'HEAD'])).trim();
+    const shortHash = (await this.commandRunner.execGit(['rev-parse', '--short', 'HEAD'])).trim();
+    this.invalidateStatusCache();
+    return {
+      commit: {
+        hash,
+        message: normalizedMessage,
+        shortHash,
+      },
+      ok: true,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
+  async pushBranch() {
+    const status = await this.getStatus({ force: true });
+    if (status.branch?.detached) {
+      throw createGitRequestError(409, 'Cannot push from a detached HEAD');
+    }
+    if (!status.branch?.upstream) {
+      throw createGitRequestError(409, 'No upstream branch is configured for push');
+    }
+
+    const output = await this.commandRunner.execGit(['push']);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      output: output.trim(),
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
+  async pullBranch() {
+    const status = await this.getStatus({ force: true });
+    if (status.branch?.detached) {
+      throw createGitRequestError(409, 'Cannot pull from a detached HEAD');
+    }
+    if (!status.branch?.upstream) {
+      throw createGitRequestError(409, 'No upstream branch is configured for pull');
+    }
+
+    const beforeRef = await this.getHeadRef();
+    const output = await this.commandRunner.execGit(['pull', '--ff-only']);
+    const afterRef = await this.getHeadRef();
+    this.invalidateStatusCache();
+    return {
+      afterRef,
+      beforeRef,
+      ok: true,
+      output: output.trim(),
+      workspaceChange: await this.createWorkspaceChangeFromRefs(beforeRef, afterRef),
+    };
+  }
+
+  async resetFileToHead(path) {
+    const normalizedPath = normalizeRelativeGitPath(path);
+    const sourceRef = 'HEAD';
+    const existsOnSource = await this.pathExistsAtRef(sourceRef, normalizedPath);
+
+    if (existsOnSource) {
+      await this.commandRunner.execGit(['restore', '--source', sourceRef, '--staged', '--worktree', '--', normalizedPath]);
+      this.invalidateStatusCache();
+      return {
+        ok: true,
+        path: normalizedPath,
+        sourceRef,
+        workspaceChange: createWorkspaceChange({
+          changedPaths: [normalizedPath],
+        }),
+      };
+    }
+
+    await this.commandRunner.execGit(['rm', '-f', '--ignore-unmatch', '--', normalizedPath]);
+    await this.commandRunner.execGit(['clean', '-f', '--', normalizedPath]);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      path: normalizedPath,
+      sourceRef,
+      workspaceChange: createWorkspaceChange({
+        deletedPaths: [normalizedPath],
+      }),
+    };
+  }
+
+  async getDiff({ allowLargePatch = false, metaOnly = false, path = null, scope = 'working-tree' } = {}) {
+    const normalizedPath = path ? normalizeRelativeGitPath(path) : null;
+    return this.diffService.getDiff({
+      allowLargePatch,
+      metaOnly,
+      path: normalizedPath,
+      scope,
+    });
+  }
+
+  async getHeadRef() {
+    try {
+      const output = await this.commandRunner.execGit(['rev-parse', 'HEAD']);
+      return output.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async pathExistsAtRef(ref, path) {
+    try {
+      await this.commandRunner.execGit(['cat-file', '-e', `${ref}:${path}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async createWorkspaceChangeFromRefs(beforeRef, afterRef) {
+    if (!afterRef || beforeRef === afterRef) {
+      return createEmptyWorkspaceChange();
+    }
+
+    const args = beforeRef
+      ? ['diff', '--name-status', '--find-renames', beforeRef, afterRef]
+      : ['diff-tree', '--root', '--no-commit-id', '--name-status', '--find-renames', '-r', afterRef];
+    const parsed = parseNameStatusOutput(await this.commandRunner.execGit(args));
+    return createWorkspaceChange(parsed);
+  }
+}

package/src/server/infrastructure/git/parsers.js

@@ -0,0 +1,401 @@
+import { decodeQuotedPath, parseRenamePath, stripDiffPrefix } from './path-utils.js';
+import { createEmptyBranchStatus, createStatusInfo } from './responses.js';
+
+function parseBranchLine(line) {
+  const result = {
+    ...createEmptyBranchStatus(),
+    hasCommits: true,
+  };
+
+  if (!line.startsWith('## ')) {
+    return result;
+  }
+
+  const branchText = line.slice(3).trim();
+  if (!branchText) {
+    return result;
+  }
+
+  if (branchText.startsWith('No commits yet on ')) {
+    result.name = branchText.slice('No commits yet on '.length);
+    result.hasCommits = false;
+    return result;
+  }
+
+  if (branchText.startsWith('HEAD (no branch)')) {
+    result.name = 'HEAD';
+    result.detached = true;
+    return result;
+  }
+
+  const metadataIndex = branchText.indexOf(' [');
+  const branchSegment = metadataIndex === -1
+    ? branchText
+    : branchText.slice(0, metadataIndex);
+  const metadataSegment = metadataIndex === -1
+    ? ''
+    : branchText.slice(metadataIndex + 2, -1);
+  const [name, upstream] = branchSegment.split('...');
+
+  result.name = name || null;
+  result.upstream = upstream || null;
+
+  if (metadataSegment) {
+    for (const token of metadataSegment.split(',')) {
+      const value = token.trim();
+      if (value.startsWith('ahead ')) {
+        result.ahead = Number.parseInt(value.slice(6), 10) || 0;
+      } else if (value.startsWith('behind ')) {
+        result.behind = Number.parseInt(value.slice(7), 10) || 0;
+      }
+    }
+  }
+
+  return result;
+}
+
+function parseHunkHeader(line) {
+  const match = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/u);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    header: line,
+    newLines: Number.parseInt(match[4] ?? '1', 10),
+    newStart: Number.parseInt(match[3], 10),
+    oldLines: Number.parseInt(match[2] ?? '1', 10),
+    oldStart: Number.parseInt(match[1], 10),
+    section: match[5]?.trim() || '',
+  };
+}
+
+function finalizeFile(file) {
+  if (!file) {
+    return null;
+  }
+
+  if (file.oldPath === file.path) {
+    file.oldPath = null;
+  }
+
+  return file;
+}
+
+export function splitContentLines(content) {
+  const lines = String(content ?? '').replace(/\r\n/g, '\n').split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return lines;
+}
+
+export function parseStatusOutput(output) {
+  const lines = String(output ?? '')
+    .split(/\r?\n/u)
+    .filter(Boolean);
+  const [branchLine = '', ...statusLines] = lines;
+  const branch = parseBranchLine(branchLine);
+  const sections = {
+    staged: [],
+    'working-tree': [],
+    untracked: [],
+  };
+  const uniquePaths = new Set();
+
+  for (const line of statusLines) {
+    if (line.length < 3) {
+      continue;
+    }
+
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const rawPath = line.slice(3);
+
+    if (indexStatus === '!' && workTreeStatus === '!') {
+      continue;
+    }
+
+    if (indexStatus === '?' && workTreeStatus === '?') {
+      const file = {
+        ...createStatusInfo('?'),
+        oldPath: null,
+        path: decodeQuotedPath(rawPath),
+        scope: 'untracked',
+      };
+      sections.untracked.push(file);
+      uniquePaths.add(file.path);
+      continue;
+    }
+
+    const parsedPath = parseRenamePath(rawPath);
+
+    if (indexStatus !== ' ') {
+      const file = {
+        ...createStatusInfo(indexStatus),
+        oldPath: parsedPath.oldPath,
+        path: parsedPath.path,
+        scope: 'staged',
+      };
+      sections.staged.push(file);
+      uniquePaths.add(file.path);
+    }
+
+    if (workTreeStatus !== ' ') {
+      const file = {
+        ...createStatusInfo(workTreeStatus),
+        oldPath: parsedPath.oldPath,
+        path: parsedPath.path,
+        scope: 'working-tree',
+      };
+      sections['working-tree'].push(file);
+      uniquePaths.add(file.path);
+    }
+  }
+
+  return {
+    branch,
+    sections,
+    summary: {
+      changedFiles: uniquePaths.size,
+      staged: sections.staged.length,
+      untracked: sections.untracked.length,
+      workingTree: sections['working-tree'].length,
+    },
+  };
+}
+
+export function parseNumstatOutput(output) {
+  return String(output ?? '')
+    .split(/\r?\n/u)
+    .filter(Boolean)
+    .reduce((summary, line) => {
+      const [rawAdditions = '0', rawDeletions = '0'] = line.split('\t');
+      const additions = rawAdditions === '-' ? 0 : Number.parseInt(rawAdditions, 10) || 0;
+      const deletions = rawDeletions === '-' ? 0 : Number.parseInt(rawDeletions, 10) || 0;
+
+      return {
+        additions: summary.additions + additions,
+        deletions: summary.deletions + deletions,
+      };
+    }, {
+      additions: 0,
+      deletions: 0,
+    });
+}
+
+export function parseNumstatEntries(output) {
+  return String(output ?? '')
+    .split(/\r?\n/u)
+    .filter(Boolean)
+    .map((line) => {
+      const [rawAdditions = '0', rawDeletions = '0', ...rest] = line.split('\t');
+      return {
+        additions: rawAdditions === '-' ? 0 : Number.parseInt(rawAdditions, 10) || 0,
+        deletions: rawDeletions === '-' ? 0 : Number.parseInt(rawDeletions, 10) || 0,
+        rawPath: rest.join('\t'),
+      };
+    });
+}
+
+export function parseNameStatusOutput(output) {
+  return String(output ?? '')
+    .split(/\r?\n/u)
+    .filter(Boolean)
+    .reduce((summary, line) => {
+      const [rawStatus = '', ...parts] = line.split('\t');
+      const status = rawStatus.trim().toUpperCase();
+      if (!status) {
+        return summary;
+      }
+
+      if (status.startsWith('R') || status.startsWith('C')) {
+        const [oldPath = '', newPath = ''] = parts.map((value) => decodeQuotedPath(value));
+        if (oldPath && newPath && oldPath !== newPath) {
+          summary.renamedPaths.push({ newPath, oldPath });
+        }
+        return summary;
+      }
+
+      const [path = ''] = parts.map((value) => decodeQuotedPath(value));
+      if (!path) {
+        return summary;
+      }
+
+      if (status.startsWith('D')) {
+        summary.deletedPaths.push(path);
+        return summary;
+      }
+
+      summary.changedPaths.push(path);
+      return summary;
+    }, {
+      changedPaths: [],
+      deletedPaths: [],
+      renamedPaths: [],
+    });
+}
+
+export function countPatchLines(file = null) {
+  return (file?.hunks ?? []).reduce((total, hunk) => total + (hunk.lines?.length ?? 0), 0);
+}
+
+export function parseUnifiedDiff(diffText) {
+  if (!diffText) {
+    return [];
+  }
+
+  const files = [];
+  const lines = String(diffText).split(/\r?\n/u);
+  let currentFile = null;
+  let currentHunk = null;
+  let oldLineNumber = 0;
+  let newLineNumber = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      const parts = line.split(' ');
+      const oldPath = stripDiffPrefix(parts[2]);
+      const newPath = stripDiffPrefix(parts[3]);
+      currentFile = {
+        code: 'M',
+        hunks: [],
+        isBinary: false,
+        oldPath,
+        path: newPath ?? oldPath,
+        stats: {
+          additions: 0,
+          deletions: 0,
+        },
+        status: 'modified',
+      };
+      currentHunk = null;
+      files.push(currentFile);
+      continue;
+    }
+
+    if (!currentFile) {
+      continue;
+    }
+
+    if (line.startsWith('new file mode ')) {
+      currentFile.code = 'A';
+      currentFile.status = 'added';
+      continue;
+    }
+
+    if (line.startsWith('deleted file mode ')) {
+      currentFile.code = 'D';
+      currentFile.status = 'deleted';
+      continue;
+    }
+
+    if (line.startsWith('rename from ')) {
+      currentFile.code = 'R';
+      currentFile.status = 'renamed';
+      currentFile.oldPath = line.slice('rename from '.length);
+      continue;
+    }
+
+    if (line.startsWith('rename to ')) {
+      currentFile.path = line.slice('rename to '.length);
+      continue;
+    }
+
+    if (line.startsWith('copy from ')) {
+      currentFile.code = 'C';
+      currentFile.status = 'copied';
+      currentFile.oldPath = line.slice('copy from '.length);
+      continue;
+    }
+
+    if (line.startsWith('copy to ')) {
+      currentFile.path = line.slice('copy to '.length);
+      continue;
+    }
+
+    if (line.startsWith('Binary files ')) {
+      currentFile.isBinary = true;
+      currentFile.binaryMessage = line;
+      continue;
+    }
+
+    if (line.startsWith('--- ')) {
+      currentFile.oldPath = stripDiffPrefix(line.slice(4));
+      continue;
+    }
+
+    if (line.startsWith('+++ ')) {
+      currentFile.path = stripDiffPrefix(line.slice(4)) ?? currentFile.path;
+      continue;
+    }
+
+    const hunk = parseHunkHeader(line);
+    if (hunk) {
+      currentHunk = {
+        ...hunk,
+        lines: [],
+      };
+      currentFile.hunks.push(currentHunk);
+      oldLineNumber = hunk.oldStart;
+      newLineNumber = hunk.newStart;
+      continue;
+    }
+
+    if (!currentHunk) {
+      continue;
+    }
+
+    const prefix = line[0];
+    const content = line.slice(1);
+
+    if (prefix === ' ') {
+      currentHunk.lines.push({
+        content,
+        newLine: newLineNumber,
+        oldLine: oldLineNumber,
+        type: 'context',
+      });
+      oldLineNumber += 1;
+      newLineNumber += 1;
+      continue;
+    }
+
+    if (prefix === '-') {
+      currentFile.stats.deletions += 1;
+      currentHunk.lines.push({
+        content,
+        newLine: null,
+        oldLine: oldLineNumber,
+        type: 'deletion',
+      });
+      oldLineNumber += 1;
+      continue;
+    }
+
+    if (prefix === '+') {
+      currentFile.stats.additions += 1;
+      currentHunk.lines.push({
+        content,
+        newLine: newLineNumber,
+        oldLine: null,
+        type: 'addition',
+      });
+      newLineNumber += 1;
+      continue;
+    }
+
+    if (prefix === '\\') {
+      currentHunk.lines.push({
+        content: line,
+        newLine: null,
+        oldLine: null,
+        type: 'note',
+      });
+    }
+  }
+
+  return files
+    .map((file) => finalizeFile(file))
+    .filter(Boolean);
+}

package/src/server/infrastructure/git/path-utils.js

@@ -0,0 +1,65 @@
+import { createGitRequestError } from './errors.js';
+
+export function decodeQuotedPath(pathValue) {
+  const rawValue = String(pathValue ?? '').trim();
+  if (!(rawValue.startsWith('"') && rawValue.endsWith('"'))) {
+    return rawValue;
+  }
+
+  return rawValue
+    .slice(1, -1)
+    .replace(/\\([\\"])/g, '$1')
+    .replace(/\\t/g, '\t')
+    .replace(/\\n/g, '\n')
+    .replace(/\\([0-7]{3})/g, (_match, value) => String.fromCharCode(Number.parseInt(value, 8)));
+}
+
+export function normalizeRelativeGitPath(pathValue) {
+  const normalized = decodeQuotedPath(pathValue)
+    .trim()
+    .replace(/\\/g, '/')
+    .replace(/^\/+/u, '')
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  if (normalized.length === 0) {
+    throw createGitRequestError(400, 'Missing path parameter');
+  }
+
+  if (normalized.some((segment) => segment === '.' || segment === '..')) {
+    throw createGitRequestError(400, 'Invalid path parameter');
+  }
+
+  return normalized.join('/');
+}
+
+export function parseRenamePath(rawPath) {
+  const decodedPath = decodeQuotedPath(rawPath);
+  const separator = ' -> ';
+  const separatorIndex = decodedPath.indexOf(separator);
+  if (separatorIndex === -1) {
+    return {
+      oldPath: null,
+      path: decodedPath,
+    };
+  }
+
+  return {
+    oldPath: decodedPath.slice(0, separatorIndex),
+    path: decodedPath.slice(separatorIndex + separator.length),
+  };
+}
+
+export function stripDiffPrefix(pathValue) {
+  const normalizedPath = String(pathValue ?? '').replace(/\s+$/u, '');
+  if (!normalizedPath || normalizedPath === '/dev/null') {
+    return null;
+  }
+
+  if (normalizedPath.startsWith('a/') || normalizedPath.startsWith('b/')) {
+    return normalizedPath.slice(2);
+  }
+
+  return normalizedPath;
+}