@nomos-arc/arc 0.1.0

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@nomos-arc/arc",
+  "version": "0.1.0",
+  "description": "The Architect — AI Orchestrator CLI for Verification Architecture",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bin": {
+    "arc": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "esbuild src/cli.ts --bundle --platform=node --target=node20 --outfile=dist/cli.js --format=esm --external:node-pty --external:simple-git --external:proper-lockfile --external:winston --external:gray-matter --external:commander --external:@google/generative-ai --external:open --external:google-auth-library --external:fast-glob --external:gitignore-parser --external:web-tree-sitter --external:tree-sitter-wasms --external:@lancedb/lancedb --external:apache-arrow --banner:js='#!/usr/bin/env node'",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run --dir src",
+    "test:e2e": "vitest run --dir test",
+    "lint": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/i-magdy/nomos-arc.git"
+  },
+  "keywords": [],
+  "author": "Ibrahim Magdy",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/i-magdy/nomos-arc/issues"
+  },
+  "homepage": "https://github.com/i-magdy/nomos-arc#readme",
+  "dependencies": {
+    "@google/generative-ai": "^0.24.1",
+    "@lancedb/lancedb": "0.27.2",
+    "apache-arrow": "18.1.0",
+    "commander": "^14.0.3",
+    "cytoscape": "^3.33.1",
+    "fast-glob": "^3.3.3",
+    "gitignore-parser": "^0.0.2",
+    "google-auth-library": "^10.6.2",
+    "gray-matter": "^4.0.3",
+    "node-pty": "^1.1.0",
+    "open": "^11.0.0",
+    "p-limit": "^7.3.0",
+    "proper-lockfile": "^4.1.2",
+    "simple-git": "^3.33.0",
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "^0.24.7",
+    "winston": "^3.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@types/proper-lockfile": "^4.1.4",
+    "esbuild": "^0.27.7",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}

package/src/adapters/__tests__/git.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { simpleGit } from 'simple-git';
+import { GitAdapter } from '../git.js';
+import { NomosError } from '../../core/errors.js';
+import { getDefaultConfig } from '../../core/config.js';
+import { createLogger } from '../../core/logger.js';
+
+// Minimal logger for tests
+const logger = createLogger('error');
+
+function makeConfig(overrides: Partial<{ worktree_base: string }> = {}) {
+  const cfg = getDefaultConfig();
+  if (overrides.worktree_base) {
+    cfg.execution.worktree_base = overrides.worktree_base;
+  }
+  return cfg;
+}
+
+async function initRepo(dir: string): Promise<void> {
+  const git = simpleGit(dir);
+  await git.init(['-b', 'main']);
+  await git.addConfig('user.email', 'test@test.com');
+  await git.addConfig('user.name', 'Test User');
+  fs.writeFileSync(path.join(dir, 'README.md'), '# test');
+  await git.add('README.md');
+  await git.commit('Initial commit');
+}
+
+async function cleanupWorktrees(repoDir: string): Promise<void> {
+  try {
+    const git = simpleGit(repoDir);
+    const list = await git.raw(['worktree', 'list', '--porcelain']);
+    const worktrees = list
+      .split('\n\n')
+      .slice(1) // skip the main worktree
+      .map(block => {
+        const match = block.match(/^worktree (.+)/m);
+        return match ? match[1].trim() : null;
+      })
+      .filter(Boolean) as string[];
+
+    for (const wt of worktrees) {
+      await git.raw(['worktree', 'remove', wt, '--force']).catch(() => {});
+    }
+  } catch {
+    // best effort
+  }
+}
+
+describe('GitAdapter', () => {
+  let tmpDir: string;
+  let worktreeBase: string;
+  let adapter: GitAdapter;
+
+  beforeEach(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nomos-git-test-'));
+    worktreeBase = fs.mkdtempSync(path.join(os.tmpdir(), 'nomos-wt-base-'));
+    await initRepo(tmpDir);
+    const config = makeConfig({ worktree_base: worktreeBase });
+    adapter = new GitAdapter(tmpDir, config, logger);
+  });
+
+  afterEach(async () => {
+    await cleanupWorktrees(tmpDir);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(worktreeBase, { recursive: true, force: true });
+  });
+
+  // ── resolveWorktreePath ──────────────────────────────────────────────────────
+
+  it('resolveWorktreePath produces correct path', () => {
+    const taskId = 'my-task';
+    const expected = path.join(worktreeBase, path.basename(tmpDir), taskId);
+    expect(adapter.resolveWorktreePath(taskId)).toBe(expected);
+  });
+
+  // ── createWorktree ───────────────────────────────────────────────────────────
+
+  it('createWorktree: branch exists, worktree path exists', async () => {
+    const { branch, worktreePath, baseCommit } = await adapter.createWorktree('task-create');
+
+    expect(branch).toContain('task-create');
+    expect(fs.existsSync(worktreePath)).toBe(true);
+    expect(baseCommit).toMatch(/^[a-f0-9]{40}$/);
+  });
+
+  it('createWorktree throws branch_exists when branch already exists', async () => {
+    await adapter.createWorktree('task-dup');
+    await expect(adapter.createWorktree('task-dup')).rejects.toMatchObject({
+      code: 'branch_exists',
+    });
+  });
+
+  // ── removeWorktree ───────────────────────────────────────────────────────────
+
+  it('removeWorktree: path and branch cleaned up', async () => {
+    const { worktreePath } = await adapter.createWorktree('task-remove');
+    await adapter.removeWorktree('task-remove', true);
+
+    expect(fs.existsSync(worktreePath)).toBe(false);
+
+    const git = simpleGit(tmpDir);
+    const branches = await git.branch(['--list', adapter.resolveBranchName('task-remove')]);
+    expect(branches.all).toHaveLength(0);
+  });
+
+  // ── getDiff ─────────────────────────────────────────────────────────────────
+
+  it('getDiff includes changes from multiple commits (not just HEAD~1)', async () => {
+    const { worktreePath, baseCommit } = await adapter.createWorktree('task-diff');
+    const wtGit = simpleGit(worktreePath);
+
+    // First commit in worktree
+    fs.writeFileSync(path.join(worktreePath, 'file1.ts'), 'const x = 1;');
+    await wtGit.add('file1.ts');
+    await wtGit.commit('Add file1');
+
+    // Second commit in worktree
+    fs.writeFileSync(path.join(worktreePath, 'file2.ts'), 'const y = 2;');
+    await wtGit.add('file2.ts');
+    await wtGit.commit('Add file2');
+
+    const diff = await adapter.getDiff('task-diff', baseCommit);
+    expect(diff).toContain('file1.ts');
+    expect(diff).toContain('file2.ts');
+  });
+
+  it('getDiff throws base_commit_unreachable for a fabricated SHA', async () => {
+    await adapter.createWorktree('task-bad-sha');
+    const fakeSha = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
+    await expect(adapter.getDiff('task-bad-sha', fakeSha)).rejects.toMatchObject({
+      code: 'base_commit_unreachable',
+    });
+  });
+
+  // ── commitToShadowBranch ────────────────────────────────────────────────────
+
+  it('commitToShadowBranch copies files and commits them', async () => {
+    // Pre-stage the plan file in the main repo so it's tracked (not untracked)
+    const planFile = path.join('tasks-management', 'plans', 'task-commit-v1.md');
+    fs.mkdirSync(path.join(tmpDir, 'tasks-management', 'plans'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, planFile), '# Plan v1');
+    const mainGit = simpleGit(tmpDir);
+    await mainGit.add(planFile);
+    await mainGit.commit('track plan in main');
+
+    // Now create worktree (branched from HEAD which includes the plan file)
+    await adapter.createWorktree('task-commit');
+
+    // Update the plan file in project root (simulate planner output)
+    fs.writeFileSync(path.join(tmpDir, planFile), '# Plan v1 updated');
+
+    await adapter.commitToShadowBranch('task-commit', 'chore: add plan', [planFile]);
+
+    const worktreePath = adapter.resolveWorktreePath('task-commit');
+    const committedContent = fs.readFileSync(path.join(worktreePath, planFile), 'utf8');
+    expect(committedContent).toBe('# Plan v1 updated');
+
+    const wtGit = simpleGit(worktreePath);
+    const log = await wtGit.log();
+    expect(log.latest?.message).toBe('chore: add plan');
+  });
+
+  it('commitToShadowBranch throws path_traversal for ../../etc/passwd', async () => {
+    await adapter.createWorktree('task-traversal');
+    await expect(
+      adapter.commitToShadowBranch('task-traversal', 'bad', ['../../etc/passwd']),
+    ).rejects.toMatchObject({ code: 'path_traversal' });
+  });
+
+  // ── mergeToMain ─────────────────────────────────────────────────────────────
+
+  it('mergeToMain performs a clean merge', async () => {
+    const { worktreePath } = await adapter.createWorktree('task-merge');
+
+    // Commit a new file directly in the worktree (no project root pollution)
+    fs.writeFileSync(path.join(worktreePath, 'plan.md'), '# Plan');
+    const wtGit = simpleGit(worktreePath);
+    await wtGit.add('plan.md');
+    await wtGit.commit('add plan');
+
+    const result = await adapter.mergeToMain('task-merge', 1, '[nomos]', 'main');
+    expect(result.success).toBe(true);
+  });
+
+  it('mergeToMain with conflict returns success: false and conflict list', async () => {
+    // Create conflicting files in both branches
+    await adapter.createWorktree('task-conflict');
+    const worktreePath = adapter.resolveWorktreePath('task-conflict');
+
+    const conflictFile = 'conflict.txt';
+
+    // Write to main branch
+    fs.writeFileSync(path.join(tmpDir, conflictFile), 'main content');
+    const mainGit = simpleGit(tmpDir);
+    await mainGit.add(conflictFile);
+    await mainGit.commit('main adds conflict.txt');
+
+    // Write conflicting content in shadow branch
+    fs.writeFileSync(path.join(worktreePath, conflictFile), 'shadow content');
+    const wtGit = simpleGit(worktreePath);
+    await wtGit.add(conflictFile);
+    await wtGit.commit('shadow adds conflict.txt');
+
+    const result = await adapter.mergeToMain('task-conflict', 1, '[nomos]', 'main');
+    expect(result.success).toBe(false);
+    expect(result.conflicts).toBeDefined();
+    expect(result.conflicts!.length).toBeGreaterThan(0);
+  });
+
+  it('mergeToMain throws wrong_branch when on a different branch', async () => {
+    await adapter.createWorktree('task-wrong-branch');
+    const mainGit = simpleGit(tmpDir);
+    // Checkout a different branch (not the shadow branch, which is checked out in a worktree)
+    await mainGit.checkoutLocalBranch('other-branch');
+
+    await expect(
+      adapter.mergeToMain('task-wrong-branch', 1, '[nomos]', 'main'),
+    ).rejects.toMatchObject({ code: 'wrong_branch' });
+
+    // Restore main
+    await mainGit.checkout('main');
+  });
+
+  it('mergeToMain throws dirty_working_tree when changes are uncommitted', async () => {
+    await adapter.createWorktree('task-dirty');
+    // Create an uncommitted change in project root
+    fs.writeFileSync(path.join(tmpDir, 'dirty.txt'), 'dirty');
+
+    await expect(
+      adapter.mergeToMain('task-dirty', 1, '[nomos]', 'main'),
+    ).rejects.toMatchObject({ code: 'dirty_working_tree' });
+
+    // Clean up
+    fs.unlinkSync(path.join(tmpDir, 'dirty.txt'));
+  });
+
+  // ── recoverWorktree ─────────────────────────────────────────────────────────
+
+  it('recoverWorktree recreates worktree from existing branch', async () => {
+    const { branch, worktreePath } = await adapter.createWorktree('task-recover');
+
+    // Remove the worktree dir but keep the branch
+    const git = simpleGit(tmpDir);
+    await git.raw(['worktree', 'remove', worktreePath, '--force']);
+    expect(fs.existsSync(worktreePath)).toBe(false);
+
+    // Recover
+    const recovered = await adapter.recoverWorktree('task-recover', branch);
+    expect(fs.existsSync(recovered)).toBe(true);
+  });
+
+  it('recoverWorktree throws worktree_unrecoverable when branch is also gone', async () => {
+    await expect(
+      adapter.recoverWorktree('task-gone', 'nomos/task-gone'),
+    ).rejects.toMatchObject({ code: 'worktree_unrecoverable' });
+  });
+
+  // ── grep ────────────────────────────────────────────────────────────────────
+
+  it('grep returns relative paths matching a pattern', async () => {
+    // Create a file in the repo containing a searchable pattern
+    fs.writeFileSync(path.join(tmpDir, 'search-me.ts'), 'export const SECRET_PATTERN = true;');
+    const git = simpleGit(tmpDir);
+    await git.add('search-me.ts');
+    await git.commit('Add searchable file');
+
+    const results = await adapter.grep('SECRET_PATTERN', tmpDir);
+    expect(results).toContain('search-me.ts');
+  });
+
+  it('grep returns empty array when no matches found', async () => {
+    const results = await adapter.grep('NONEXISTENT_XYZ_12345', tmpDir);
+    expect(results).toEqual([]);
+  });
+
+  it('grep returns empty array on timeout', async () => {
+    // Use 1ms timeout — will almost certainly time out
+    const results = await adapter.grep('.*', tmpDir, 1);
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  // ── isGitRepo / getCurrentCommit ────────────────────────────────────────────
+
+  it('isGitRepo returns true for a git repo', async () => {
+    expect(await adapter.isGitRepo()).toBe(true);
+  });
+
+  it('getCurrentCommit returns a full SHA', async () => {
+    const sha = await adapter.getCurrentCommit();
+    expect(sha).toMatch(/^[a-f0-9]{40}$/);
+  });
+});

package/src/adapters/__tests__/stdio.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import * as process from 'process';
+import { StdioAdapter } from '../stdio.js';
+import { createLogger } from '../../core/logger.js';
+
+const logger = createLogger('error');
+const adapter = new StdioAdapter(logger);
+
+const BASE_OPTIONS = {
+  cwd: process.cwd(),
+  env: process.env as Record<string, string>,
+  heartbeat_timeout_ms: 10000,
+  total_timeout_ms: 10000,
+  max_output_bytes: 1048576,
+};
+
+const NODE = process.execPath;
+
+describe('StdioAdapter', () => {
+  it('captures stdout output from a subprocess', async () => {
+    const result = await adapter.execute({
+      ...BASE_OPTIONS,
+      cmd: NODE,
+      args: ['-e', "process.stdout.write('hello world')"],
+      stdinData: '',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.rawOutput).toContain('hello world');
+    expect(result.killed).toBe(false);
+  });
+
+  it('pipes stdinData to the subprocess and captures output', async () => {
+    const result = await adapter.execute({
+      ...BASE_OPTIONS,
+      cmd: NODE,
+      args: ['-e', 'process.stdin.pipe(process.stdout)'],
+      stdinData: 'piped input content',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.rawOutput).toContain('piped input content');
+  });
+
+  it('kills a long-running process on total_timeout_ms', async () => {
+    const result = await adapter.execute({
+      ...BASE_OPTIONS,
+      cmd: NODE,
+      args: ['-e', 'setTimeout(() => {}, 60000)'],
+      stdinData: '',
+      total_timeout_ms: 500,
+      heartbeat_timeout_ms: 10000,
+    });
+
+    expect(result.killed).toBe(true);
+    expect(result.killReason).toBe('total_timeout');
+  });
+
+  it('propagates non-zero exit codes', async () => {
+    const result = await adapter.execute({
+      ...BASE_OPTIONS,
+      cmd: NODE,
+      args: ['-e', 'process.exit(42)'],
+      stdinData: '',
+    });
+
+    expect(result.exitCode).toBe(42);
+    expect(result.killed).toBe(false);
+  });
+});

package/src/adapters/git.ts

@@ -0,0 +1,226 @@
+import { simpleGit, type SimpleGit } from 'simple-git';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import type { Logger } from 'winston';
+import { NomosError } from '../core/errors.js';
+import type { NomosConfig } from '../types/index.js';
+
+export class GitAdapter {
+  private readonly git: SimpleGit;
+
+  constructor(
+    private readonly projectRoot: string,
+    private readonly config: NomosConfig,
+    private readonly logger: Logger,
+  ) {
+    this.git = simpleGit(projectRoot);
+  }
+
+  resolveWorktreePath(taskId: string): string {
+    const projectName = path.basename(this.projectRoot);
+    const worktreeBase =
+      process.platform === 'win32'
+        ? path.join(process.env.LOCALAPPDATA ?? os.tmpdir(), 'nomos-worktrees')
+        : this.config.execution.worktree_base;
+    return path.join(worktreeBase, projectName, taskId);
+  }
+
+  resolveBranchName(taskId: string): string {
+    return `${this.config.execution.shadow_branch_prefix}${taskId}`;
+  }
+
+  async createWorktree(
+    taskId: string,
+  ): Promise<{ branch: string; worktreePath: string; baseCommit: string }> {
+    const branchName = this.resolveBranchName(taskId);
+    const worktreePath = this.resolveWorktreePath(taskId);
+
+    fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+
+    const existing = await this.git.branch(['--list', branchName]);
+    if (existing.all.length > 0) {
+      throw new NomosError(
+        'branch_exists',
+        `Branch "${branchName}" already exists. Run: arc discard ${taskId}`,
+      );
+    }
+
+    await this.git.raw(['worktree', 'add', worktreePath, '-b', branchName]);
+
+    const baseCommit = (await this.git.revparse(['HEAD'])).trim();
+
+    this.logger.debug(`Created worktree at ${worktreePath} on branch ${branchName}`);
+
+    return { branch: branchName, worktreePath, baseCommit };
+  }
+
+  async recoverWorktree(taskId: string, existingBranch: string): Promise<string> {
+    const worktreePath = this.resolveWorktreePath(taskId);
+
+    const existing = await this.git.branch(['--list', existingBranch]);
+    if (existing.all.length === 0) {
+      throw new NomosError(
+        'worktree_unrecoverable',
+        `Cannot recover worktree for "${taskId}": branch "${existingBranch}" no longer exists.`,
+      );
+    }
+
+    await this.git.raw(['worktree', 'add', worktreePath, existingBranch]);
+
+    this.logger.debug(`Recovered worktree at ${worktreePath} from branch ${existingBranch}`);
+
+    return worktreePath;
+  }
+
+  async removeWorktree(taskId: string, force: boolean = false): Promise<void> {
+    const worktreePath = this.resolveWorktreePath(taskId);
+    const branchName = this.resolveBranchName(taskId);
+
+    await this.git.raw(['worktree', 'remove', worktreePath, '--force']);
+    await this.git.branch([force ? '-D' : '-d', branchName]);
+
+    this.logger.debug(`Removed worktree at ${worktreePath} and branch ${branchName}`);
+  }
+
+  worktreeExists(taskId: string): boolean {
+    return fs.existsSync(this.resolveWorktreePath(taskId));
+  }
+
+  async grep(pattern: string, cwd: string, timeoutMs: number = 5000): Promise<string[]> {
+    const searchGit = simpleGit(cwd);
+    try {
+      const result = await Promise.race([
+        searchGit.raw(['grep', '-l', '-E', pattern]),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('grep timeout')), timeoutMs),
+        ),
+      ]);
+      return result.trim().split('\n').filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+
+  async getDiff(taskId: string, baseCommit: string): Promise<string> {
+    const worktreePath = this.resolveWorktreePath(taskId);
+    const worktreeGit = simpleGit(worktreePath);
+
+    // RT2-2.1 fix: verify baseCommit is reachable before diff
+    try {
+      await worktreeGit.raw(['cat-file', '-t', baseCommit]);
+    } catch {
+      throw new NomosError(
+        'base_commit_unreachable',
+        `Base commit ${baseCommit.slice(0, 8)} is no longer reachable (likely due to rebase or force-push). ` +
+          `Run: arc discard ${taskId} && arc init ${taskId} to reinitialize.`,
+      );
+    }
+
+    const diff = await worktreeGit.diff([`${baseCommit}..HEAD`, '--', '.']);
+    return diff;
+  }
+
+  async commitToShadowBranch(
+    taskId: string,
+    message: string,
+    files: string[],
+  ): Promise<void> {
+    const worktreePath = this.resolveWorktreePath(taskId);
+    const worktreeGit = simpleGit(worktreePath);
+
+    for (const file of files) {
+      const src = path.resolve(this.projectRoot, file);
+      const dst = path.resolve(worktreePath, file);
+
+      // W6: Path traversal defense
+      if (
+        !dst.startsWith(path.resolve(worktreePath) + path.sep) &&
+        dst !== path.resolve(worktreePath)
+      ) {
+        throw new NomosError(
+          'path_traversal',
+          `File path "${file}" resolves outside worktree`,
+        );
+      }
+      if (
+        !src.startsWith(path.resolve(this.projectRoot) + path.sep) &&
+        src !== path.resolve(this.projectRoot)
+      ) {
+        throw new NomosError(
+          'path_traversal',
+          `File path "${file}" resolves outside project root`,
+        );
+      }
+
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(src, dst);
+    }
+
+    await worktreeGit.add(files);
+
+    // M-3 fix: Check git identity before commit to avoid cryptic "Author identity unknown"
+    const email = await worktreeGit.raw(['config', '--get', 'user.email']).catch(() => '');
+    if (!email.trim()) {
+      throw new NomosError(
+        'config_invalid',
+        'Git user identity not configured in the worktree or globally. Run:\n' +
+          '  git config --global user.email "you@example.com"\n' +
+          '  git config --global user.name "Your Name"',
+      );
+    }
+
+    await worktreeGit.commit(message);
+  }
+
+  async mergeToMain(
+    taskId: string,
+    version: number,
+    commitPrefix: string,
+    targetBranch: string = 'main',
+  ): Promise<{ success: boolean; conflicts?: string[] }> {
+    // W3 fix: Target branch verification
+    const currentBranch = (await this.git.branch()).current;
+    if (currentBranch !== targetBranch) {
+      throw new NomosError(
+        'wrong_branch',
+        `Cannot apply: expected to be on "${targetBranch}" but currently on "${currentBranch}". ` +
+          `Switch first: git checkout ${targetBranch}`,
+      );
+    }
+
+    // W7 fix: Dirty working tree check
+    const status = await this.git.status();
+    if (!status.isClean()) {
+      throw new NomosError(
+        'dirty_working_tree',
+        'Cannot apply: working tree has uncommitted changes. Commit or stash them first.',
+      );
+    }
+
+    const branchName = this.resolveBranchName(taskId);
+    const mergeMessage = `${commitPrefix} apply(${taskId}): merge approved plan v${version}`;
+
+    try {
+      await this.git.merge([branchName, '--no-ff', '-m', mergeMessage]);
+      return { success: true };
+    } catch {
+      const mergeStatus = await this.git.status();
+      const conflicts = mergeStatus.conflicted;
+      await this.git.merge(['--abort']);
+      return { success: false, conflicts };
+    }
+  }
+
+  async isGitRepo(): Promise<boolean> {
+    return this.git.checkIsRepo();
+  }
+
+  async getCurrentCommit(): Promise<string> {
+    return (await this.git.revparse(['HEAD'])).trim();
+  }
+
+  async raw(args: string[]): Promise<string> {
+    return this.git.raw(args);
+  }
+}