@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/git/git-adapter.ts

@@ -1,12 +1,7 @@
-import { existsSync, realpathSync } from 'node:fs'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import sortBy from 'lodash/sortBy'
-import uniq from 'lodash/uniq'
-
-import { runCommand } from '../shell/run-command'
+import { commitOps } from './git-commits'
+import { joinOps } from './git-join'
+import { readOps } from './git-read'
+import { createWorktreeOps } from './git-worktrees'
 
 /** One changed path in a worktree, from `git status`. */
 export type FileChange = {
@@ -17,6 +12,9 @@ export type FileChange = {
 /** A commit the engine made. */
 export type EngineCommit = { sha: string; files: string[] }
 
+/** Where a commit is, next to a base commit (see `commitOnBase`). */
+export type CommitPlace = 'on_base' | 'not_on_base' | 'unknown'
+
 /**
  * Every git side effect of a run. Only the engine calls these; agents never
  * commit, branch, or push.
@@ -59,6 +57,12 @@ export type GitAdapter = {
      * included.
      */
     changedSince: (args: { cwd: string; from: string }) => Promise<string[]>
+    /** The text of `path` at commit `sha`, or `null` if it wasn't there (#581). */
+    fileAt: (args: {
+        cwd: string
+        sha: string
+        path: string
+    }) => Promise<string | null>
     /** Paths that differ between two commits. */
     filesBetween: (args: {
         cwd: string
@@ -87,6 +91,15 @@ export type GitAdapter = {
         /** Untracked paths to keep out of the commit. Left out, none. */
         leave_out?: string[]
     }) => Promise<EngineCommit>
+    /**
+     * Commits only `paths` (new or changed), skipping hooks. Every other
+     * change at `cwd`, staged or not, stays out of the commit, as it was.
+     */
+    commitPaths: (args: {
+        cwd: string
+        message: string
+        paths: string[]
+    }) => Promise<EngineCommit>
     /**
      * Throws away every uncommitted change at `cwd`, new untracked files
      * included (ignored files such as `node_modules` stay), and returns the
@@ -111,22 +124,33 @@ export type GitAdapter = {
     }) => Promise<string[]>
     /**
      * Replays commits onto the branch checked out at `cwd`, in order. A clash
-     * is undone and returned as an error.
+     * is undone and returned as an error. `lines_changed` is the lines the
+     * replay added plus removed, binary files counting 0.
      */
     replay: (args: {
         cwd: string
         commits: string[]
-    }) => Promise<{ ok: true; shas: string[] } | { ok: false; error: string }>
+    }) => Promise<
+        | { ok: true; shas: string[]; lines_changed: number }
+        | { ok: false; error: string }
+    >
     /**
      * Undoes a replay on the branch checked out at `cwd`: resets it hard to
-     * the commit before `first_sha`. Safe to run twice.
+     * the commit before `first_sha`. It never rewinds over other work
+     * (#519), so it refuses, with the branch left as it is, when
+     * `first_sha` is no commit (or has no parent), is not on the branch, or
+     * when any commit from `first_sha` up to the branch's tip is not in
+     * `only`. Safe to run twice: with the branch already at the commit
+     * before `first_sha`, it undoes nothing.
      *
-     * @returns The commits it undid, oldest first.
+     * @returns The commits it undid, oldest first, or why it refused.
      */
     undoReplay: (args: {
         cwd: string
         first_sha: string
-    }) => Promise<{ undone: string[] }>
+        /** The commits it may undo: any other on top of `first_sha` refuses. */
+        only: string[]
+    }) => Promise<{ ok: true; undone: string[] } | { ok: false; error: string }>
     /**
      * Moves a worktree's change onto another commit: resets the worktree at
      * `cwd` hard to `onto`, then applies the whole diff from `from` to `to`
@@ -150,6 +174,16 @@ export type GitAdapter = {
     push: (args: { cwd: string; branch: string }) => Promise<void>
     /** The commit checked out at `cwd`. */
     head: (args: { cwd: string }) => Promise<string>
+    /**
+     * Where commit `sha` is: `on_base` if it is `base` or in its history,
+     * `not_on_base` if the repo has it but `base` doesn't, `unknown` if the
+     * repo has no such commit (or `sha` is no commit id).
+     */
+    commitOnBase: (args: {
+        cwd: string
+        sha: string
+        base: string
+    }) => Promise<CommitPlace>
     /**
      * The commit checked out at `cwd` with its whole message (trimmed) and
      * its files, such as to adopt a commit a crash left out of the journal.
@@ -159,84 +193,6 @@ export type GitAdapter = {
     }) => Promise<EngineCommit & { message: string }>
 }
 
-const gitRun = ({ cwd, args }: { cwd: string; args: string[] }) =>
-    runCommand({ cmd: ['git', ...args], cwd, timeout_ms: 120_000 })
-
-const gitOk = async ({
-    cwd,
-    args,
-}: {
-    cwd: string
-    args: string[]
-}): Promise<string> => {
-    const result = await gitRun({ cwd, args })
-    if (result.exit_code !== 0) {
-        throw new Error(
-            `git ${args.join(' ')} failed in ${cwd}:\n${result.stderr || result.stdout}`
-        )
-    }
-    return result.stdout
-}
-
-const lines = (text: string): string[] =>
-    text.split('\n').filter((line) => line.trim() !== '')
-
-/** Parses `git status --porcelain=v1 -z --untracked-files=all`. */
-const parseStatus = ({ text }: { text: string }): FileChange[] => {
-    const parts = text.split('\0').filter((part) => part.length > 0)
-    const changes: FileChange[] = []
-    for (let index = 0; index < parts.length; index += 1) {
-        const part = parts[index] ?? ''
-        const [x = ' ', y = ' '] = part
-        const path = part.slice(3)
-        if (x === 'R' || x === 'C') index += 1 // the next part is the old path
-        if (x === 'D' || y === 'D') changes.push({ path, change: 'deleted' })
-        else if (x === '?' || x === 'A' || x === 'R' || x === 'C')
-            changes.push({ path, change: 'added' })
-        else changes.push({ path, change: 'modified' })
-    }
-    return sortBy(changes, 'path')
-}
-
-/**
- * Stages every change at `cwd` (`git add -A`) but the paths in `leave_out`,
- * which git never looks at: each is an exact, literal pathspec to exclude,
- * passed through a file so any number of them fit.
- */
-const stageAll = async ({
-    cwd,
-    leave_out,
-}: {
-    cwd: string
-    leave_out: string[]
-}): Promise<void> => {
-    if (leave_out.length === 0) {
-        await gitOk({ cwd, args: ['add', '-A'] })
-        return
-    }
-    const folder = await mkdtemp(join(tmpdir(), 'luca-stage-'))
-    try {
-        const pathspecs = join(folder, 'pathspecs')
-        await Bun.write(
-            pathspecs,
-            ['.', ...leave_out.map((path) => `:(exclude,literal)${path}`)]
-                .map((spec) => `${spec}\0`)
-                .join('')
-        )
-        await gitOk({
-            cwd,
-            args: [
-                'add',
-                '-A',
-                `--pathspec-from-file=${pathspecs}`,
-                '--pathspec-file-nul',
-            ],
-        })
-    } finally {
-        await rm(folder, { recursive: true, force: true })
-    }
-}
-
 /**
  * Runs async work one piece at a time, in call order, so git never races
  * itself on the repo's lock files when tickets build at the same time.
@@ -263,311 +219,11 @@ export const createGitAdapter = ({
 }: {
     repo_root: string
 }): GitAdapter => {
-    const head = async ({ cwd }: { cwd: string }) =>
-        (await gitOk({ cwd, args: ['rev-parse', 'HEAD'] })).trim()
-
-    /** The branch git has checked out in a worktree at `path`, if any. */
-    const worktreeBranchAt = async ({
-        path,
-    }: {
-        path: string
-    }): Promise<{ branch: string | null } | null> => {
-        if (!existsSync(path)) return null
-        const wanted = realpathSync(path)
-        const listed = await gitOk({
-            cwd: repo_root,
-            args: ['worktree', 'list', '--porcelain'],
-        })
-        for (const block of listed.split('\n\n')) {
-            const fields = lines(block)
-            const at = fields
-                .find((line) => line.startsWith('worktree '))
-                ?.slice('worktree '.length)
-            if (at === undefined || !existsSync(at)) continue
-            if (realpathSync(at) !== wanted) continue
-            const ref = fields
-                .find((line) => line.startsWith('branch '))
-                ?.slice('branch '.length)
-            return { branch: ref?.replace(/^refs\/heads\//, '') ?? null }
-        }
-        return null
-    }
-
-    const branchExists = async ({ branch }: { branch: string }) =>
-        (
-            await gitRun({
-                cwd: repo_root,
-                args: [
-                    'rev-parse',
-                    '--verify',
-                    '--quiet',
-                    `refs/heads/${branch}`,
-                ],
-            })
-        ).exit_code === 0
-
-    const addWorktree = async ({
-        branch,
-        from,
-        path,
-    }: {
-        branch: string
-        from: string
-        path: string
-    }) => {
-        const known = await worktreeBranchAt({ path })
-        if (known !== null && known.branch !== branch) {
-            throw new Error(
-                `${path} is already a worktree on ${known.branch ?? 'no branch'}, not ${branch}.`
-            )
-        }
-        if (known !== null) {
-            // Made before a crash: nothing has worked in it since, so finish
-            // a checkout the crash may have cut off, and adopt it.
-            const reset = await gitRun({
-                cwd: path,
-                args: ['reset', '--quiet', '--hard', 'HEAD'],
-            })
-            if (reset.exit_code === 0) {
-                return { base_sha: await head({ cwd: path }) }
-            }
-            await gitRun({
-                cwd: repo_root,
-                args: ['worktree', 'remove', '--force', '--force', path],
-            })
-        }
-        // A half-made folder git doesn't know (or no longer does) goes.
-        await rm(path, { recursive: true, force: true })
-        await gitOk({ cwd: repo_root, args: ['worktree', 'prune'] })
-        await gitOk({
-            cwd: repo_root,
-            args: (await branchExists({ branch }))
-                ? ['worktree', 'add', '--quiet', path, branch]
-                : [
-                      'worktree',
-                      'add',
-                      '--quiet',
-                      '--no-track',
-                      '-b',
-                      branch,
-                      path,
-                      from,
-                  ],
-        })
-        return { base_sha: await head({ cwd: path }) }
-    }
-
-    const filesOf = async ({ cwd, sha }: { cwd: string; sha: string }) =>
-        lines(
-            await gitOk({
-                cwd,
-                args: ['show', '--name-only', '--format=', sha],
-            })
-        ).toSorted()
-
     const raw: GitAdapter = {
-        fetchBase: async ({ base_branch }) => {
-            const fetched = await gitRun({
-                cwd: repo_root,
-                args: [
-                    'fetch',
-                    '--quiet',
-                    'origin',
-                    `+refs/heads/${base_branch}:refs/remotes/origin/${base_branch}`,
-                ],
-            })
-            return fetched.exit_code === 0
-                ? { ok: true }
-                : {
-                      ok: false,
-                      error: (fetched.stderr || fetched.stdout).trim(),
-                  }
-        },
-        createRunBranch: ({ branch, base_branch, path }) =>
-            addWorktree({ branch, from: `origin/${base_branch}`, path }),
-        createWorktree: addWorktree,
-        changes: async ({ cwd }) =>
-            parseStatus({
-                text: await gitOk({
-                    cwd,
-                    args: [
-                        'status',
-                        '--porcelain=v1',
-                        '-z',
-                        '--untracked-files=all',
-                    ],
-                }),
-            }),
-        changedSince: async ({ cwd, from }) => {
-            const tracked = lines(
-                await gitOk({ cwd, args: ['diff', '--name-only', from] })
-            )
-            const untracked = lines(
-                await gitOk({
-                    cwd,
-                    args: ['ls-files', '--others', '--exclude-standard'],
-                })
-            )
-            return uniq([...tracked, ...untracked]).toSorted()
-        },
-        filesBetween: async ({ cwd, from, to }) =>
-            lines(
-                await gitOk({ cwd, args: ['diff', '--name-only', from, to] })
-            ).toSorted(),
-        untracked: async ({ cwd }) =>
-            (
-                await gitOk({
-                    cwd,
-                    args: ['ls-files', '--others', '--exclude-standard', '-z'],
-                })
-            )
-                .split('\0')
-                .filter((path) => path !== ''),
-        listFiles: async ({ cwd }) =>
-            lines(
-                await gitOk({
-                    cwd,
-                    args: [
-                        'ls-files',
-                        '--cached',
-                        '--others',
-                        '--exclude-standard',
-                    ],
-                })
-            ),
-        filesMentioning: async ({ cwd, text }) => {
-            // git grep exits 1 when nothing matches; that is an empty answer.
-            const result = await gitRun({
-                cwd,
-                args: ['grep', '-l', '-F', '-e', text, '--', '.'],
-            })
-            return result.exit_code === 0 ? lines(result.stdout) : []
-        },
-        commitAll: async ({ cwd, message, leave_out }) => {
-            await stageAll({ cwd, leave_out: leave_out ?? [] })
-            await gitOk({
-                cwd,
-                args: ['commit', '--quiet', '--no-verify', '-m', message],
-            })
-            const sha = await head({ cwd })
-            return { sha, files: await filesOf({ cwd, sha }) }
-        },
-        discardChanges: async ({ cwd }) => {
-            await gitOk({ cwd, args: ['reset', '--quiet', '--hard', 'HEAD'] })
-            await gitOk({ cwd, args: ['clean', '--quiet', '-f', '-d'] })
-            return { sha: await head({ cwd }) }
-        },
-        resetWorktree: async ({ cwd, to }) => {
-            // A cherry-pick a crash cut off leaves its sequence behind.
-            await gitRun({ cwd, args: ['cherry-pick', '--quit'] })
-            await gitOk({ cwd, args: ['reset', '--quiet', '--hard', to] })
-            await gitOk({ cwd, args: ['clean', '--quiet', '-f', '-d'] })
-            return { sha: await head({ cwd }) }
-        },
-        commitsBetween: async ({ cwd, from, to }) =>
-            lines(
-                await gitOk({
-                    cwd,
-                    args: ['rev-list', '--reverse', `${from}..${to}`],
-                })
-            ),
-        replay: async ({ cwd, commits }) => {
-            const before = await head({ cwd })
-            const picked = await gitRun({
-                cwd,
-                args: ['cherry-pick', ...commits],
-            })
-            if (picked.exit_code !== 0) {
-                await gitRun({ cwd, args: ['cherry-pick', '--abort'] })
-                return { ok: false, error: picked.stderr || picked.stdout }
-            }
-            return {
-                ok: true,
-                shas: lines(
-                    await gitOk({
-                        cwd,
-                        args: ['rev-list', '--reverse', `${before}..HEAD`],
-                    })
-                ),
-            }
-        },
-        undoReplay: async ({ cwd, first_sha }) => {
-            const before = `${first_sha}^`
-            const undone = lines(
-                await gitOk({
-                    cwd,
-                    args: ['rev-list', '--reverse', `${before}..HEAD`],
-                })
-            )
-            await gitOk({ cwd, args: ['reset', '--quiet', '--hard', before] })
-            return { undone }
-        },
-        rebaseWorktree: async ({ cwd, from, to, onto }) => {
-            const folder = await mkdtemp(join(tmpdir(), 'luca-rebase-'))
-            try {
-                const patch = join(folder, 'change.patch')
-                await gitOk({
-                    cwd,
-                    args: ['diff', '--binary', `--output=${patch}`, from, to],
-                })
-                await gitOk({ cwd, args: ['reset', '--quiet', '--hard', onto] })
-                if ((await Bun.file(patch).size) === 0) return { conflicts: [] }
-                const applied = await gitRun({
-                    cwd,
-                    args: ['apply', '--3way', patch],
-                })
-                const conflicts = lines(
-                    await gitOk({
-                        cwd,
-                        args: ['diff', '--name-only', '--diff-filter=U'],
-                    })
-                ).toSorted()
-                if (applied.exit_code !== 0 && conflicts.length === 0) {
-                    throw new Error(
-                        `git apply --3way failed in ${cwd}:\n${applied.stderr || applied.stdout}`
-                    )
-                }
-                // Everything becomes plain uncommitted changes, markers kept.
-                await gitOk({ cwd, args: ['reset', '--quiet'] })
-                return { conflicts }
-            } finally {
-                await rm(folder, { recursive: true, force: true })
-            }
-        },
-        removeWorktree: async ({ path }) => {
-            if (existsSync(path)) {
-                // A folder that is no worktree (or not any more) is fine.
-                await gitRun({
-                    cwd: repo_root,
-                    args: ['worktree', 'remove', '--force', path],
-                })
-            }
-            await gitOk({ cwd: repo_root, args: ['worktree', 'prune'] })
-        },
-        push: async ({ cwd, branch }) => {
-            await gitOk({
-                cwd,
-                args: [
-                    'push',
-                    '--quiet',
-                    'origin',
-                    `${branch}:refs/heads/${branch}`,
-                ],
-            })
-        },
-        head,
-        lastCommit: async ({ cwd }) => {
-            const sha = await head({ cwd })
-            const message = await gitOk({
-                cwd,
-                args: ['log', '-1', '--format=%B', sha],
-            })
-            return {
-                sha,
-                message: message.trim(),
-                files: await filesOf({ cwd, sha }),
-            }
-        },
+        ...createWorktreeOps({ repo_root }),
+        ...readOps,
+        ...commitOps,
+        ...joinOps,
     }
 
     const inTurn = createQueue()
@@ -581,11 +237,13 @@ export const createGitAdapter = ({
         createWorktree: serial(raw.createWorktree),
         changes: serial(raw.changes),
         changedSince: serial(raw.changedSince),
+        fileAt: serial(raw.fileAt),
         filesBetween: serial(raw.filesBetween),
         untracked: serial(raw.untracked),
         listFiles: serial(raw.listFiles),
         filesMentioning: serial(raw.filesMentioning),
         commitAll: serial(raw.commitAll),
+        commitPaths: serial(raw.commitPaths),
         discardChanges: serial(raw.discardChanges),
         resetWorktree: serial(raw.resetWorktree),
         commitsBetween: serial(raw.commitsBetween),
@@ -595,6 +253,7 @@ export const createGitAdapter = ({
         removeWorktree: serial(raw.removeWorktree),
         push: serial(raw.push),
         head: serial(raw.head),
+        commitOnBase: serial(raw.commitOnBase),
         lastCommit: serial(raw.lastCommit),
     }
 }

package/engine/git/git-commits.ts

@@ -0,0 +1,132 @@
+/**
+ * The git adapter's commits and clean-ups: stage and commit all or some
+ * paths, read the last commit, throw away or reset a worktree's changes, and
+ * push. Every call skips hooks: the engine ran the gates.
+ */
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { GitAdapter } from './git-adapter'
+import { gitOk, gitRun, head, lines } from './git-run'
+
+/**
+ * Stages every change at `cwd` (`git add -A`) but the paths in `leave_out`,
+ * which git never looks at: each is an exact, literal pathspec to exclude,
+ * passed through a file so any number of them fit.
+ */
+export const stageAll = async ({
+    cwd,
+    leave_out,
+}: {
+    cwd: string
+    leave_out: string[]
+}): Promise<void> => {
+    if (leave_out.length === 0) {
+        await gitOk({ cwd, args: ['add', '-A'] })
+        return
+    }
+    const folder = await mkdtemp(join(tmpdir(), 'luca-stage-'))
+    try {
+        const pathspecs = join(folder, 'pathspecs')
+        await Bun.write(
+            pathspecs,
+            ['.', ...leave_out.map((path) => `:(exclude,literal)${path}`)]
+                .map((spec) => `${spec}\0`)
+                .join('')
+        )
+        await gitOk({
+            cwd,
+            args: [
+                'add',
+                '-A',
+                `--pathspec-from-file=${pathspecs}`,
+                '--pathspec-file-nul',
+            ],
+        })
+    } finally {
+        await rm(folder, { recursive: true, force: true })
+    }
+}
+
+export const filesOf = async ({ cwd, sha }: { cwd: string; sha: string }) =>
+    lines(
+        await gitOk({
+            cwd,
+            args: ['show', '--name-only', '--format=', sha],
+        })
+    ).toSorted()
+
+export const commitOps: Pick<
+    GitAdapter,
+    | 'commitAll'
+    | 'commitPaths'
+    | 'discardChanges'
+    | 'resetWorktree'
+    | 'push'
+    | 'lastCommit'
+> = {
+    commitAll: async ({ cwd, message, leave_out }) => {
+        await stageAll({ cwd, leave_out: leave_out ?? [] })
+        await gitOk({
+            cwd,
+            args: ['commit', '--quiet', '--no-verify', '-m', message],
+        })
+        const sha = await head({ cwd })
+        return { sha, files: await filesOf({ cwd, sha }) }
+    },
+    commitPaths: async ({ cwd, message, paths }) => {
+        const pathspecs = paths.map((path) => `:(literal)${path}`)
+        await gitOk({ cwd, args: ['add', '--', ...pathspecs] })
+        // With paths, `git commit` commits just them (`--only`).
+        await gitOk({
+            cwd,
+            args: [
+                'commit',
+                '--quiet',
+                '--no-verify',
+                '-m',
+                message,
+                '--',
+                ...pathspecs,
+            ],
+        })
+        const sha = await head({ cwd })
+        return { sha, files: await filesOf({ cwd, sha }) }
+    },
+    discardChanges: async ({ cwd }) => {
+        await gitOk({ cwd, args: ['reset', '--quiet', '--hard', 'HEAD'] })
+        await gitOk({ cwd, args: ['clean', '--quiet', '-f', '-d'] })
+        return { sha: await head({ cwd }) }
+    },
+    resetWorktree: async ({ cwd, to }) => {
+        // A cherry-pick a crash cut off leaves its sequence behind.
+        await gitRun({ cwd, args: ['cherry-pick', '--quit'] })
+        await gitOk({ cwd, args: ['reset', '--quiet', '--hard', to] })
+        await gitOk({ cwd, args: ['clean', '--quiet', '-f', '-d'] })
+        return { sha: await head({ cwd }) }
+    },
+    push: async ({ cwd, branch }) => {
+        await gitOk({
+            cwd,
+            args: [
+                'push',
+                '--quiet',
+                'origin',
+                `${branch}:refs/heads/${branch}`,
+            ],
+        })
+    },
+    lastCommit: async ({ cwd }) => {
+        const sha = await head({ cwd })
+        const message = await gitOk({
+            cwd,
+            args: ['log', '-1', '--format=%B', sha],
+        })
+        return {
+            sha,
+            message: message.trim(),
+            files: await filesOf({ cwd, sha }),
+        }
+    },
+}