@doriandev/devcc 0.1.2

package/src/devcc/git/GitService.ts

@@ -0,0 +1,205 @@
+import { TypedEmitter } from "../core/events.js"
+import { DevccError } from "../utils/errors.js"
+import { exec, type ExecResult } from "../utils/exec.js"
+import type { ScopedLogger } from "../utils/logger.js"
+import {
+  EMPTY_GIT_STATUS,
+  LOG_FORMAT,
+  parseCommits,
+  parsePorcelainV2,
+  type GitCommit,
+  type GitStatus,
+} from "./parse.js"
+
+export interface GitSnapshot {
+  available: boolean
+  isRepository: boolean
+  status: GitStatus
+  commits: GitCommit[]
+  version: string | null
+  lastRefreshedAt: Date | null
+  /** Set when the last refresh failed; the previous snapshot is kept. */
+  error: string | null
+}
+
+export const EMPTY_GIT_SNAPSHOT: GitSnapshot = {
+  available: false,
+  isRepository: false,
+  status: EMPTY_GIT_STATUS,
+  commits: [],
+  version: null,
+  lastRefreshedAt: null,
+  error: null,
+}
+
+export type GitServiceEvents = {
+  "git:changed": [GitSnapshot]
+  "git:error": [DevccError]
+}
+
+export interface GitServiceOptions {
+  rootDir: string
+  logger: ScopedLogger
+  commitLimit?: number
+  timeoutMs?: number
+}
+
+/**
+ * Thin wrapper around the `git` executable.
+ *
+ * We call git directly rather than adding a git abstraction library: the six
+ * commands the dashboard needs are stable plumbing, and porcelain v2 output is
+ * far easier to keep honest than a dependency's changing object model.
+ */
+export class GitService extends TypedEmitter<GitServiceEvents> {
+  private snapshot: GitSnapshot = { ...EMPTY_GIT_SNAPSHOT }
+  private refreshing: Promise<GitSnapshot> | null = null
+  private readonly commitLimit: number
+  private readonly timeoutMs: number
+
+  constructor(private readonly options: GitServiceOptions) {
+    super()
+    this.commitLimit = options.commitLimit ?? 8
+    this.timeoutMs = options.timeoutMs ?? 5_000
+  }
+
+  getSnapshot(): GitSnapshot {
+    return this.snapshot
+  }
+
+  /** Refresh branch/status/commits. Concurrent calls share one run. */
+  async refresh(): Promise<GitSnapshot> {
+    if (this.refreshing) return this.refreshing
+    this.refreshing = this.doRefresh().finally(() => {
+      this.refreshing = null
+    })
+    return this.refreshing
+  }
+
+  private async doRefresh(): Promise<GitSnapshot> {
+    const [versionResult, statusResult, logResult] = 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}`]),
+    ])
+
+    const available = versionResult.spawnError === undefined
+    if (!available) {
+      return this.publish({
+        ...EMPTY_GIT_SNAPSHOT,
+        available: false,
+        lastRefreshedAt: new Date(),
+        error: "git executable not found",
+      })
+    }
+
+    const version = versionResult.ok ? versionResult.stdout.trim().replace(/^git version /u, "") : null
+
+    if (!statusResult.ok) {
+      const notARepo = /not a git repository/iu.test(statusResult.stderr)
+      return this.publish({
+        ...this.snapshot,
+        available: true,
+        isRepository: false,
+        status: EMPTY_GIT_STATUS,
+        commits: [],
+        version,
+        lastRefreshedAt: new Date(),
+        error: notARepo ? null : statusResult.stderr.trim() || "git status failed",
+      })
+    }
+
+    return this.publish({
+      available: true,
+      isRepository: true,
+      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) : [],
+      version,
+      lastRefreshedAt: new Date(),
+      error: null,
+    })
+  }
+
+  /** `git fetch` is deliberately manual: it touches the network. */
+  async fetch(): Promise<void> {
+    await this.mutate(["fetch", "--prune"], "git fetch", 30_000)
+  }
+
+  async pull(): Promise<void> {
+    await this.mutate(["pull", "--ff-only"], "git pull", 60_000)
+  }
+
+  async push(): Promise<void> {
+    await this.mutate(["push"], "git push", 60_000)
+  }
+
+  async stage(paths: readonly string[]): Promise<void> {
+    if (paths.length === 0) return
+    await this.mutate(["add", "--", ...paths], "git add")
+  }
+
+  async stageAll(): Promise<void> {
+    await this.mutate(["add", "--all"], "git add --all")
+  }
+
+  async unstage(paths: readonly string[]): Promise<void> {
+    if (paths.length === 0) return
+    await this.mutate(["restore", "--staged", "--", ...paths], "git restore --staged")
+  }
+
+  /** Destructive: throws away worktree changes. Callers must confirm first. */
+  async discard(paths: readonly string[]): Promise<void> {
+    if (paths.length === 0) return
+    await this.mutate(["restore", "--worktree", "--", ...paths], "git restore")
+  }
+
+  async commit(message: string): Promise<void> {
+    const trimmed = message.trim()
+    if (trimmed === "") {
+      throw new DevccError({ scope: "git", message: "Commit message is empty" })
+    }
+    await this.mutate(["commit", "--message", trimmed], "git commit")
+  }
+
+  /** Read-only diff for the inspect panel. */
+  async diff(path: string, staged: boolean): Promise<string> {
+    const args = ["--no-pager", "diff", "--no-color"]
+    if (staged) args.push("--staged")
+    args.push("--", path)
+    const result = await this.git(args, 10_000)
+    return result.ok ? result.stdout : result.stderr
+  }
+
+  private async mutate(args: readonly string[], label: string, timeoutMs?: number): Promise<void> {
+    const result = await this.git(args, timeoutMs)
+    if (!result.ok) {
+      const detail = [result.stdout, result.stderr].filter(Boolean).join("\n").trim()
+      this.options.logger.warn(`${label} failed`, { code: result.code, detail })
+      const error = new DevccError({
+        scope: "git",
+        message: `${label} failed`,
+        detail: detail || (result.timedOut ? "timed out" : undefined),
+      })
+      this.emit("git:error", error)
+      throw error
+    }
+    this.options.logger.info(`${label} ok`)
+    await this.refresh()
+  }
+
+  private git(args: readonly string[], timeoutMs?: number): Promise<ExecResult> {
+    return exec("git", args, {
+      cwd: this.options.rootDir,
+      timeoutMs: timeoutMs ?? this.timeoutMs,
+      // 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" },
+    })
+  }
+
+  private publish(snapshot: GitSnapshot): GitSnapshot {
+    this.snapshot = snapshot
+    this.emit("git:changed", snapshot)
+    return snapshot
+  }
+}

package/src/devcc/git/parse.ts

@@ -0,0 +1,203 @@
+/**
+ * Pure parsers for git plumbing output.
+ *
+ * Kept separate from `GitService` so they can be unit tested without a repo,
+ * and so the shape of the data the UI consumes is defined in one place.
+ */
+
+export type GitFileState = "staged" | "modified" | "untracked" | "conflicted"
+
+export interface GitFile {
+  path: string
+  state: GitFileState
+  /** Two-letter porcelain code, e.g. `M.`, `.M`, `A.`, `??`. */
+  code: string
+  /** Original path for renames. */
+  origPath?: string
+}
+
+export interface GitStatus {
+  branch: string | null
+  upstream: string | null
+  ahead: number
+  behind: number
+  /** Short commit hash of HEAD, when known. */
+  head: string | null
+  files: GitFile[]
+  clean: boolean
+}
+
+export interface GitCommit {
+  hash: string
+  shortHash: string
+  author: string
+  relativeDate: string
+  subject: string
+}
+
+export const EMPTY_GIT_STATUS: GitStatus = {
+  branch: null,
+  upstream: null,
+  ahead: 0,
+  behind: 0,
+  head: null,
+  files: [],
+  clean: true,
+}
+
+/**
+ * Parse `git status --porcelain=v2 --branch --untracked-files=all`.
+ *
+ * Format reference: `man git-status`, "Porcelain Format Version 2".
+ */
+export function parsePorcelainV2(output: string): GitStatus {
+  const status: GitStatus = { ...EMPTY_GIT_STATUS, files: [] }
+
+  for (const rawLine of output.split("\n")) {
+    const line = rawLine.replace(/\r$/u, "")
+    if (line.length === 0) continue
+
+    if (line.startsWith("# branch.head ")) {
+      const value = line.slice("# branch.head ".length).trim()
+      status.branch = value === "(detached)" ? null : value
+      continue
+    }
+    if (line.startsWith("# branch.oid ")) {
+      const value = line.slice("# branch.oid ".length).trim()
+      status.head = value === "(initial)" ? null : value.slice(0, 7)
+      continue
+    }
+    if (line.startsWith("# branch.upstream ")) {
+      status.upstream = line.slice("# branch.upstream ".length).trim()
+      continue
+    }
+    if (line.startsWith("# branch.ab ")) {
+      for (const part of line.slice("# branch.ab ".length).trim().split(" ")) {
+        const value = Number.parseInt(part.slice(1), 10)
+        if (Number.isNaN(value)) continue
+        if (part.startsWith("+")) status.ahead = value
+        else if (part.startsWith("-")) status.behind = value
+      }
+      continue
+    }
+    if (line.startsWith("# ")) continue
+
+    const kind = line[0]
+    if (kind === "1") {
+      // 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+      const fields = splitFields(line, 8)
+      const code = fields[1] ?? ".."
+      const path = fields[8] ?? ""
+      if (path) status.files.push({ path, code, state: stateFromCode(code) })
+      continue
+    }
+    if (kind === "2") {
+      // 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path><TAB><origPath>
+      const fields = splitFields(line, 9)
+      const code = fields[1] ?? ".."
+      const rest = fields[9] ?? ""
+      const [path = "", origPath] = rest.split("\t")
+      if (path) status.files.push({ path, code, state: stateFromCode(code), origPath })
+      continue
+    }
+    if (kind === "u") {
+      const fields = splitFields(line, 10)
+      const path = fields[10] ?? ""
+      if (path) status.files.push({ path, code: fields[1] ?? "UU", state: "conflicted" })
+      continue
+    }
+    if (kind === "?") {
+      const path = line.slice(2)
+      if (path) status.files.push({ path, code: "??", state: "untracked" })
+      continue
+    }
+  }
+
+  status.clean = status.files.length === 0
+  return status
+}
+
+/**
+ * Porcelain v2 codes are `XY` where X is the staged change and Y the worktree
+ * change; `.` means "unchanged".
+ */
+function stateFromCode(code: string): GitFileState {
+  const staged = code[0] ?? "."
+  return staged !== "." && staged !== "?" ? "staged" : "modified"
+}
+
+/** Split a porcelain line into `count` space-separated fields plus the remainder. */
+function splitFields(line: string, count: number): string[] {
+  const fields: string[] = []
+  let index = 0
+  for (let i = 0; i < count; i += 1) {
+    const next = line.indexOf(" ", index)
+    if (next === -1) {
+      fields.push(line.slice(index))
+      return fields
+    }
+    fields.push(line.slice(index, next))
+    index = next + 1
+  }
+  fields.push(line.slice(index))
+  return fields
+}
+
+/** ASCII unit separator (0x1F), used as the field separator in our git log format. */
+export const LOG_SEPARATOR = String.fromCharCode(31)
+
+/** Format string matching {@link parseCommits}. */
+export const LOG_FORMAT = ["%H", "%h", "%an", "%ar", "%s"].join(LOG_SEPARATOR)
+
+/** Parse `git log --pretty=format:<LOG_FORMAT>`. */
+export function parseCommits(output: string): GitCommit[] {
+  const commits: GitCommit[] = []
+  for (const line of output.split("\n")) {
+    if (line.trim() === "") continue
+    const [hash, shortHash, author, relativeDate, ...subject] = line.split(LOG_SEPARATOR)
+    if (!hash || !shortHash) continue
+    commits.push({
+      hash,
+      shortHash,
+      author: author ?? "",
+      relativeDate: relativeDate ?? "",
+      subject: subject.join(LOG_SEPARATOR),
+    })
+  }
+  return commits
+}
+
+export interface GitCounts {
+  staged: number
+  modified: number
+  untracked: number
+  conflicted: number
+}
+
+export function countByState(files: readonly GitFile[]): GitCounts {
+  const counts: GitCounts = { staged: 0, modified: 0, untracked: 0, conflicted: 0 }
+  for (const file of files) counts[file.state] += 1
+  return counts
+}
+
+/** Short summary such as `3 staged / 2 modified / 1 untracked`, or `clean`. */
+export function summariseStatus(status: GitStatus): string {
+  if (status.clean) return "clean"
+  const counts = countByState(status.files)
+  const parts: string[] = []
+  if (counts.staged) parts.push(`${counts.staged} staged`)
+  if (counts.modified) parts.push(`${counts.modified} modified`)
+  if (counts.untracked) parts.push(`${counts.untracked} untracked`)
+  if (counts.conflicted) parts.push(`${counts.conflicted} conflicted`)
+  return parts.join(" / ")
+}
+
+/** `ahead 2, behind 1`, or `up to date` / `no upstream`. */
+export function summariseTracking(status: GitStatus): string {
+  if (!status.upstream) return "no upstream"
+  if (status.ahead === 0 && status.behind === 0) return "up to date"
+  const parts: string[] = []
+  if (status.ahead) parts.push(`ahead ${status.ahead}`)
+  if (status.behind) parts.push(`behind ${status.behind}`)
+  return parts.join(", ")
+}

package/src/devcc/index.ts

@@ -0,0 +1,115 @@
+/**
+ * Public API for Dev Command Center.
+ *
+ * Project config files import `defineConfig` from here; embedders can drive the
+ * `App` directly or reuse individual pieces (process manager, service adapters,
+ * git parsing) without the UI.
+ */
+
+export { App, type AppOptions } from "./app/App.js"
+export { createBuiltinCommands, createConfigCommands, createScriptCommands } from "./app/builtinCommands.js"
+export { HELP_SECTIONS, VIEW_SHORTCUTS } from "./app/keymap.js"
+export { theme, glyphs, processStatusStyle, serviceStateStyle } from "./app/theme.js"
+
+export { CommandRegistry, type CommandContext, type CommandDefinition } from "./core/commands.js"
+export {
+  defineConfig,
+  loadConfig,
+  validateConfig,
+  findConfigFile,
+  CONFIG_FILENAMES,
+  DEFAULT_REFRESH,
+  type CommandConfigEntry,
+  type DevccConfig,
+  type ResolvedConfig,
+  type ServiceConfigEntry,
+} from "./core/config.js"
+export { TypedEmitter, Subscriptions, type Unsubscribe } from "./core/events.js"
+export {
+  Store,
+  VIEW_IDS,
+  createInitialState,
+  type AppState,
+  type Notification,
+  type ProjectState,
+  type UiState,
+  type ViewId,
+} from "./core/state.js"
+
+export { DependencyService, updateArgs, type DependencySnapshot } from "./deps/DependencyService.js"
+export {
+  outdatedArgs,
+  parseOutdated,
+  severityBetween,
+  sortOutdated,
+  summariseOutdated,
+  supportsOutdatedJson,
+  type OutdatedPackage,
+  type UpdateSeverity,
+} from "./deps/parse.js"
+
+export { GitService, type GitSnapshot } from "./git/GitService.js"
+export {
+  parseCommits,
+  parsePorcelainV2,
+  summariseStatus,
+  summariseTracking,
+  type GitCommit,
+  type GitFile,
+  type GitStatus,
+} from "./git/parse.js"
+
+export {
+  LogBuffer,
+  LogStore,
+  MAX_LOG_LINES,
+  type LogEntry,
+  type LogSource,
+  type LogStream,
+} from "./logs/LogBuffer.js"
+
+export {
+  canTransition,
+  crashBackoffDelay,
+  shouldAutoRestart,
+  DEFAULT_CRASH_POLICY,
+  createManagedProcess,
+  describeCommand,
+  isActive,
+  type ManagedProcess,
+  type ProcessDefinition,
+  type ProcessStatus,
+  type ReadinessCheck,
+} from "./processes/ManagedProcess.js"
+export { dependentsOf, planStartOrder, type StartPlan } from "./processes/graph.js"
+export { ProcessManager, type ProcessManagerOptions } from "./processes/ProcessManager.js"
+
+export {
+  buildProjectList,
+  discoverProjects,
+  isProjectDirectory,
+  readRecents,
+  recordRecent,
+  type ProjectEntry,
+} from "./projects/ProjectRegistry.js"
+
+export { ServiceManager } from "./services/ServiceManager.js"
+export { DockerService, findComposeFile, parseComposePs } from "./services/docker.js"
+export { PortService, detectNodeServices } from "./services/node.js"
+export { OllamaService } from "./services/ollama.js"
+export { PostgresService, parsePostgresUrl } from "./services/postgres.js"
+export { RedisService, parseRedisUrl } from "./services/redis.js"
+export type { ServiceAdapter, ServiceSnapshot, ServiceState, ServiceStatus } from "./services/types.js"
+
+export { SystemMonitor, cpuUsageBetween, sampleCpu, type SystemMetrics } from "./system/SystemMonitor.js"
+
+export { DevccError, errorMessage, toDevccError } from "./utils/errors.js"
+export { Logger, createLogger, type LogLevel } from "./utils/logger.js"
+export {
+  detectPackageManager,
+  readPackageJson,
+  readScripts,
+  runScriptArgs,
+  type PackageManager,
+} from "./utils/packageManager.js"
+export { findProjectRoot } from "./utils/paths.js"