@doriandev/devcc 0.1.2

package/src/devcc/utils/packageManager.ts

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+export const PACKAGE_MANAGERS = ["pnpm", "yarn", "npm", "bun"] as const
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number]
+
+export interface PackageManagerDetection {
+  manager: PackageManager
+  /** How the decision was made - surfaced in the Settings view. */
+  source: "packageManager-field" | "lockfile" | "user-agent" | "default"
+  /** The lockfile that decided it, when applicable. */
+  evidence?: string
+}
+
+const LOCKFILES: ReadonlyArray<{ file: string; manager: PackageManager }> = [
+  { file: "pnpm-lock.yaml", manager: "pnpm" },
+  { file: "bun.lock", manager: "bun" },
+  { file: "bun.lockb", manager: "bun" },
+  { file: "yarn.lock", manager: "yarn" },
+  { file: "package-lock.json", manager: "npm" },
+  { file: "npm-shrinkwrap.json", manager: "npm" },
+]
+
+function isPackageManager(value: string): value is PackageManager {
+  return (PACKAGE_MANAGERS as readonly string[]).includes(value)
+}
+
+/**
+ * Parse the `packageManager` field of a package.json (corepack format,
+ * e.g. `pnpm@10.26.2+sha512...`).
+ */
+export function parsePackageManagerField(value: unknown): PackageManager | null {
+  if (typeof value !== "string") return null
+  const name = value.split("@")[0]?.trim().toLowerCase()
+  return name && isPackageManager(name) ? name : null
+}
+
+/** Parse the `npm_config_user_agent` env var, e.g. `pnpm/10.26.2 npm/? node/v24`. */
+export function parseUserAgent(userAgent: string | undefined): PackageManager | null {
+  if (!userAgent) return null
+  const name = userAgent.split("/")[0]?.trim().toLowerCase()
+  return name && isPackageManager(name) ? name : null
+}
+
+export interface DetectPackageManagerInput {
+  rootDir: string
+  packageJson?: Record<string, unknown> | null
+  userAgent?: string | undefined
+  /** Injected for tests. */
+  fileExists?: (path: string) => boolean
+}
+
+/**
+ * Detect the package manager, preferring explicit declarations over guesses:
+ * `packageManager` field -> lockfile -> the manager that launched us -> npm.
+ */
+export function detectPackageManager(input: DetectPackageManagerInput): PackageManagerDetection {
+  const fileExists = input.fileExists ?? existsSync
+
+  const declared = parsePackageManagerField(input.packageJson?.packageManager)
+  if (declared) return { manager: declared, source: "packageManager-field" }
+
+  for (const { file, manager } of LOCKFILES) {
+    if (fileExists(join(input.rootDir, file))) {
+      return { manager, source: "lockfile", evidence: file }
+    }
+  }
+
+  const fromAgent = parseUserAgent(input.userAgent)
+  if (fromAgent) return { manager: fromAgent, source: "user-agent" }
+
+  return { manager: "npm", source: "default" }
+}
+
+/** The argv needed to run a package.json script with the given manager. */
+export function runScriptArgs(manager: PackageManager, script: string): string[] {
+  switch (manager) {
+    case "npm":
+      return ["run", script]
+    case "yarn":
+      return [script]
+    case "pnpm":
+    case "bun":
+      return ["run", script]
+  }
+}
+
+/** Read and parse package.json, returning `null` when absent or invalid. */
+export function readPackageJson(rootDir: string): Record<string, unknown> | null {
+  const path = join(rootDir, "package.json")
+  try {
+    if (!existsSync(path)) return null
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"))
+    return typeof parsed === "object" && parsed !== null ? (parsed as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
+
+export interface PackageScript {
+  name: string
+  command: string
+}
+
+/** Extract `scripts` from a parsed package.json as a stable, sorted-by-declaration list. */
+export function readScripts(packageJson: Record<string, unknown> | null): PackageScript[] {
+  const scripts = packageJson?.scripts
+  if (typeof scripts !== "object" || scripts === null) return []
+  return Object.entries(scripts as Record<string, unknown>)
+    .filter((entry): entry is [string, string] => typeof entry[1] === "string")
+    .map(([name, command]) => ({ name, command }))
+}

package/src/devcc/utils/paths.ts

@@ -0,0 +1,39 @@
+import { existsSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+
+const PROJECT_MARKERS = ["package.json", ".git", "pnpm-workspace.yaml", "deno.json", "Cargo.toml"] as const
+
+/**
+ * Walk upwards from `startDir` looking for a project root marker.
+ * Falls back to `startDir` so the app always has somewhere to run.
+ */
+export function findProjectRoot(startDir: string = process.cwd()): string {
+  let current = resolve(startDir)
+
+  for (;;) {
+    for (const marker of PROJECT_MARKERS) {
+      if (existsSync(join(current, marker))) return current
+    }
+    const parent = dirname(current)
+    if (parent === current) return resolve(startDir)
+    current = parent
+  }
+}
+
+/** Directory holding devcc's own runtime artefacts (logs, future state). */
+export function devccDir(rootDir: string): string {
+  return join(rootDir, ".devcc")
+}
+
+/** Replace the home directory with `~` for compact display. */
+export function tildify(path: string, home = process.env.HOME ?? ""): string {
+  if (home && path.startsWith(home)) return `~${path.slice(home.length)}`
+  return path
+}
+
+/** Truncate a path from the left so the most specific segments stay visible. */
+export function truncatePath(path: string, maxLength: number): string {
+  if (path.length <= maxLength) return path
+  if (maxLength <= 1) return path.slice(-maxLength)
+  return `…${path.slice(-(maxLength - 1))}`
+}

package/src/devcc/views/DependenciesView.ts

@@ -0,0 +1,206 @@
+import type { KeyEvent } from "@opentui/core"
+import { theme } from "../app/theme.js"
+import type { KeyHint } from "../components/Footer.js"
+import { RowList, type ListRow } from "../components/primitives.js"
+import { chunk, dim, styled } from "../components/styled.js"
+import { setSelection, type AppState, type ViewId } from "../core/state.js"
+import type { OutdatedPackage, UpdateSeverity } from "../deps/parse.js"
+import { summariseOutdated } from "../deps/parse.js"
+import { fit, formatClock } from "../utils/format.js"
+import { View, type ViewDeps } from "./View.js"
+
+/**
+ * Rows rendered above the package list (summary + spacer).
+ *
+ * Fixed so the view and the palette command agree on what
+ * `ui.selection.dependencies` points at.
+ */
+export const DEPENDENCY_HEADER_ROWS = 2
+
+/** Map a selection index to an index into the package list. */
+export function selectedPackageIndex(selection: number): number {
+  return Math.max(0, selection - DEPENDENCY_HEADER_ROWS)
+}
+
+/**
+ * Outdated dependencies, grouped by how big the jump is.
+ *
+ * This is the only panel that never refreshes on a timer: it queries the
+ * registry over the network, so it runs when you ask it to (`r`) and not before.
+ */
+export class DependenciesView extends View {
+  readonly id: ViewId = "dependencies"
+  readonly title = "Dependencies"
+
+  private readonly list: RowList
+  private packages: OutdatedPackage[] = []
+
+  constructor(deps: ViewDeps) {
+    super(deps)
+    this.list = new RowList(deps.ctx, { flexGrow: 1 })
+    this.box.add(this.list.box)
+  }
+
+  update(state: AppState): void {
+    const snapshot = state.dependencies
+    this.packages = snapshot.packages
+
+    const width = Math.max(40, state.ui.width - (state.ui.sidebarVisible ? 26 : 4))
+    const nameWidth = Math.min(34, Math.max(14, Math.floor(width * 0.3)))
+    const rows: ListRow[] = []
+
+    rows.push({ key: "__summary", disabled: true, content: this.summaryRow(state) })
+    rows.push({ key: "__blank", disabled: true, content: "" })
+
+    // A status row only appears when there is no package list, which keeps the
+    // header height constant at DEPENDENCY_HEADER_ROWS whenever selection matters.
+    if (this.packages.length > 0 && snapshot.error) {
+      rows[0] = { key: "__summary", disabled: true, content: this.summaryRow(state) }
+    } else if (!snapshot.supported) {
+      rows.push({
+        key: "__unsupported",
+        disabled: true,
+        content: styled(
+          chunk(`⚠ ${snapshot.error ?? "not supported by this package manager"}`, theme.warning),
+        ),
+      })
+    } else if (snapshot.error) {
+      rows.push({
+        key: "__error",
+        disabled: true,
+        content: styled(chunk(`⚠ ${snapshot.error}`, theme.danger)),
+      })
+    } else if (snapshot.checkedAt === null) {
+      rows.push({
+        key: "__prompt",
+        disabled: true,
+        content: styled(dim("Press r to check the registry for updates.")),
+      })
+    } else if (this.packages.length === 0) {
+      rows.push({
+        key: "__uptodate",
+        disabled: true,
+        content: styled(chunk("✓ everything is up to date", theme.success)),
+      })
+    }
+
+    for (const entry of this.packages) {
+      rows.push({
+        key: entry.name,
+        content: styled(
+          chunk(fit(severityLabel(entry.severity), 7), severityColor(entry.severity)),
+          chunk(fit(entry.name, nameWidth), theme.textBright),
+          dim(fit(entry.current, 12)),
+          dim(fit("→", 2)),
+          chunk(fit(entry.latest, 12), severityColor(entry.severity)),
+          dim(fit(kindLabel(entry.kind), 6)),
+          entry.deprecated ? chunk("deprecated", theme.danger) : dim(entry.onlyLatest ? "outside range" : ""),
+        ),
+      })
+    }
+
+    this.list.setRows(rows, state.ui.selection.dependencies)
+  }
+
+  override handleKey(key: KeyEvent, state: AppState): boolean {
+    const selected = state.ui.selection.dependencies
+    const first = this.firstPackageRow()
+    const last = first + this.packages.length - 1
+
+    switch (key.name) {
+      case "up":
+      case "k":
+        if (this.packages.length > 0) {
+          setSelection(this.deps.app.store, "dependencies", Math.max(first, selected - 1))
+        }
+        return true
+      case "down":
+      case "j":
+        if (this.packages.length > 0) {
+          setSelection(this.deps.app.store, "dependencies", Math.min(last, Math.max(first, selected + 1)))
+        }
+        return true
+      case "r":
+        void this.deps.commands.run("deps.check", this.deps.app)
+        return true
+      case "u":
+        void this.updateSelected(selected)
+        return true
+      default:
+        return false
+    }
+  }
+
+  override hints(): KeyHint[] {
+    return [
+      { keys: "↑↓/jk", label: "select" },
+      { keys: "r", label: "check registry" },
+      { keys: "u", label: "update package" },
+      { keys: "/", label: "commands" },
+    ]
+  }
+
+  override onActivate(state: AppState): void {
+    // Land on the first real package rather than the summary header.
+    if (state.ui.selection.dependencies < this.firstPackageRow()) {
+      setSelection(this.deps.app.store, "dependencies", this.firstPackageRow())
+    }
+  }
+
+  private firstPackageRow(): number {
+    return DEPENDENCY_HEADER_ROWS
+  }
+
+  private summaryRow(state: AppState) {
+    const snapshot = state.dependencies
+    if (snapshot.checking) return styled(chunk("checking the registry…", theme.warning))
+
+    const counts = summariseOutdated(snapshot.packages)
+    const checked = snapshot.checkedAt ? formatClock(snapshot.checkedAt) : "never"
+    return styled(
+      chunk(state.project.packageManager.manager, theme.text),
+      dim("  ·  "),
+      chunk(`${counts.total} outdated`, counts.total > 0 ? theme.warning : theme.success),
+      dim("  ·  "),
+      chunk(`${counts.major} major`, counts.major > 0 ? theme.danger : theme.textDim),
+      dim(`  ·  ${counts.minor} minor  ·  ${counts.patch} patch  ·  checked ${checked}`),
+      snapshot.error ? chunk(`  ·  ⚠ ${snapshot.error}`, theme.danger) : dim(""),
+    )
+  }
+
+  private async updateSelected(index: number): Promise<void> {
+    const entry = this.packages[selectedPackageIndex(index)]
+    if (!entry) return
+    await this.deps.app.updateDependency(entry.name, entry.latest)
+  }
+}
+
+function severityLabel(severity: UpdateSeverity): string {
+  return severity === "unknown" ? "?" : severity
+}
+
+function severityColor(severity: UpdateSeverity): string {
+  switch (severity) {
+    case "major":
+      return theme.danger
+    case "minor":
+      return theme.warning
+    case "patch":
+      return theme.success
+    case "unknown":
+      return theme.textDim
+  }
+}
+
+function kindLabel(kind: OutdatedPackage["kind"]): string {
+  switch (kind) {
+    case "devDependencies":
+      return "dev"
+    case "peerDependencies":
+      return "peer"
+    case "optionalDependencies":
+      return "opt"
+    case "dependencies":
+      return "prod"
+  }
+}

package/src/devcc/views/GitView.ts

@@ -0,0 +1,259 @@
+import type { KeyEvent } from "@opentui/core"
+import { theme } from "../app/theme.js"
+import type { KeyHint } from "../components/Footer.js"
+import { RowList, type ListRow } from "../components/primitives.js"
+import { chunk, dim, styled } from "../components/styled.js"
+import { setSelection, type AppState, type ViewId } from "../core/state.js"
+import { summariseStatus, summariseTracking, type GitFile } from "../git/parse.js"
+import { errorMessage } from "../utils/errors.js"
+import { fit, truncate } from "../utils/format.js"
+import { View, type ViewDeps } from "./View.js"
+
+interface GitRow {
+  file?: GitFile
+}
+
+/**
+ * Git dashboard.
+ *
+ * Read operations refresh on a timer; every write is explicit, and the three
+ * that cannot be undone locally - discard, push, and hard operations from the
+ * palette - require a confirmation.
+ */
+export class GitView extends View {
+  readonly id: ViewId = "git"
+  readonly title = "Git"
+
+  private readonly list: RowList
+  private rowMeta: GitRow[] = []
+
+  constructor(deps: ViewDeps) {
+    super(deps)
+    this.list = new RowList(deps.ctx, { flexGrow: 1 })
+    this.box.add(this.list.box)
+  }
+
+  update(state: AppState): void {
+    const rows: ListRow[] = []
+    const meta: GitRow[] = []
+    const width = Math.max(40, state.ui.width - (state.ui.sidebarVisible ? 26 : 4))
+    const git = state.git
+
+    if (git.lastRefreshedAt === null) {
+      rows.push({ key: "__checking", disabled: true, content: styled(dim("checking git status…")) })
+    } else if (!git.available) {
+      rows.push({
+        key: "__nogit",
+        disabled: true,
+        content: styled(chunk("git is not installed", theme.danger)),
+      })
+    } else if (!git.isRepository) {
+      rows.push({
+        key: "__norepo",
+        disabled: true,
+        content: styled(dim("This directory is not a git repository")),
+      })
+    } else {
+      const branch = git.status.branch ?? `detached @ ${git.status.head ?? "?"}`
+      rows.push({
+        key: "__branch",
+        disabled: true,
+        content: styled(
+          dim(fit("branch", 12)),
+          chunk(branch, theme.textBright),
+          dim(`   ${summariseTracking(git.status)}`),
+        ),
+      })
+      rows.push({
+        key: "__status",
+        disabled: true,
+        content: styled(
+          dim(fit("status", 12)),
+          chunk(summariseStatus(git.status), git.status.clean ? theme.success : theme.warning),
+        ),
+      })
+      meta.push({}, {})
+
+      rows.push({ key: "__blank1", disabled: true, content: "" })
+      meta.push({})
+      rows.push({ key: "__files", disabled: true, content: styled(chunk("CHANGES", theme.accent)) })
+      meta.push({})
+
+      if (git.status.files.length === 0) {
+        rows.push({ key: "__clean", disabled: true, content: styled(dim("  working tree clean")) })
+        meta.push({})
+      }
+
+      for (const file of git.status.files) {
+        rows.push({
+          key: `file-${file.path}`,
+          content: styled(
+            chunk(fit(file.code, 4), stateColor(file.state)),
+            chunk(fit(file.state, 11), stateColor(file.state)),
+            chunk(truncate(file.path, Math.max(10, width - 20)), theme.text),
+          ),
+        })
+        meta.push({ file })
+      }
+
+      if (git.commits.length > 0 && state.ui.height > 22) {
+        rows.push({ key: "__blank2", disabled: true, content: "" })
+        meta.push({})
+        rows.push({
+          key: "__commits",
+          disabled: true,
+          content: styled(chunk("RECENT COMMITS", theme.accent)),
+        })
+        meta.push({})
+        for (const commit of git.commits.slice(0, 6)) {
+          rows.push({
+            key: `commit-${commit.hash}`,
+            disabled: true,
+            content: styled(
+              dim(fit(commit.shortHash, 9)),
+              chunk(truncate(commit.subject, Math.max(10, width - 34)), theme.text),
+              dim(`  ${commit.relativeDate}`),
+            ),
+          })
+          meta.push({})
+        }
+      }
+    }
+
+    if (git.error) {
+      rows.push({ key: "__error", disabled: true, content: styled(chunk(`⚠ ${git.error}`, theme.danger)) })
+      meta.push({})
+    }
+
+    this.rowMeta = meta
+    this.list.setRows(rows, state.ui.selection.git)
+  }
+
+  override handleKey(key: KeyEvent, state: AppState): boolean {
+    const selected = state.ui.selection.git
+
+    switch (key.name) {
+      case "up":
+      case "k":
+        this.move(selected, -1)
+        return true
+      case "down":
+      case "j":
+        this.move(selected, 1)
+        return true
+      case "r":
+        void this.refresh()
+        return true
+      case "s":
+        void this.stage(selected)
+        return true
+      case "u":
+        void this.unstage(selected)
+        return true
+      case "d":
+        void this.discard(selected)
+        return true
+      case "c":
+        void this.deps.commands.run("git.commit", this.deps.app)
+        return true
+      case "p":
+        // Shift+P arrives as name "p" with `shift` set.
+        void this.deps.commands.run(key.shift ? "git.push" : "git.pull", this.deps.app)
+        return true
+      case "f":
+        void this.deps.commands.run("git.fetch", this.deps.app)
+        return true
+      default:
+        return false
+    }
+  }
+
+  override hints(): KeyHint[] {
+    return [
+      { keys: "↑↓/jk", label: "select" },
+      { keys: "s/u", label: "stage/unstage" },
+      { keys: "d", label: "discard" },
+      { keys: "c", label: "commit" },
+      { keys: "p/P", label: "pull/push" },
+      { keys: "f", label: "fetch" },
+      { keys: "r", label: "refresh" },
+    ]
+  }
+
+  private move(from: number, direction: 1 | -1): void {
+    let index = from
+    for (let steps = 0; steps < this.rowMeta.length; steps += 1) {
+      index += direction
+      if (index < 0 || index >= this.rowMeta.length) return
+      if (this.rowMeta[index]?.file) {
+        setSelection(this.deps.app.store, "git", index)
+        return
+      }
+    }
+  }
+
+  private selectedFile(index: number): GitFile | undefined {
+    return this.rowMeta[index]?.file
+  }
+
+  private async refresh(): Promise<void> {
+    await this.deps.app.git.refresh()
+    this.deps.app.notify("info", "Git status refreshed")
+  }
+
+  private async stage(index: number): Promise<void> {
+    const file = this.selectedFile(index)
+    if (!file) return
+    try {
+      await this.deps.app.git.stage([file.path])
+      this.deps.app.notify("success", `Staged ${file.path}`)
+    } catch (error) {
+      this.deps.app.notify("error", errorMessage(error))
+    }
+  }
+
+  private async unstage(index: number): Promise<void> {
+    const file = this.selectedFile(index)
+    if (!file) return
+    try {
+      await this.deps.app.git.unstage([file.path])
+      this.deps.app.notify("success", `Unstaged ${file.path}`)
+    } catch (error) {
+      this.deps.app.notify("error", errorMessage(error))
+    }
+  }
+
+  /** Destructive: always confirmed, never applied to untracked files. */
+  private async discard(index: number): Promise<void> {
+    const file = this.selectedFile(index)
+    if (!file) return
+    if (file.state === "untracked") {
+      this.deps.app.notify("warn", "Refusing to delete untracked files; remove them manually")
+      return
+    }
+    const confirmed = await this.deps.app.confirm(
+      `Discard changes in ${file.path}?`,
+      "This runs `git restore` and permanently throws away your local edits to this file.",
+    )
+    if (!confirmed) return
+    try {
+      await this.deps.app.git.discard([file.path])
+      this.deps.app.notify("success", `Discarded changes in ${file.path}`)
+    } catch (error) {
+      this.deps.app.notify("error", errorMessage(error))
+    }
+  }
+}
+
+function stateColor(state: GitFile["state"]): string {
+  switch (state) {
+    case "staged":
+      return theme.success
+    case "modified":
+      return theme.warning
+    case "untracked":
+      return theme.textDim
+    case "conflicted":
+      return theme.danger
+  }
+}