@xortex/xcode 3.0.0

package/utils/desktopDeepLink.ts

@@ -0,0 +1,236 @@
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import { coerce as semverCoerce } from 'semver'
+import { getSessionId } from '../bootstrap/state.js'
+import { getCwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+import { execFileNoThrow } from './execFileNoThrow.js'
+import { pathExists } from './file.js'
+import { gte as semverGte } from './semver.js'
+
+const MIN_DESKTOP_VERSION = '1.1.2396'
+
+function isDevMode(): boolean {
+  if ((process.env.NODE_ENV as string) === 'development') {
+    return true
+  }
+
+  // Local builds from build directories are dev mode even with NODE_ENV=production
+  const pathsToCheck = [process.argv[1] || '', process.execPath || '']
+  const buildDirs = [
+    '/build-ant/',
+    '/build-ant-native/',
+    '/build-external/',
+    '/build-external-native/',
+  ]
+
+  return pathsToCheck.some(p => buildDirs.some(dir => p.includes(dir)))
+}
+
+/**
+ * Builds a deep link URL for Claude Desktop to resume a CLI session.
+ * Format: claude://resume?session={sessionId}&cwd={cwd}
+ * In dev mode: claude-dev://resume?session={sessionId}&cwd={cwd}
+ */
+function buildDesktopDeepLink(sessionId: string): string {
+  const protocol = isDevMode() ? 'claude-dev' : 'claude'
+  const url = new URL(`${protocol}://resume`)
+  url.searchParams.set('session', sessionId)
+  url.searchParams.set('cwd', getCwd())
+  return url.toString()
+}
+
+/**
+ * Check if Claude Desktop app is installed.
+ * On macOS, checks for /Applications/Claude.app.
+ * On Linux, checks if xdg-open can handle claude:// protocol.
+ * On Windows, checks if the protocol handler exists.
+ * In dev mode, always returns true (assumes dev Desktop is running).
+ */
+async function isDesktopInstalled(): Promise<boolean> {
+  // In dev mode, assume the dev Desktop app is running
+  if (isDevMode()) {
+    return true
+  }
+
+  const platform = process.platform
+
+  if (platform === 'darwin') {
+    // Check for Claude.app in /Applications
+    return pathExists('/Applications/Claude.app')
+  } else if (platform === 'linux') {
+    // Check if xdg-mime can find a handler for claude://
+    // Note: xdg-mime returns exit code 0 even with no handler, so check stdout too
+    const { code, stdout } = await execFileNoThrow('xdg-mime', [
+      'query',
+      'default',
+      'x-scheme-handler/claude',
+    ])
+    return code === 0 && stdout.trim().length > 0
+  } else if (platform === 'win32') {
+    // On Windows, try to query the registry for the protocol handler
+    const { code } = await execFileNoThrow('reg', [
+      'query',
+      'HKEY_CLASSES_ROOT\\claude',
+      '/ve',
+    ])
+    return code === 0
+  }
+
+  return false
+}
+
+/**
+ * Detect the installed Claude Desktop version.
+ * On macOS, reads CFBundleShortVersionString from the app plist.
+ * On Windows, finds the highest app-X.Y.Z directory in the Squirrel install.
+ * Returns null if version cannot be determined.
+ */
+async function getDesktopVersion(): Promise<string | null> {
+  const platform = process.platform
+
+  if (platform === 'darwin') {
+    const { code, stdout } = await execFileNoThrow('defaults', [
+      'read',
+      '/Applications/Claude.app/Contents/Info.plist',
+      'CFBundleShortVersionString',
+    ])
+    if (code !== 0) {
+      return null
+    }
+    const version = stdout.trim()
+    return version.length > 0 ? version : null
+  } else if (platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA
+    if (!localAppData) {
+      return null
+    }
+    const installDir = join(localAppData, 'AnthropicClaude')
+    try {
+      const entries = await readdir(installDir)
+      const versions = entries
+        .filter(e => e.startsWith('app-'))
+        .map(e => e.slice(4))
+        .filter(v => semverCoerce(v) !== null)
+        .sort((a, b) => {
+          const ca = semverCoerce(a)!
+          const cb = semverCoerce(b)!
+          return ca.compare(cb)
+        })
+      return versions.length > 0 ? versions[versions.length - 1]! : null
+    } catch {
+      return null
+    }
+  }
+
+  return null
+}
+
+export type DesktopInstallStatus =
+  | { status: 'not-installed' }
+  | { status: 'version-too-old'; version: string }
+  | { status: 'ready'; version: string }
+
+/**
+ * Check Desktop install status including version compatibility.
+ */
+export async function getDesktopInstallStatus(): Promise<DesktopInstallStatus> {
+  const installed = await isDesktopInstalled()
+  if (!installed) {
+    return { status: 'not-installed' }
+  }
+
+  let version: string | null
+  try {
+    version = await getDesktopVersion()
+  } catch {
+    // Best effort — proceed with handoff if version detection fails
+    return { status: 'ready', version: 'unknown' }
+  }
+
+  if (!version) {
+    // Can't determine version — assume it's ready (dev mode or unknown install)
+    return { status: 'ready', version: 'unknown' }
+  }
+
+  const coerced = semverCoerce(version)
+  if (!coerced || !semverGte(coerced.version, MIN_DESKTOP_VERSION)) {
+    return { status: 'version-too-old', version }
+  }
+
+  return { status: 'ready', version }
+}
+
+/**
+ * Opens a deep link URL using the platform-specific mechanism.
+ * Returns true if the command succeeded, false otherwise.
+ */
+async function openDeepLink(deepLinkUrl: string): Promise<boolean> {
+  const platform = process.platform
+  logForDebugging(`Opening deep link: ${deepLinkUrl}`)
+
+  if (platform === 'darwin') {
+    if (isDevMode()) {
+      // In dev mode, `open` launches a bare Electron binary (without app code)
+      // because setAsDefaultProtocolClient registers just the Electron executable.
+      // Use AppleScript to route the URL to the already-running Electron app.
+      const { code } = await execFileNoThrow('osascript', [
+        '-e',
+        `tell application "Electron" to open location "${deepLinkUrl}"`,
+      ])
+      return code === 0
+    }
+    const { code } = await execFileNoThrow('open', [deepLinkUrl])
+    return code === 0
+  } else if (platform === 'linux') {
+    const { code } = await execFileNoThrow('xdg-open', [deepLinkUrl])
+    return code === 0
+  } else if (platform === 'win32') {
+    // On Windows, use cmd /c start to open URLs
+    const { code } = await execFileNoThrow('cmd', [
+      '/c',
+      'start',
+      '',
+      deepLinkUrl,
+    ])
+    return code === 0
+  }
+
+  return false
+}
+
+/**
+ * Build and open a deep link to resume the current session in Claude Desktop.
+ * Returns an object with success status and any error message.
+ */
+export async function openCurrentSessionInDesktop(): Promise<{
+  success: boolean
+  error?: string
+  deepLinkUrl?: string
+}> {
+  const sessionId = getSessionId()
+
+  // Check if Desktop is installed
+  const installed = await isDesktopInstalled()
+  if (!installed) {
+    return {
+      success: false,
+      error:
+        'Claude Desktop is not installed. Install it from https://claude.ai/download',
+    }
+  }
+
+  // Build and open the deep link
+  const deepLinkUrl = buildDesktopDeepLink(sessionId)
+  const opened = await openDeepLink(deepLinkUrl)
+
+  if (!opened) {
+    return {
+      success: false,
+      error: 'Failed to open Claude Desktop. Please try opening it manually.',
+      deepLinkUrl,
+    }
+  }
+
+  return { success: true, deepLinkUrl }
+}

package/utils/detectRepository.ts

@@ -0,0 +1,178 @@
+import { getCwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+import { getRemoteUrl } from './git.js'
+
+export type ParsedRepository = {
+  host: string
+  owner: string
+  name: string
+}
+
+const repositoryWithHostCache = new Map<string, ParsedRepository | null>()
+
+export function clearRepositoryCaches(): void {
+  repositoryWithHostCache.clear()
+}
+
+export async function detectCurrentRepository(): Promise<string | null> {
+  const result = await detectCurrentRepositoryWithHost()
+  if (!result) return null
+  // Only return results for github.com to avoid breaking downstream consumers
+  // that assume the result is a github.com repository.
+  // Use detectCurrentRepositoryWithHost() for GHE support.
+  if (result.host !== 'github.com') return null
+  return `${result.owner}/${result.name}`
+}
+
+/**
+ * Like detectCurrentRepository, but also returns the host (e.g. "github.com"
+ * or a GHE hostname). Callers that need to construct URLs against a specific
+ * GitHub host should use this variant.
+ */
+export async function detectCurrentRepositoryWithHost(): Promise<ParsedRepository | null> {
+  const cwd = getCwd()
+
+  if (repositoryWithHostCache.has(cwd)) {
+    return repositoryWithHostCache.get(cwd) ?? null
+  }
+
+  try {
+    const remoteUrl = await getRemoteUrl()
+    logForDebugging(`Git remote URL: ${remoteUrl}`)
+    if (!remoteUrl) {
+      logForDebugging('No git remote URL found')
+      repositoryWithHostCache.set(cwd, null)
+      return null
+    }
+
+    const parsed = parseGitRemote(remoteUrl)
+    logForDebugging(
+      `Parsed repository: ${parsed ? `${parsed.host}/${parsed.owner}/${parsed.name}` : null} from URL: ${remoteUrl}`,
+    )
+    repositoryWithHostCache.set(cwd, parsed)
+    return parsed
+  } catch (error) {
+    logForDebugging(`Error detecting repository: ${error}`)
+    repositoryWithHostCache.set(cwd, null)
+    return null
+  }
+}
+
+/**
+ * Synchronously returns the cached github.com repository for the current cwd
+ * as "owner/name", or null if it hasn't been resolved yet or the host is not
+ * github.com. Call detectCurrentRepository() first to populate the cache.
+ *
+ * Callers construct github.com URLs, so GHE hosts are filtered out here.
+ */
+export function getCachedRepository(): string | null {
+  const parsed = repositoryWithHostCache.get(getCwd())
+  if (!parsed || parsed.host !== 'github.com') return null
+  return `${parsed.owner}/${parsed.name}`
+}
+
+/**
+ * Parses a git remote URL into host, owner, and name components.
+ * Accepts any host (github.com, GHE instances, etc.).
+ *
+ * Supports:
+ *   https://host/owner/repo.git
+ *   git@host:owner/repo.git
+ *   ssh://git@host/owner/repo.git
+ *   git://host/owner/repo.git
+ *   https://host/owner/repo (no .git)
+ *
+ * Note: repo names can contain dots (e.g., cc.kurs.web)
+ */
+export function parseGitRemote(input: string): ParsedRepository | null {
+  const trimmed = input.trim()
+
+  // SSH format: git@host:owner/repo.git
+  const sshMatch = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/)
+  if (sshMatch?.[1] && sshMatch[2] && sshMatch[3]) {
+    if (!looksLikeRealHostname(sshMatch[1])) return null
+    return {
+      host: sshMatch[1],
+      owner: sshMatch[2],
+      name: sshMatch[3],
+    }
+  }
+
+  // URL format: https://host/owner/repo.git, ssh://git@host/owner/repo, git://host/owner/repo
+  const urlMatch = trimmed.match(
+    /^(https?|ssh|git):\/\/(?:[^@]+@)?([^/:]+(?::\d+)?)\/([^/]+)\/([^/]+?)(?:\.git)?$/,
+  )
+  if (urlMatch?.[1] && urlMatch[2] && urlMatch[3] && urlMatch[4]) {
+    const protocol = urlMatch[1]
+    const hostWithPort = urlMatch[2]
+    const hostWithoutPort = hostWithPort.split(':')[0] ?? ''
+    if (!looksLikeRealHostname(hostWithoutPort)) return null
+    // Only preserve port for HTTPS — SSH/git ports are not usable for constructing
+    // web URLs (e.g. ssh://git@ghe.corp.com:2222 → port 2222 is SSH, not HTTPS).
+    const host =
+      protocol === 'https' || protocol === 'http'
+        ? hostWithPort
+        : hostWithoutPort
+    return {
+      host,
+      owner: urlMatch[3],
+      name: urlMatch[4],
+    }
+  }
+
+  return null
+}
+
+/**
+ * Parses a git remote URL or "owner/repo" string and returns "owner/repo".
+ * Only returns results for github.com hosts — GHE URLs return null.
+ * Use parseGitRemote() for GHE support.
+ * Also accepts plain "owner/repo" strings for backward compatibility.
+ */
+export function parseGitHubRepository(input: string): string | null {
+  const trimmed = input.trim()
+
+  // Try parsing as a full remote URL first.
+  // Only return results for github.com hosts — existing callers (VS Code extension,
+  // bridge) assume this function is GitHub.com-specific. Use parseGitRemote() directly
+  // for GHE support.
+  const parsed = parseGitRemote(trimmed)
+  if (parsed) {
+    if (parsed.host !== 'github.com') return null
+    return `${parsed.owner}/${parsed.name}`
+  }
+
+  // If no URL pattern matched, check if it's already in owner/repo format
+  if (
+    !trimmed.includes('://') &&
+    !trimmed.includes('@') &&
+    trimmed.includes('/')
+  ) {
+    const parts = trimmed.split('/')
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      // Remove .git extension if present
+      const repo = parts[1].replace(/\.git$/, '')
+      return `${parts[0]}/${repo}`
+    }
+  }
+
+  logForDebugging(`Could not parse repository from: ${trimmed}`)
+  return null
+}
+
+/**
+ * Checks whether a hostname looks like a real domain name rather than an
+ * SSH config alias. A simple dot-check is not enough because aliases like
+ * "github.com-work" still contain a dot. We additionally require that the
+ * last segment (the TLD) is purely alphabetic — real TLDs (com, org, io, net)
+ * never contain hyphens or digits.
+ */
+function looksLikeRealHostname(host: string): boolean {
+  if (!host.includes('.')) return false
+  const lastSegment = host.split('.').pop()
+  if (!lastSegment) return false
+  // Real TLDs are purely alphabetic (e.g., "com", "org", "io").
+  // SSH aliases like "github.com-work" have a last segment "com-work" which
+  // contains a hyphen.
+  return /^[a-zA-Z]+$/.test(lastSegment)
+}

package/utils/diagLogs.ts

@@ -0,0 +1,94 @@
+import { dirname } from 'path'
+import { getFsImplementation } from './fsOperations.js'
+import { jsonStringify } from './slowOperations.js'
+
+type DiagnosticLogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+type DiagnosticLogEntry = {
+  timestamp: string
+  level: DiagnosticLogLevel
+  event: string
+  data: Record<string, unknown>
+}
+
+/**
+ * Logs diagnostic information to a logfile. This information is sent
+ * via the environment manager to session-ingress to monitor issues from
+ * within the container.
+ *
+ * *Important* - this function MUST NOT be called with any PII, including
+ * file paths, project names, repo names, prompts, etc.
+ *
+ * @param level    Log level. Only used for information, not filtering
+ * @param event    A specific event: "started", "mcp_connected", etc.
+ * @param data     Optional additional data to log
+ */
+// sync IO: called from sync context
+export function logForDiagnosticsNoPII(
+  level: DiagnosticLogLevel,
+  event: string,
+  data?: Record<string, unknown>,
+): void {
+  const logFile = getDiagnosticLogFile()
+  if (!logFile) {
+    return
+  }
+
+  const entry: DiagnosticLogEntry = {
+    timestamp: new Date().toISOString(),
+    level,
+    event,
+    data: data ?? {},
+  }
+
+  const fs = getFsImplementation()
+  const line = jsonStringify(entry) + '\n'
+  try {
+    fs.appendFileSync(logFile, line)
+  } catch {
+    // If append fails, try creating the directory first
+    try {
+      fs.mkdirSync(dirname(logFile))
+      fs.appendFileSync(logFile, line)
+    } catch {
+      // Silently fail if logging is not possible
+    }
+  }
+}
+
+function getDiagnosticLogFile(): string | undefined {
+  return process.env.CLAUDE_CODE_DIAGNOSTICS_FILE
+}
+
+/**
+ * Wraps an async function with diagnostic timing logs.
+ * Logs `{event}_started` before execution and `{event}_completed` after with duration_ms.
+ *
+ * @param event   Event name prefix (e.g., "git_status" -> logs "git_status_started" and "git_status_completed")
+ * @param fn      Async function to execute and time
+ * @param getData Optional function to extract additional data from the result for the completion log
+ * @returns       The result of the wrapped function
+ */
+export async function withDiagnosticsTiming<T>(
+  event: string,
+  fn: () => Promise<T>,
+  getData?: (result: T) => Record<string, unknown>,
+): Promise<T> {
+  const startTime = Date.now()
+  logForDiagnosticsNoPII('info', `${event}_started`)
+
+  try {
+    const result = await fn()
+    const additionalData = getData ? getData(result) : {}
+    logForDiagnosticsNoPII('info', `${event}_completed`, {
+      duration_ms: Date.now() - startTime,
+      ...additionalData,
+    })
+    return result
+  } catch (error) {
+    logForDiagnosticsNoPII('error', `${event}_failed`, {
+      duration_ms: Date.now() - startTime,
+    })
+    throw error
+  }
+}

package/utils/diff.ts

@@ -0,0 +1,177 @@
+import { type StructuredPatchHunk, structuredPatch } from 'diff'
+import { logEvent } from 'src/services/analytics/index.js'
+import { getLocCounter } from '../bootstrap/state.js'
+import { addToTotalLinesChanged } from '../cost-tracker.js'
+import type { FileEdit } from '../tools/FileEditTool/types.js'
+import { count } from './array.js'
+import { convertLeadingTabsToSpaces } from './file.js'
+
+export const CONTEXT_LINES = 3
+export const DIFF_TIMEOUT_MS = 5_000
+
+/**
+ * Shifts hunk line numbers by offset. Use when getPatchForDisplay received
+ * a slice of the file (e.g. readEditContext) rather than the whole file —
+ * callers pass `ctx.lineOffset - 1` to convert slice-relative to file-relative.
+ */
+export function adjustHunkLineNumbers(
+  hunks: StructuredPatchHunk[],
+  offset: number,
+): StructuredPatchHunk[] {
+  if (offset === 0) return hunks
+  return hunks.map(h => ({
+    ...h,
+    oldStart: h.oldStart + offset,
+    newStart: h.newStart + offset,
+  }))
+}
+
+// For some reason, & confuses the diff library, so we replace it with a token,
+// then substitute it back in after the diff is computed.
+const AMPERSAND_TOKEN = '<<:AMPERSAND_TOKEN:>>'
+
+const DOLLAR_TOKEN = '<<:DOLLAR_TOKEN:>>'
+
+function escapeForDiff(s: string): string {
+  return s.replaceAll('&', AMPERSAND_TOKEN).replaceAll('$', DOLLAR_TOKEN)
+}
+
+function unescapeFromDiff(s: string): string {
+  return s.replaceAll(AMPERSAND_TOKEN, '&').replaceAll(DOLLAR_TOKEN, '$')
+}
+
+/**
+ * Count lines added and removed in a patch and update the total
+ * For new files, pass the content string as the second parameter
+ * @param patch Array of diff hunks
+ * @param newFileContent Optional content string for new files
+ */
+export function countLinesChanged(
+  patch: StructuredPatchHunk[],
+  newFileContent?: string,
+): void {
+  let numAdditions = 0
+  let numRemovals = 0
+
+  if (patch.length === 0 && newFileContent) {
+    // For new files, count all lines as additions
+    numAdditions = newFileContent.split(/\r?\n/).length
+  } else {
+    numAdditions = patch.reduce(
+      (acc, hunk) => acc + count(hunk.lines, _ => _.startsWith('+')),
+      0,
+    )
+    numRemovals = patch.reduce(
+      (acc, hunk) => acc + count(hunk.lines, _ => _.startsWith('-')),
+      0,
+    )
+  }
+
+  addToTotalLinesChanged(numAdditions, numRemovals)
+
+  getLocCounter()?.add(numAdditions, { type: 'added' })
+  getLocCounter()?.add(numRemovals, { type: 'removed' })
+
+  logEvent('tengu_file_changed', {
+    lines_added: numAdditions,
+    lines_removed: numRemovals,
+  })
+}
+
+export function getPatchFromContents({
+  filePath,
+  oldContent,
+  newContent,
+  ignoreWhitespace = false,
+  singleHunk = false,
+}: {
+  filePath: string
+  oldContent: string
+  newContent: string
+  ignoreWhitespace?: boolean
+  singleHunk?: boolean
+}): StructuredPatchHunk[] {
+  const result = structuredPatch(
+    filePath,
+    filePath,
+    escapeForDiff(oldContent),
+    escapeForDiff(newContent),
+    undefined,
+    undefined,
+    {
+      ignoreWhitespace,
+      context: singleHunk ? 100_000 : CONTEXT_LINES,
+      timeout: DIFF_TIMEOUT_MS,
+    },
+  )
+  if (!result) {
+    return []
+  }
+  return result.hunks.map(_ => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff),
+  }))
+}
+
+/**
+ * Get a patch for display with edits applied
+ * @param filePath The path to the file
+ * @param fileContents The contents of the file
+ * @param edits An array of edits to apply to the file
+ * @param ignoreWhitespace Whether to ignore whitespace changes
+ * @returns An array of hunks representing the diff
+ *
+ * NOTE: This function will return the diff with all leading tabs
+ * rendered as spaces for display
+ */
+
+export function getPatchForDisplay({
+  filePath,
+  fileContents,
+  edits,
+  ignoreWhitespace = false,
+}: {
+  filePath: string
+  fileContents: string
+  edits: FileEdit[]
+  ignoreWhitespace?: boolean
+}): StructuredPatchHunk[] {
+  const preparedFileContents = escapeForDiff(
+    convertLeadingTabsToSpaces(fileContents),
+  )
+  const result = structuredPatch(
+    filePath,
+    filePath,
+    preparedFileContents,
+    edits.reduce((p, edit) => {
+      const { old_string, new_string } = edit
+      const replace_all = 'replace_all' in edit ? edit.replace_all : false
+      const escapedOldString = escapeForDiff(
+        convertLeadingTabsToSpaces(old_string),
+      )
+      const escapedNewString = escapeForDiff(
+        convertLeadingTabsToSpaces(new_string),
+      )
+
+      if (replace_all) {
+        return p.replaceAll(escapedOldString, () => escapedNewString)
+      } else {
+        return p.replace(escapedOldString, () => escapedNewString)
+      }
+    }, preparedFileContents),
+    undefined,
+    undefined,
+    {
+      context: CONTEXT_LINES,
+      ignoreWhitespace,
+      timeout: DIFF_TIMEOUT_MS,
+    },
+  )
+  if (!result) {
+    return []
+  }
+  return result.hunks.map(_ => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff),
+  }))
+}