@doriandev/devcc 0.1.2 → 0.3.0

package/src/devcc/environment/integrations.ts

@@ -0,0 +1,133 @@
+import { dirname } from "node:path"
+import { firstLine } from "./tools.js"
+
+/**
+ * Pure parsers for mise and direnv. Both tools offer machine-readable output,
+ * so nothing here scrapes their human-oriented formatting.
+ */
+
+// ---------------------------------------------------------------------------
+// mise
+// ---------------------------------------------------------------------------
+
+export interface RuntimeVersion {
+  tool: string
+  version: string
+  /** What the config asked for, e.g. `22` or `lts`. */
+  requested?: string
+  /** Config file that pinned it. */
+  source?: string
+  installed: boolean
+  active: boolean
+}
+
+export interface MiseStatus {
+  installed: boolean
+  runtimes: RuntimeVersion[]
+  /** Set when mise is installed but could not report (e.g. untrusted config). */
+  error?: string
+}
+
+/** `mise ls --current --json`: an object keyed by tool name, each an array of version records. */
+export const MISE_ARGS = ["ls", "--current", "--json"] as const
+
+export function parseMiseLs(output: string): RuntimeVersion[] {
+  let data: unknown
+  try {
+    data = JSON.parse(output)
+  } catch {
+    return []
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
+
+  const runtimes: RuntimeVersion[] = []
+  for (const [tool, records] of Object.entries(data as Record<string, unknown>)) {
+    if (!Array.isArray(records)) continue
+    for (const record of records) {
+      if (typeof record !== "object" || record === null) continue
+      const entry = record as Record<string, unknown>
+      const version = typeof entry.version === "string" ? entry.version : undefined
+      if (!version) continue
+      const source = entry.source as Record<string, unknown> | undefined
+      runtimes.push({
+        tool,
+        version,
+        requested: typeof entry.requested_version === "string" ? entry.requested_version : undefined,
+        source: typeof source?.path === "string" ? source.path : undefined,
+        installed: entry.installed !== false,
+        active: entry.active === true,
+      })
+    }
+  }
+  return runtimes.sort((a, b) => a.tool.localeCompare(b.tool))
+}
+
+/** Turn a failed `mise ls` into a short, actionable message. */
+export function miseErrorMessage(stderr: string): string {
+  if (/not trusted/iu.test(stderr)) return "config is not trusted - run `mise trust` if you expect it"
+  return firstLine(stderr.replace(/^mise\s+(ERROR|WARN)\s*/imu, "")) ?? "mise ls failed"
+}
+
+// ---------------------------------------------------------------------------
+// direnv
+// ---------------------------------------------------------------------------
+
+export type DirenvApproval = "allowed" | "not-allowed" | "denied" | "unknown"
+
+export interface DirenvStatus {
+  installed: boolean
+  /** The `.envrc` direnv would load for this project, if any. */
+  rcPath?: string
+  approval: DirenvApproval
+  /**
+   * Whether devcc's own environment has this `.envrc` loaded (it was started
+   * from a direnv-enabled shell in the project). Null when there is nothing to load.
+   */
+  loaded: boolean | null
+  error?: string
+}
+
+/** direnv's numeric allow states (`internal/cmd/rc.go`). */
+const APPROVAL_CODES: Record<number, DirenvApproval> = { 0: "allowed", 1: "not-allowed", 2: "denied" }
+
+function approvalFrom(value: unknown): DirenvApproval {
+  if (typeof value === "number") return APPROVAL_CODES[value] ?? "unknown"
+  if (typeof value === "boolean") return value ? "allowed" : "not-allowed"
+  if (typeof value === "string") {
+    const numeric = Number(value)
+    if (value.trim() !== "" && Number.isInteger(numeric)) return APPROVAL_CODES[numeric] ?? "unknown"
+    if (value === "true") return "allowed"
+    if (value === "false") return "not-allowed"
+  }
+  return "unknown"
+}
+
+/**
+ * Parse `direnv status --json`, falling back to the plain `direnv status`
+ * text for versions without JSON support.
+ */
+export function parseDirenvStatus(output: string): { rcPath?: string; approval: DirenvApproval } {
+  try {
+    const data = JSON.parse(output) as { state?: { foundRC?: { path?: unknown; allowed?: unknown } | null } }
+    const found = data.state?.foundRC
+    if (!found || typeof found.path !== "string") return { approval: "unknown" }
+    return { rcPath: found.path, approval: approvalFrom(found.allowed) }
+  } catch {
+    // Not JSON: older direnv. Fall through to the text format.
+  }
+
+  const path = /^Found RC path (.+)$/mu.exec(output)?.[1]?.trim()
+  if (!path) return { approval: "unknown" }
+  const allowed = /^Found RC allowed (.+)$/mu.exec(output)?.[1]?.trim()
+  return { rcPath: path, approval: allowed === undefined ? "unknown" : approvalFrom(allowed) }
+}
+
+/**
+ * direnv exports `DIRENV_DIR=-<dir>` into shells where it loaded an `.envrc`.
+ * If devcc inherited that for this `.envrc`'s directory, the environment is loaded.
+ */
+export function isDirenvLoaded(rcPath: string, env: NodeJS.ProcessEnv = process.env): boolean {
+  const dir = env.DIRENV_DIR
+  if (!dir) return false
+  return dir.replace(/^-/u, "") === dirname(rcPath)
+}

package/src/devcc/environment/tools.ts

@@ -0,0 +1,151 @@
+import { accessSync, constants } from "node:fs"
+import { delimiter, isAbsolute, join } from "node:path"
+import { exec, type ExecOptions, type ExecResult } from "../utils/exec.js"
+
+/**
+ * Tool detection for the Environment panel and `devcc env`.
+ *
+ * Observation only: devcc reports what is installed and whether it answers, it
+ * never installs or upgrades anything. A missing tool is a normal state, not
+ * an error.
+ */
+
+export type ToolHealth = "ready" | "warning" | "error"
+
+export interface ToolStatus {
+  id: string
+  name: string
+  installed: boolean
+  version?: string
+  /** Resolved executable path. */
+  path?: string
+  /** Absent when the tool is not installed. */
+  status?: ToolHealth
+  message?: string
+}
+
+export interface ToolDefinition {
+  id: string
+  name: string
+  command: string
+  /** Arguments that print a version (default `--version`). */
+  versionArgs?: string[]
+  /** Capture group 1 is the version; defaults to the first dotted number. */
+  versionPattern?: RegExp
+  /** Absolute paths to try when the command is not on PATH (e.g. app bundles). */
+  fallbackPaths?: string[]
+}
+
+export const DEFAULT_TOOLS: readonly ToolDefinition[] = [
+  { id: "node", name: "Node", command: "node" },
+  { id: "pnpm", name: "pnpm", command: "pnpm" },
+  { id: "npm", name: "npm", command: "npm" },
+  { id: "bun", name: "Bun", command: "bun" },
+  { id: "git", name: "Git", command: "git" },
+  { id: "mise", name: "mise", command: "mise" },
+  { id: "direnv", name: "direnv", command: "direnv", versionArgs: ["version"] },
+  { id: "docker", name: "Docker", command: "docker" },
+  { id: "cargo", name: "Rust/Cargo", command: "cargo" },
+  { id: "claude", name: "Claude Code", command: "claude" },
+  { id: "codex", name: "Codex", command: "codex" },
+  {
+    id: "tailscale",
+    name: "Tailscale",
+    command: "tailscale",
+    versionArgs: ["version"],
+    fallbackPaths: ["/Applications/Tailscale.app/Contents/MacOS/Tailscale"],
+  },
+  { id: "ollama", name: "Ollama", command: "ollama" },
+]
+
+export const TOOL_TIMEOUT_MS = 3_000
+
+/** First `x.y[.z…]` version in the output, or the pattern's first group. */
+export function parseVersion(output: string, pattern?: RegExp): string | undefined {
+  const text = output.trim()
+  if (text === "") return undefined
+  if (pattern) {
+    const match = pattern.exec(text)
+    if (match?.[1]) return match[1]
+  }
+  return /\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?/u.exec(text)?.[0]
+}
+
+export type Which = (command: string) => string | undefined
+
+/** Look a command up on PATH the way a shell would, without running a shell. */
+export function findExecutable(
+  command: string,
+  pathEnv: string = process.env.PATH ?? "",
+  isExecutable: (path: string) => boolean = canExecute,
+): string | undefined {
+  if (command.includes("/")) return isAbsolute(command) && isExecutable(command) ? command : undefined
+  for (const dir of pathEnv.split(delimiter)) {
+    if (dir === "") continue
+    const candidate = join(dir, command)
+    if (isExecutable(candidate)) return candidate
+  }
+  return undefined
+}
+
+function canExecute(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export type Exec = (command: string, args: readonly string[], options?: ExecOptions) => Promise<ExecResult>
+
+export interface DetectToolDeps {
+  run?: Exec
+  which?: Which
+  timeoutMs?: number
+}
+
+/**
+ * Detect one tool: resolve it on PATH, then ask for its version with a hard
+ * timeout. Never throws - every failure becomes diagnostic state.
+ */
+export async function detectTool(definition: ToolDefinition, deps: DetectToolDeps = {}): Promise<ToolStatus> {
+  const which = deps.which ?? ((command: string) => findExecutable(command))
+  const run = deps.run ?? exec
+  const timeoutMs = deps.timeoutMs ?? TOOL_TIMEOUT_MS
+  const base = { id: definition.id, name: definition.name }
+
+  const path =
+    which(definition.command) ?? definition.fallbackPaths?.find((candidate) => which(candidate) !== undefined)
+  if (!path) return { ...base, installed: false, message: "not installed" }
+
+  let result: ExecResult
+  try {
+    result = await run(path, definition.versionArgs ?? ["--version"], { timeoutMs })
+  } catch (error) {
+    return { ...base, installed: true, path, status: "error", message: String(error) }
+  }
+
+  if (result.timedOut) {
+    return { ...base, installed: true, path, status: "warning", message: `no answer within ${timeoutMs}ms` }
+  }
+  if (result.spawnError) {
+    return { ...base, installed: true, path, status: "error", message: result.spawnError.message }
+  }
+  if (!result.ok) {
+    const reason =
+      firstLine(result.stderr) ?? firstLine(result.stdout) ?? `exited with code ${result.code ?? "?"}`
+    return { ...base, installed: true, path, status: "error", message: reason }
+  }
+
+  const version = parseVersion(result.stdout || result.stderr, definition.versionPattern)
+  return { ...base, installed: true, path, version, status: "ready" }
+}
+
+export function firstLine(text: string): string | undefined {
+  const line = text
+    .split("\n")
+    .map((entry) => entry.trim())
+    .find((entry) => entry !== "")
+  return line
+}

package/src/devcc/git/GitService.ts

@@ -1,5 +1,7 @@
 import { TypedEmitter } from "../core/events.js"
 import { DevccError } from "../utils/errors.js"
+import { existsSync, realpathSync } from "node:fs"
+import { resolve } from "node:path"
 import { exec, type ExecResult } from "../utils/exec.js"
 import type { ScopedLogger } from "../utils/logger.js"
 import {
@@ -10,12 +12,24 @@ import {
   type GitCommit,
   type GitStatus,
 } from "./parse.js"
+import {
+  parseWorktreeList,
+  removalBlocker,
+  validateBranchName,
+  validateRef,
+  validateWorktreePath,
+  worktreeAddArgs,
+  worktreeRemoveArgs,
+  type GitWorktree,
+} from "./worktrees.js"
 
 export interface GitSnapshot {
   available: boolean
   isRepository: boolean
   status: GitStatus
   commits: GitCommit[]
+  /** Every worktree of the repository, current one flagged. Empty outside a repo. */
+  worktrees: GitWorktree[]
   version: string | null
   lastRefreshedAt: Date | null
   /** Set when the last refresh failed; the previous snapshot is kept. */
@@ -27,11 +41,20 @@ export const EMPTY_GIT_SNAPSHOT: GitSnapshot = {
   isRepository: false,
   status: EMPTY_GIT_STATUS,
   commits: [],
+  worktrees: [],
   version: null,
   lastRefreshedAt: null,
   error: null,
 }
 
+export interface CreateWorktreeInput {
+  branch: string
+  /** Start point when the branch does not exist yet (default: HEAD). */
+  base?: string
+  /** Absolute destination directory. */
+  path: string
+}
+
 export type GitServiceEvents = {
   "git:changed": [GitSnapshot]
   "git:error": [DevccError]
@@ -77,10 +100,11 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
   }
 
   private async doRefresh(): Promise<GitSnapshot> {
-    const [versionResult, statusResult, logResult] = await Promise.all([
+    const [versionResult, statusResult, logResult, worktreeResult] = await Promise.all([
       this.git(["--version"]),
       this.git(["status", "--porcelain=v2", "--branch", "--untracked-files=all"]),
       this.git(["log", `--max-count=${this.commitLimit}`, `--pretty=format:${LOG_FORMAT}`]),
+      this.git(["worktree", "list", "--porcelain"]),
     ])
 
     const available = versionResult.spawnError === undefined
@@ -103,6 +127,7 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
         isRepository: false,
         status: EMPTY_GIT_STATUS,
         commits: [],
+        worktrees: [],
         version,
         lastRefreshedAt: new Date(),
         error: notARepo ? null : statusResult.stderr.trim() || "git status failed",
@@ -115,6 +140,7 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
       status: parsePorcelainV2(statusResult.stdout),
       // A fresh repository with no commits fails `git log`; an empty list is correct there.
       commits: logResult.ok ? parseCommits(logResult.stdout) : [],
+      worktrees: worktreeResult.ok ? parseWorktreeList(worktreeResult.stdout, this.currentPath()) : [],
       version,
       lastRefreshedAt: new Date(),
       error: null,
@@ -162,6 +188,66 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
     await this.mutate(["commit", "--message", trimmed], "git commit")
   }
 
+  /** Fresh worktree list, independent of the polling snapshot. */
+  async listWorktrees(): Promise<GitWorktree[]> {
+    const result = await this.git(["worktree", "list", "--porcelain"])
+    if (!result.ok) {
+      throw new DevccError({
+        scope: "git",
+        message: "git worktree list failed",
+        detail: result.stderr.trim() || (result.spawnError ? "git executable not found" : undefined),
+      })
+    }
+    return parseWorktreeList(result.stdout, this.currentPath())
+  }
+
+  /**
+   * Create a worktree. An existing local branch is checked out; otherwise the
+   * branch is created from `base` (default HEAD). Input is validated before git
+   * runs, and git's own ref check has the final word on the branch name.
+   */
+  async createWorktree(input: CreateWorktreeInput): Promise<string> {
+    const branch = input.branch.trim()
+    const base = input.base?.trim() || undefined
+    const path = resolve(input.path.trim())
+
+    const problem =
+      validateBranchName(branch) ??
+      (base ? validateRef(base) : null) ??
+      validateWorktreePath(path, existsSync)
+    if (problem) throw new DevccError({ scope: "git", message: problem })
+
+    const refCheck = await this.git(["check-ref-format", "--branch", branch])
+    if (!refCheck.ok) {
+      throw new DevccError({ scope: "git", message: `"${branch}" is not a valid branch name` })
+    }
+
+    const existing = await this.git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])
+    const createBranch = !existing.ok
+    await this.mutate(
+      worktreeAddArgs({ path, branch, base: createBranch ? base : undefined, createBranch }),
+      "git worktree add",
+      60_000,
+    )
+    return path
+  }
+
+  /**
+   * Remove a worktree without `--force`. devcc refuses the main and current
+   * worktrees and ones with running work (`busy`); git refuses dirty ones, and
+   * that refusal is surfaced verbatim rather than overridden.
+   */
+  async removeWorktree(path: string, busy: readonly string[] = []): Promise<void> {
+    const target = (await this.listWorktrees()).find((worktree) => worktree.path === path)
+    if (!target)
+      throw new DevccError({ scope: "git", message: `${path} is not a worktree of this repository` })
+
+    const blocker = removalBlocker(target, busy)
+    if (blocker) throw new DevccError({ scope: "git", message: blocker })
+
+    await this.mutate(worktreeRemoveArgs(target.path), "git worktree remove")
+  }
+
   /** Read-only diff for the inspect panel. */
   async diff(path: string, staged: boolean): Promise<string> {
     const args = ["--no-pager", "diff", "--no-color"]
@@ -176,9 +262,15 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
     if (!result.ok) {
       const detail = [result.stdout, result.stderr].filter(Boolean).join("\n").trim()
       this.options.logger.warn(`${label} failed`, { code: result.code, detail })
+      // Prefer git's fatal/error line: progress chatter ("Preparing worktree…") can come first.
+      const lines = detail.split("\n")
+      const reason = (lines.find((line) => /^(fatal|error): /u.test(line)) ?? lines[0])?.replace(
+        /^(fatal|error): /u,
+        "",
+      )
       const error = new DevccError({
         scope: "git",
-        message: `${label} failed`,
+        message: reason ? `${label} failed: ${reason}` : `${label} failed`,
         detail: detail || (result.timedOut ? "timed out" : undefined),
       })
       this.emit("git:error", error)
@@ -188,10 +280,20 @@ export class GitService extends TypedEmitter<GitServiceEvents> {
     await this.refresh()
   }
 
+  /** Real path of the project root, so git's resolved paths compare equal (macOS /var -> /private/var). */
+  private currentPath(): string {
+    try {
+      return realpathSync(this.options.rootDir)
+    } catch {
+      return resolve(this.options.rootDir)
+    }
+  }
+
   private git(args: readonly string[], timeoutMs?: number): Promise<ExecResult> {
     return exec("git", args, {
       cwd: this.options.rootDir,
       timeoutMs: timeoutMs ?? this.timeoutMs,
+      logger: this.options.logger,
       // Never let git open an editor or a credential prompt under the TUI.
       env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0", GIT_EDITOR: "true" },
     })