git-chopstick-core 0.1.2 → 0.1.4

package/src/git/worktree.ts

@@ -1,219 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-import * as Path from 'path'
-import * as Fs from 'fs'
-import type { WorktreeEntry, WorktreeType } from '../models/worktree.js'
-import { normalizePath } from '../lib/helpers/path.js'
-
-/**
- * Get the set of canonical branch refs (e.g. `refs/heads/feature`)
- * checked out in any worktree (main or linked).
- */
-export async function getWorktreeCheckedOutBranches(
-  repository: Repository
-): Promise<ReadonlySet<string>> {
-  const result = await git(
-    ['worktree', 'list', '--porcelain', '-z'],
-    repository.path,
-    'getWorktreeCheckedOutBranches'
-  )
-
-  const branches = new Set<string>()
-
-  // With -z, lines are NUL-terminated and blocks are separated by
-  // double NUL (i.e. an empty string between two NUL terminators).
-  const blocks = result.stdout.split('\0\0')
-
-  for (const block of blocks) {
-    for (const line of block.split('\0')) {
-      if (line.startsWith('branch ')) {
-        branches.add(line.substring('branch '.length))
-      }
-    }
-  }
-
-  return branches
-}
-
-function getDotGitPath(repositoryPath: string): string {
-  return Path.join(repositoryPath, '.git')
-}
-
-export interface IWorktreePathInfo {
-  readonly isLinkedWorktree: boolean
-  readonly mainWorktreePath: string | null
-}
-
-export function parseWorktreePorcelainOutput(
-  stdout: string
-): ReadonlyArray<WorktreeEntry> {
-  if (stdout.trim().length === 0) {
-    return []
-  }
-
-  const blocks = stdout.trim().split('\n\n')
-  const entries: WorktreeEntry[] = []
-
-  for (let i = 0; i < blocks.length; i++) {
-    const lines = blocks[i].split('\n')
-    let path = ''
-    let head = ''
-    let branch: string | null = null
-    let isDetached = false
-    let isLocked = false
-    let isPrunable = false
-
-    for (const line of lines) {
-      if (line.startsWith('worktree ')) {
-        path = line.substring('worktree '.length)
-      } else if (line.startsWith('HEAD ')) {
-        head = line.substring('HEAD '.length)
-      } else if (line.startsWith('branch ')) {
-        branch = line.substring('branch '.length)
-      } else if (line === 'detached') {
-        isDetached = true
-      } else if (line === 'locked' || line.startsWith('locked ')) {
-        isLocked = true
-      } else if (line === 'prunable' || line.startsWith('prunable ')) {
-        isPrunable = true
-      }
-    }
-
-    const type: WorktreeType = i === 0 ? 'main' : 'linked'
-    entries.push({ path, head, branch, isDetached, type, isLocked, isPrunable })
-  }
-
-  return entries
-}
-
-export async function listWorktrees(
-  repository: Repository
-): Promise<ReadonlyArray<WorktreeEntry>> {
-  const result = await git(
-    ['worktree', 'list', '--porcelain'],
-    repository.path,
-    'listWorktrees'
-  )
-
-  return parseWorktreePorcelainOutput(result.stdout)
-}
-
-export async function addWorktree(
-  repository: Repository,
-  path: string,
-  options: {
-    readonly branch?: string
-    readonly createBranch?: string
-    readonly detach?: boolean
-    readonly commitish?: string
-  } = {}
-): Promise<void> {
-  const args = ['worktree', 'add']
-
-  if (options.detach) {
-    args.push('--detach')
-  }
-
-  if (options.createBranch) {
-    args.push('-b', options.createBranch)
-  }
-
-  args.push(path)
-
-  if (options.branch) {
-    args.push(options.branch)
-  } else if (options.commitish) {
-    args.push(options.commitish)
-  }
-
-  await git(args, repository.path, 'addWorktree')
-}
-
-export async function removeWorktree(
-  repository: Repository,
-  path: string
-): Promise<void> {
-  const args = ['worktree', 'remove', '--force', path]
-  await git(args, repository.path, 'removeWorktree')
-}
-
-export async function pruneWorktrees(repository: Repository): Promise<void> {
-  await git(['worktree', 'prune'], repository.path, 'pruneWorktrees')
-}
-
-export async function moveWorktree(
-  repository: Repository,
-  oldPath: string,
-  newPath: string
-): Promise<void> {
-  await git(
-    ['worktree', 'move', oldPath, newPath],
-    repository.path,
-    'moveWorktree'
-  )
-}
-
-export async function isLinkedWorktree(
-  repository: Repository
-): Promise<boolean> {
-  const worktrees = await listWorktrees(repository)
-  const repoPath = normalizePath(repository.path)
-
-  return worktrees.some(
-    wt => wt.type === 'linked' && normalizePath(wt.path) === repoPath
-  )
-}
-
-export async function getMainWorktreePath(
-  repository: Repository
-): Promise<string | null> {
-  const worktrees = await listWorktrees(repository)
-  const main = worktrees.find(wt => wt.type === 'main')
-  return main?.path ?? null
-}
-
-export function getWorktreePathInfoSync(
-  repositoryPath: string
-): IWorktreePathInfo | null {
-  try {
-    const dotGit = getDotGitPath(repositoryPath)
-    // eslint-disable-next-line no-sync
-    const stats = Fs.statSync(dotGit)
-
-    if (stats.isDirectory()) {
-      return { isLinkedWorktree: false, mainWorktreePath: repositoryPath }
-    }
-
-    if (!stats.isFile()) {
-      return null
-    }
-
-    // eslint-disable-next-line no-sync
-    const contents = Fs.readFileSync(dotGit, 'utf8').trim()
-    if (!contents.startsWith('gitdir: ')) {
-      return null
-    }
-
-    const gitDirPath = Path.resolve(
-      repositoryPath,
-      contents.substring('gitdir: '.length)
-    )
-
-    // eslint-disable-next-line no-sync
-    const commondir = Fs.readFileSync(
-      Path.join(gitDirPath, 'commondir'),
-      'utf8'
-    ).trim()
-    if (commondir.length === 0) {
-      return null
-    }
-
-    const commonGitDir = Path.resolve(gitDirPath, commondir)
-    return {
-      isLinkedWorktree: true,
-      mainWorktreePath: Path.dirname(commonGitDir),
-    }
-  } catch {
-    return null
-  }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-// ── All git operations ──
-export * from './git/index.js'
-
-// ── Git error codes enum (renamed to avoid conflict with GitError class from core.js) ──
-export { GitError as GitErrorCodes, type IGitSpawnOptions } from './git/exec.js'
-
-// ── All domain models ──
-export * from './models/index.js'
-
-// ── Explicit re-exports to resolve ambiguities between git and models ──
-export type { ITrailer } from './models/commit.js'

package/src/lib/api.ts

@@ -1,7 +0,0 @@
-export function getHTMLURL(): string {
-  return 'https://github.com'
-}
-
-export function isTrustedRemoteHost(_url: string): boolean {
-  return true
-}

package/src/lib/diff-parser.ts

@@ -1,249 +0,0 @@
-import {
-  IRawDiff,
-  DiffHunk,
-  DiffHunkHeader,
-  DiffLine,
-  DiffLineType,
-  DiffHunkExpansionType,
-} from '../models/diff/index.js'
-import { assertNever } from './fatal-error.js'
-
-const diffHeaderRe = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
-
-export const HiddenBidiCharsRegex = /[\u202A-\u202E]|[\u2066-\u2069]/
-
-const DiffPrefixAdd = '+' as const
-const DiffPrefixDelete = '-' as const
-const DiffPrefixContext = ' ' as const
-const DiffPrefixNoNewline = '\\' as const
-
-type DiffLinePrefix =
-  | typeof DiffPrefixAdd
-  | typeof DiffPrefixDelete
-  | typeof DiffPrefixContext
-  | typeof DiffPrefixNoNewline
-
-const DiffLinePrefixChars: Set<DiffLinePrefix> = new Set([
-  DiffPrefixAdd,
-  DiffPrefixDelete,
-  DiffPrefixContext,
-  DiffPrefixNoNewline,
-])
-
-interface IDiffHeaderInfo {
-  readonly isBinary: boolean
-}
-
-function getLargestLineNumber(hunks: ReadonlyArray<DiffHunk>): number {
-  let largest = 0
-  for (const hunk of hunks) {
-    for (const line of hunk.lines) {
-      if (line.originalLineNumber !== null && line.originalLineNumber > largest) {
-        largest = line.originalLineNumber
-      }
-    }
-  }
-  return largest
-}
-
-function getHunkHeaderExpansionType(
-  _hunkIndex: number,
-  _header: DiffHunkHeader,
-  _previousHunk: DiffHunk | null
-): DiffHunkExpansionType {
-  return DiffHunkExpansionType.None
-}
-
-export class DiffParser {
-  private ls!: number
-  private le!: number
-  private text!: string
-
-  public constructor() {
-    this.reset()
-  }
-
-  private reset() {
-    this.ls = 0
-    this.le = -1
-    this.text = ''
-  }
-
-  private nextLine(): boolean {
-    this.ls = this.le + 1
-    if (this.ls >= this.text.length) return false
-    this.le = this.text.indexOf('\n', this.ls)
-    if (this.le === -1) this.le = this.text.length
-    return this.ls !== this.le
-  }
-
-  private readLine(): string | null {
-    return this.nextLine() ? this.text.substring(this.ls, this.le) : null
-  }
-
-  private lineStartsWith(searchString: string): boolean {
-    return this.text.startsWith(searchString, this.ls)
-  }
-
-  private lineEndsWith(searchString: string): boolean {
-    return this.text.endsWith(searchString, this.le)
-  }
-
-  private peek(): string | null {
-    const p = this.le + 1
-    return p < this.text.length ? this.text[p] : null
-  }
-
-  private parseDiffHeader(): IDiffHeaderInfo | null {
-    while (this.nextLine()) {
-      if (this.lineStartsWith('Binary files ') && this.lineEndsWith('differ')) {
-        return { isBinary: true }
-      }
-      if (this.lineStartsWith('+++')) {
-        return { isBinary: false }
-      }
-    }
-    return null
-  }
-
-  private numberFromGroup(
-    m: RegExpMatchArray,
-    group: number,
-    defaultValue: number | null = null
-  ): number {
-    const str = m[group]
-    if (!str) {
-      if (defaultValue === null) {
-        throw new Error(
-          `Group ${group} missing from regexp match and no defaultValue was provided`
-        )
-      }
-      return defaultValue
-    }
-    const num = parseInt(str, 10)
-    if (isNaN(num)) {
-      throw new Error(`Could not parse capture group ${group} into number: ${str}`)
-    }
-    return num
-  }
-
-  private parseHunkHeader(line: string): DiffHunkHeader {
-    const m = diffHeaderRe.exec(line)
-    if (!m) throw new Error('Invalid hunk header format')
-
-    const oldStartLine = this.numberFromGroup(m, 1)
-    const oldLineCount = this.numberFromGroup(m, 2, 1)
-    const newStartLine = this.numberFromGroup(m, 3)
-    const newLineCount = this.numberFromGroup(m, 4, 1)
-
-    return new DiffHunkHeader(oldStartLine, oldLineCount, newStartLine, newLineCount)
-  }
-
-  private parseLinePrefix(c: string | null): DiffLinePrefix | null {
-    if (c && c.length && (DiffLinePrefixChars as Set<string>).has(c[0])) {
-      return c[0] as DiffLinePrefix
-    }
-    return null
-  }
-
-  private parseHunk(
-    linesConsumed: number,
-    _hunkIndex: number,
-    _previousHunk: DiffHunk | null
-  ): DiffHunk {
-    const headerLine = this.readLine()
-    if (!headerLine) throw new Error('Expected hunk header but reached end of diff')
-
-    const header = this.parseHunkHeader(headerLine)
-    const lines = new Array<DiffLine>()
-    lines.push(new DiffLine(headerLine, DiffLineType.Hunk, 1, null, null))
-
-    let rollingDiffBeforeCounter = header.oldStartLine
-    let rollingDiffAfterCounter = header.newStartLine
-    let diffLineNumber = linesConsumed
-
-    let c: DiffLinePrefix | null
-    while ((c = this.parseLinePrefix(this.peek()))) {
-      const line = this.readLine()
-      if (!line) throw new Error('Expected unified diff line but reached end of diff')
-
-      if (c === DiffPrefixNoNewline) {
-        if (line.length < 12) {
-          throw new Error(
-            `Expected "no newline at end of file" marker to be at least 12 bytes long`
-          )
-        }
-        const previousLineIndex = lines.length - 1
-        lines[previousLineIndex] = lines[previousLineIndex].withNoTrailingNewLine(true)
-        continue
-      }
-
-      diffLineNumber++
-
-      let diffLine: DiffLine
-      if (c === DiffPrefixAdd) {
-        diffLine = new DiffLine(line, DiffLineType.Add, diffLineNumber, null, rollingDiffAfterCounter++)
-      } else if (c === DiffPrefixDelete) {
-        diffLine = new DiffLine(line, DiffLineType.Delete, diffLineNumber, rollingDiffBeforeCounter++, null)
-      } else if (c === DiffPrefixContext) {
-        diffLine = new DiffLine(line, DiffLineType.Context, diffLineNumber, rollingDiffBeforeCounter++, rollingDiffAfterCounter++)
-      } else {
-        return assertNever(c, `Unknown DiffLinePrefix: ${c}`)
-      }
-      lines.push(diffLine)
-    }
-
-    if (lines.length === 1) {
-      throw new Error('Malformed diff, empty hunk')
-    }
-
-    return new DiffHunk(
-      header,
-      lines,
-      linesConsumed,
-      linesConsumed + lines.length - 1,
-      getHunkHeaderExpansionType(_hunkIndex, header, _previousHunk)
-    )
-  }
-
-  public parse(text: string): IRawDiff {
-    this.text = text
-    try {
-      const headerInfo = this.parseDiffHeader()
-      const headerEnd = this.le
-      const header = this.text.substring(0, headerEnd)
-
-      if (!headerInfo) {
-        return { header, contents: '', hunks: [], isBinary: false, maxLineNumber: 0, hasHiddenBidiChars: false }
-      }
-
-      if (headerInfo.isBinary) {
-        return { header, contents: '', hunks: [], isBinary: true, maxLineNumber: 0, hasHiddenBidiChars: false }
-      }
-
-      const hunks = new Array<DiffHunk>()
-      let linesConsumed = 0
-
-      do {
-        const hunk = this.parseHunk(linesConsumed, hunks.length, null)
-        hunks.push(hunk)
-        linesConsumed += hunk.lines.length
-      } while (this.peek())
-
-      const contents = this.text
-        .substring(headerEnd + 1, this.le)
-        .replace(/\n\/g, '')
-
-      return {
-        header,
-        contents,
-        hunks,
-        isBinary: headerInfo.isBinary,
-        maxLineNumber: getLargestLineNumber(hunks),
-        hasHiddenBidiChars: HiddenBidiCharsRegex.test(text),
-      }
-    } finally {
-      this.reset()
-    }
-  }
-}

package/src/lib/directory-exists.ts

@@ -1,10 +0,0 @@
-import { stat } from 'fs/promises'
-
-export const directoryExists = async (path: string) => {
-  try {
-    const s = await stat(path)
-    return s.isDirectory()
-  } catch {
-    return false
-  }
-}

package/src/lib/errno-exception.ts

@@ -1,12 +0,0 @@
-interface IErrnoException extends Error {
-  readonly code: string
-  readonly syscall: string
-}
-
-export function isErrnoException(err: any): err is IErrnoException {
-  return (
-    err instanceof Error &&
-    typeof (err as any).code === 'string' &&
-    typeof (err as any).syscall === 'string'
-  )
-}

package/src/lib/fatal-error.ts

@@ -1,23 +0,0 @@
-export function fatalError(msg: string): never {
-  throw new Error(msg)
-}
-
-export function assertNever(x: never, message: string): never {
-  throw new Error(message)
-}
-
-export function forceUnwrap<T>(message: string, x: T | null | undefined): T {
-  if (x == null) {
-    return fatalError(message)
-  }
-  return x
-}
-
-export function assertNonNullable<T>(
-  x: T,
-  message: string
-): asserts x is NonNullable<T> {
-  if (x == null) {
-    return fatalError(message)
-  }
-}

package/src/lib/feature-flag.ts

@@ -1,29 +0,0 @@
-export function enableImagePreviewsForDDSFiles(): boolean {
-  return false
-}
-
-export function enableReadmeOverwriteWarning(): boolean {
-  return false
-}
-
-export function enableWSLDetection(): boolean {
-  return false
-}
-
-export function enablePreviousTagSuggestions(): boolean {
-  return false
-}
-
-export function enablePullRequestQuickView(): boolean {
-  return false
-}
-
-export const enableCustomIntegration = () => true
-export const enableResizingToolbarButtons = () => true
-export const enableHooksEnvironment = () => true
-export const enableHooksByDefault = () => true
-export const enableFormattingPreferences = () => true
-export const enableCopilotConflictResolution = () => false
-export const enableTestMenuItems = () => false
-export const enableCommitMessageGeneration = () => false
-export const enableCopilotSdkCommitMessageGeneration = () => false

package/src/lib/file-system.ts

@@ -1,7 +0,0 @@
-import { mkdtempSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-
-export function getTempFilePath(prefix: string): string {
-  return join(mkdtempSync(join(tmpdir(), prefix)), 'temp')
-}

package/src/lib/get-old-path.ts

@@ -1,11 +0,0 @@
-import { FileChange, AppFileStatusKind } from '../models/status.js'
-
-export function getOldPathOrDefault(file: FileChange) {
-  if (
-    file.status.kind === AppFileStatusKind.Renamed ||
-    file.status.kind === AppFileStatusKind.Copied
-  ) {
-    return file.status.oldPath
-  }
-  return file.path
-}

package/src/lib/git/environment.ts

@@ -1,14 +0,0 @@
-import { IRemote } from '../../models/remote.js'
-
-export async function envForRemoteOperation(
-  _url: string | null
-): Promise<Record<string, string | undefined>> {
-  return {}
-}
-
-export function getFallbackUrlForProxyResolve(
-  _repository: any,
-  _remote: IRemote | null
-): string | null {
-  return null
-}

package/src/lib/git-perf.ts

@@ -1,3 +0,0 @@
-export function measure<T>(_name: string, fn: () => Promise<T>): Promise<T> {
-  return fn()
-}

package/src/lib/helpers/default-branch.ts

@@ -1,3 +0,0 @@
-export async function getDefaultBranch(): Promise<string> {
-  return 'main'
-}

package/src/lib/helpers/path.ts

@@ -1,5 +0,0 @@
-import * as Path from 'path'
-
-export function normalizePath(path: string): string {
-  return Path.normalize(path)
-}

package/src/lib/hooks/with-hooks-env.ts

@@ -1,7 +0,0 @@
-export function withHooksEnv<T>(
-  fn: (env: Record<string, string | undefined>) => Promise<T>,
-  _path: string,
-  _options?: { interceptHooks?: string[] }
-): Promise<T> {
-  return fn({})
-}

package/src/lib/merge.ts

@@ -1,3 +0,0 @@
-export function merge<T, U>(a: T, b: U): T & U {
-  return { ...a, ...b }
-}

package/src/lib/noop.ts

@@ -1 +0,0 @@
-export default function noop() {}

package/src/lib/patch-formatter.ts

@@ -1,18 +0,0 @@
-import { DiffSelection } from '../models/diff/index.js'
-import { WorkingDirectoryFileChange } from '../models/status.js'
-import { Repository } from '../models/repository.js'
-
-export async function formatPatch(
-  _repository: Repository,
-  _file: WorkingDirectoryFileChange,
-  _selection: DiffSelection
-): Promise<string> {
-  return ''
-}
-
-export async function formatPatchToDiscardChanges(
-  _repository: Repository,
-  _file: WorkingDirectoryFileChange
-): Promise<string> {
-  return ''
-}

package/src/lib/path-exists.ts

@@ -1,7 +0,0 @@
-import { access } from 'fs/promises'
-
-export const pathExists = (path: string) =>
-  access(path).then(
-    () => true,
-    () => false
-  )

package/src/lib/progress/from-process.ts

@@ -1,10 +0,0 @@
-import { ChildProcess } from 'child_process'
-import { IGitExecutionOptions } from '../../git/core.js'
-
-export async function executionOptionsWithProgress(
-  options: IGitExecutionOptions,
-  _parser: any,
-  _progressCallback: (progress: any) => void
-): Promise<IGitExecutionOptions> {
-  return options
-}