@otto-assistant/bridge 0.4.101 → 0.4.103

package/src/worktrees.test.ts

@@ -8,19 +8,19 @@ import {
   buildSubmoduleReferencePlan,
   createWorktreeWithSubmodules,
   execAsync,
+  getManagedWorktreeDirectory,
   parseGitmodulesFileContent,
+  parseGitWorktreeListPorcelain,
 } from './worktrees.js'
+import {
+  formatAutoWorktreeName,
+  formatWorktreeName,
+  shortenWorktreeSlug,
+} from './commands/new-worktree.js'
+import { setDataDir } from './config.js'
 
 const GIT_TIMEOUT_MS = 60_000
 
-function gitCommand(args: string[]): string {
-  return `git ${args
-    .map((arg) => {
-      return JSON.stringify(arg)
-    })
-    .join(' ')}`
-}
-
 async function git({
   cwd,
   args,
@@ -28,7 +28,13 @@ async function git({
   cwd: string
   args: string[]
 }): Promise<string> {
-  const result = await execAsync(gitCommand(args), {
+  const command = `git ${args
+    .map((arg) => {
+      return JSON.stringify(arg)
+    })
+    .join(' ')}`
+
+  const result = await execAsync(command, {
     cwd,
     timeout: GIT_TIMEOUT_MS,
   })
@@ -221,4 +227,263 @@ describe('worktrees', () => {
     }
   })
 
+  test('createWorktreeWithSubmodules uses current HEAD even when origin does not have the commit', async () => {
+    const sandbox = createTestRoot()
+    const parentRemote = path.join(sandbox, 'parent-remote.git')
+    const parentLocal = path.join(sandbox, 'parent-local')
+    const worktreeName = `opencode/kimaki-local-head-${Date.now()}`
+
+    let createdWorktreeDirectory = ''
+
+    try {
+      await git({ cwd: sandbox, args: ['init', '--bare', '-b', 'main', parentRemote] })
+      await git({ cwd: sandbox, args: ['clone', parentRemote, parentLocal] })
+
+      await git({
+        cwd: parentLocal,
+        args: ['config', 'user.email', 'kimaki-tests@example.com'],
+      })
+      await git({
+        cwd: parentLocal,
+        args: ['config', 'user.name', 'Kimaki Tests'],
+      })
+
+      fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v1\n', 'utf-8')
+      await git({ cwd: parentLocal, args: ['add', 'README.md'] })
+      await git({ cwd: parentLocal, args: ['commit', '-m', 'v1'] })
+      await git({ cwd: parentLocal, args: ['push', 'origin', 'HEAD:main'] })
+
+      fs.writeFileSync(path.join(parentLocal, 'README.md'), 'v2-local-only\n', 'utf-8')
+      await git({ cwd: parentLocal, args: ['commit', '-am', 'v2 local only'] })
+
+      const localHeadSha = await git({
+        cwd: parentLocal,
+        args: ['rev-parse', 'HEAD'],
+      })
+      const originHeadSha = await git({
+        cwd: parentLocal,
+        args: ['rev-parse', 'origin/main'],
+      })
+
+      const worktreeResult = await createWorktreeWithSubmodules({
+        directory: parentLocal,
+        name: worktreeName,
+      })
+
+      if (worktreeResult instanceof Error) {
+        throw worktreeResult
+      }
+
+      createdWorktreeDirectory = worktreeResult.directory
+      const worktreeHeadSha = await git({
+        cwd: createdWorktreeDirectory,
+        args: ['rev-parse', 'HEAD'],
+      })
+
+      expect({
+        localHeadShaLength: localHeadSha.length,
+        originHeadShaLength: originHeadSha.length,
+        worktreeHeadShaLength: worktreeHeadSha.length,
+        usesLocalOnlyHead: localHeadSha === worktreeHeadSha,
+        differsFromOrigin: localHeadSha !== originHeadSha,
+      }).toMatchInlineSnapshot(`
+        {
+          "differsFromOrigin": true,
+          "localHeadShaLength": 40,
+          "originHeadShaLength": 40,
+          "usesLocalOnlyHead": true,
+          "worktreeHeadShaLength": 40,
+        }
+      `)
+    } finally {
+      if (createdWorktreeDirectory) {
+        await git({
+          cwd: parentLocal,
+          args: ['worktree', 'remove', '--force', createdWorktreeDirectory],
+        }).catch(() => {
+          return ''
+        })
+      }
+      fs.rmSync(sandbox, { recursive: true, force: true })
+    }
+  })
+
+  test('shortenWorktreeSlug leaves short slugs alone', () => {
+    expect(shortenWorktreeSlug('short-name')).toMatchInlineSnapshot(
+      `"short-name"`,
+    )
+    expect(shortenWorktreeSlug('exactly-twenty-chars')).toMatchInlineSnapshot(
+      `"exactly-twenty-chars"`,
+    )
+  })
+
+  test('shortenWorktreeSlug strips vowels from long slugs', () => {
+    expect(
+      shortenWorktreeSlug('configurable-sidebar-width-by-component'),
+    ).toMatchInlineSnapshot(`"cnfgrbl-sdbr-wdth-by-cmpnnt"`)
+    expect(
+      shortenWorktreeSlug('add-dark-mode-toggle-to-settings-page'),
+    ).toMatchInlineSnapshot(`"add-drk-md-tggl-t-sttngs-pg"`)
+  })
+
+  test('formatWorktreeName keeps user-provided slugs verbatim', () => {
+    expect(
+      formatWorktreeName('Configurable sidebar width by component'),
+    ).toMatchInlineSnapshot(`"opencode/kimaki-configurable-sidebar-width-by-component"`)
+    expect(formatWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`)
+  })
+
+  test('formatAutoWorktreeName compresses long auto-derived slugs', () => {
+    expect(
+      formatAutoWorktreeName('Configurable sidebar width by component'),
+    ).toMatchInlineSnapshot(`"opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt"`)
+    expect(formatAutoWorktreeName('my-feature')).toMatchInlineSnapshot(`"opencode/kimaki-my-feature"`)
+  })
+
+  test('getManagedWorktreeDirectory writes under kimaki data dir and strips prefix', () => {
+    const sandbox = createTestRoot()
+    try {
+      setDataDir(sandbox)
+      const dir = getManagedWorktreeDirectory({
+        directory: '/Users/test/projects/my-app',
+        name: 'opencode/kimaki-cnfgrbl-sdbr-wdth-by-cmpnnt',
+      })
+      // Must sit inside <dataDir>/worktrees/<8hash>/<basename>
+      const rel = path.relative(sandbox, dir)
+      const parts = rel.split(path.sep)
+      expect({
+        topLevel: parts[0],
+        hashLength: parts[1]?.length,
+        basename: parts[2],
+        partsCount: parts.length,
+      }).toMatchInlineSnapshot(`
+        {
+          "basename": "cnfgrbl-sdbr-wdth-by-cmpnnt",
+          "hashLength": 8,
+          "partsCount": 3,
+          "topLevel": "worktrees",
+        }
+      `)
+    } finally {
+      fs.rmSync(sandbox, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('parseGitWorktreeListPorcelain', () => {
+  test('parses porcelain output, skips main worktree', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature',
+      'HEAD def456',
+      'branch refs/heads/opencode/kimaki-feature',
+      '',
+      'worktree /Users/me/project-manual-wt',
+      'HEAD 789abc',
+      'branch refs/heads/my-branch',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "opencode/kimaki-feature",
+          "detached": false,
+          "directory": "/Users/me/.local/share/opencode/worktree/hash/opencode-kimaki-feature",
+          "head": "def456",
+          "locked": false,
+          "prunable": false,
+        },
+        {
+          "branch": "my-branch",
+          "detached": false,
+          "directory": "/Users/me/project-manual-wt",
+          "head": "789abc",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `)
+  })
+
+  test('handles detached HEAD worktrees', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/detached-wt',
+      'HEAD deadbeef',
+      'detached',
+      '',
+    ].join('\n')
+
+    const result = parseGitWorktreeListPorcelain(output)
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": null,
+          "detached": true,
+          "directory": "/Users/me/detached-wt",
+          "head": "deadbeef",
+          "locked": false,
+          "prunable": false,
+        },
+      ]
+    `)
+  })
+
+  test('parses locked and prunable flags', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+      'worktree /Users/me/locked-wt',
+      'HEAD aaa111',
+      'branch refs/heads/feature-locked',
+      'locked portable disk',
+      '',
+      'worktree /Users/me/prunable-wt',
+      'HEAD bbb222',
+      'branch refs/heads/stale-branch',
+      'prunable gitdir file points to non-existent location',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`
+      [
+        {
+          "branch": "feature-locked",
+          "detached": false,
+          "directory": "/Users/me/locked-wt",
+          "head": "aaa111",
+          "locked": true,
+          "prunable": false,
+        },
+        {
+          "branch": "stale-branch",
+          "detached": false,
+          "directory": "/Users/me/prunable-wt",
+          "head": "bbb222",
+          "locked": false,
+          "prunable": true,
+        },
+      ]
+    `)
+  })
+
+  test('returns empty array when only main worktree exists', () => {
+    const output = [
+      'worktree /Users/me/project',
+      'HEAD abc123',
+      'branch refs/heads/main',
+      '',
+    ].join('\n')
+
+    expect(parseGitWorktreeListPorcelain(output)).toMatchInlineSnapshot(`[]`)
+  })
 })

package/src/worktrees.ts

@@ -4,9 +4,9 @@
 
 import crypto from 'node:crypto'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import * as errore from 'errore'
+import { getDataDir } from './config.js'
 import { execAsync } from './exec-async.js'
 import { createLogger, LogPrefix } from './logger.js'
 
@@ -530,24 +530,38 @@ async function resolveDefaultWorktreeTarget(
   return 'HEAD'
 }
 
-function getManagedWorktreeDirectory({
+/**
+ * Build the on-disk directory for a managed worktree.
+ *
+ * Layout: `<kimakiDataDir>/worktrees/<8charProjectHash>/<basename>`
+ *
+ * - Lives under the kimaki data dir instead of the long
+ *   `~/.local/share/opencode/worktree/<40-char-hash>/<name>` path so folder
+ *   names stay short and readable (agents tend to give up and reuse the old
+ *   worktree when paths get absurdly long).
+ * - The 8-char project hash keeps worktrees from different projects that
+ *   happen to share a slug from colliding.
+ * - Strips the `opencode/kimaki-` (or `opencode-kimaki-`) prefix from the
+ *   folder name since it's redundant noise on disk. The git branch name
+ *   itself still uses `opencode/kimaki-<slug>` so merge/cleanup logic is
+ *   unchanged.
+ */
+export function getManagedWorktreeDirectory({
   directory,
   name,
 }: {
   directory: string
   name: string
 }): string {
-  const projectHash = crypto.createHash('sha1').update(directory).digest('hex')
-  const safeName = name.replaceAll('/', '-')
-  return path.join(
-    os.homedir(),
-    '.local',
-    'share',
-    'opencode',
-    'worktree',
-    projectHash,
-    safeName,
-  )
+  const projectHash = crypto
+    .createHash('sha1')
+    .update(directory)
+    .digest('hex')
+    .slice(0, 8)
+  const withoutPrefix = name
+    .replace(/^opencode\/kimaki-/, '')
+    .replaceAll('/', '-')
+  return path.join(getDataDir(), 'worktrees', projectHash, withoutPrefix)
 }
 
 /**
@@ -724,6 +738,8 @@ export async function deleteWorktree({
 }: {
   projectDirectory: string
   worktreeDirectory: string
+  // Branch name to delete after removing the worktree.
+  // Pass empty string for detached HEAD worktrees — branch deletion is skipped.
   worktreeName: string
 }): Promise<void | Error> {
   let removeResult = await git(
@@ -749,24 +765,27 @@ export async function deleteWorktree({
     }
   }
   if (removeResult instanceof Error) {
-    return new Error(`Failed to remove worktree ${worktreeName}`, {
+    return new Error(`Failed to remove worktree ${worktreeName || worktreeDirectory}`, {
       cause: removeResult,
     })
   }
 
-  const deleteBranchResult = await git(
-    projectDirectory,
-    `branch -d ${JSON.stringify(worktreeName)}`,
-  )
-  if (deleteBranchResult instanceof Error) {
-    return new Error(`Failed to delete branch ${worktreeName}`, {
-      cause: deleteBranchResult,
-    })
+  // Skip branch deletion for detached HEAD worktrees (no branch to delete)
+  if (worktreeName) {
+    const deleteBranchResult = await git(
+      projectDirectory,
+      `branch -d ${JSON.stringify(worktreeName)}`,
+    )
+    if (deleteBranchResult instanceof Error) {
+      return new Error(`Failed to delete branch ${worktreeName}`, {
+        cause: deleteBranchResult,
+      })
+    }
   }
 
   const pruneResult = await git(projectDirectory, 'worktree prune')
   if (pruneResult instanceof Error) {
-    logger.warn(`Failed to prune worktrees after deleting ${worktreeName}`)
+    logger.warn(`Failed to prune worktrees after deleting ${worktreeName || worktreeDirectory}`)
   }
 }
 
@@ -1246,3 +1265,105 @@ export async function validateWorktreeDirectory({
 
   return absoluteCandidate
 }
+
+// Parsed entry from `git worktree list --porcelain`.
+// Represents any worktree (kimaki, opencode, manual) visible to git.
+export type GitWorktree = {
+  directory: string
+  branch: string | null // null for detached HEAD
+  head: string
+  detached: boolean
+  locked: boolean
+  prunable: boolean
+}
+
+type PartialGitWorktree = {
+  directory?: string
+  branch?: string | null
+  head?: string
+  detached?: boolean
+  locked?: boolean
+  prunable?: boolean
+}
+
+function flushGitWorktreeEntry(current: PartialGitWorktree): GitWorktree | null {
+  if (!current.directory) {
+    return null
+  }
+  return {
+    directory: current.directory,
+    branch: current.branch ?? null,
+    head: current.head ?? '',
+    detached: current.detached ?? false,
+    locked: current.locked ?? false,
+    prunable: current.prunable ?? false,
+  }
+}
+
+// Parse `git worktree list --porcelain` output into structured entries.
+// Skips the first entry (the main checkout) since that's the project root.
+export function parseGitWorktreeListPorcelain(
+  output: string,
+): GitWorktree[] {
+  const entries: GitWorktree[] = []
+  let current: PartialGitWorktree = {}
+
+  for (const line of output.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      const flushed = flushGitWorktreeEntry(current)
+      if (flushed) {
+        entries.push(flushed)
+      }
+      current = { directory: line.slice('worktree '.length) }
+      continue
+    }
+    if (line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length)
+      continue
+    }
+    if (line.startsWith('branch ')) {
+      // "branch refs/heads/opencode/kimaki-foo" → "opencode/kimaki-foo"
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
+      continue
+    }
+    if (line === 'detached') {
+      current.detached = true
+      continue
+    }
+    // "locked" or "locked <reason>"
+    if (line === 'locked' || line.startsWith('locked ')) {
+      current.locked = true
+      continue
+    }
+    if (line.startsWith('prunable')) {
+      current.prunable = true
+      continue
+    }
+  }
+  // Flush last entry
+  const flushed = flushGitWorktreeEntry(current)
+  if (flushed) {
+    entries.push(flushed)
+  }
+
+  // Skip the first entry — it's the main checkout (project root)
+  return entries.slice(1)
+}
+
+// List all git worktrees for a project directory (excluding the main checkout).
+// Returns Error on git failure, empty array if no worktrees exist.
+export async function listGitWorktrees({
+  projectDirectory,
+  timeout,
+}: {
+  projectDirectory: string
+  timeout?: number
+}): Promise<GitWorktree[] | Error> {
+  const result = await git(projectDirectory, 'worktree list --porcelain', {
+    timeout,
+  })
+  if (result instanceof Error) {
+    return result
+  }
+  return parseGitWorktreeListPorcelain(result)
+}