@doriandev/devcc 0.1.2

package/src/devcc/core/state.ts

@@ -0,0 +1,236 @@
+import type { GitSnapshot } from "../git/GitService.js"
+import { EMPTY_GIT_SNAPSHOT } from "../git/GitService.js"
+import type { LogSource } from "../logs/LogBuffer.js"
+import type { ManagedProcess } from "../processes/ManagedProcess.js"
+import type { DependencySnapshot } from "../deps/DependencyService.js"
+import { EMPTY_DEPENDENCY_SNAPSHOT } from "../deps/DependencyService.js"
+import type { ProjectEntry } from "../projects/ProjectRegistry.js"
+import type { ServiceSnapshot } from "../services/types.js"
+import type { HostInfo, SystemMetrics, ToolVersions } from "../system/SystemMonitor.js"
+import type { PackageManagerDetection } from "../utils/packageManager.js"
+
+export const VIEW_IDS = [
+  "overview",
+  "processes",
+  "services",
+  "scripts",
+  "git",
+  "logs",
+  "dependencies",
+  "system",
+  "settings",
+] as const
+
+export type ViewId = (typeof VIEW_IDS)[number]
+
+export type OverlayKind = "none" | "palette" | "help" | "confirm" | "prompt" | "projects" | "inspect"
+
+export type NotificationLevel = "info" | "success" | "warn" | "error"
+
+export interface Notification {
+  id: number
+  level: NotificationLevel
+  message: string
+  detail?: string
+  createdAt: Date
+}
+
+export interface ProjectState {
+  name: string
+  rootDir: string
+  packageManager: PackageManagerDetection
+  configPath: string | null
+  configIssues: string[]
+  host: HostInfo
+  tools: ToolVersions
+}
+
+export interface ScriptRun {
+  scriptName: string
+  /** Process id in the ProcessManager, also the log source id. */
+  processId: string
+  startedAt: Date
+  finishedAt?: Date
+  exitCode?: number
+  status: "running" | "succeeded" | "failed"
+}
+
+export interface ScriptsState {
+  available: { name: string; command: string }[]
+  runs: Record<string, ScriptRun>
+}
+
+export interface UiState {
+  view: ViewId
+  overlay: OverlayKind
+  /** Selected row index per view; keeps position when switching back. */
+  selection: Record<ViewId, number>
+  logSource: string | null
+  logFollow: boolean
+  /** Terminal size; views degrade gracefully below the thresholds. */
+  width: number
+  height: number
+  sidebarVisible: boolean
+  statusMessage: string | null
+  clock: Date
+}
+
+export interface AppState {
+  ui: UiState
+  project: ProjectState
+  processes: ManagedProcess[]
+  services: ServiceSnapshot[]
+  scripts: ScriptsState
+  git: GitSnapshot
+  dependencies: DependencySnapshot
+  system: SystemMetrics | null
+  logSources: LogSource[]
+  notifications: Notification[]
+  /** Projects devcc can switch to, including the current one. */
+  projects: ProjectEntry[]
+}
+
+/** Terminal narrower than this hides the sidebar. */
+export const NARROW_WIDTH = 76
+/** Terminal shorter than this drops decorative rows. */
+export const SHORT_HEIGHT = 20
+
+export function createInitialSelection(): Record<ViewId, number> {
+  return Object.fromEntries(VIEW_IDS.map((id) => [id, 0])) as Record<ViewId, number>
+}
+
+export function createInitialState(project: ProjectState, width: number, height: number): AppState {
+  return {
+    ui: {
+      view: "overview",
+      overlay: "none",
+      selection: createInitialSelection(),
+      logSource: null,
+      logFollow: true,
+      width,
+      height,
+      sidebarVisible: width >= NARROW_WIDTH,
+      statusMessage: null,
+      clock: new Date(),
+    },
+    project,
+    processes: [],
+    services: [],
+    scripts: { available: [], runs: {} },
+    git: EMPTY_GIT_SNAPSHOT,
+    dependencies: EMPTY_DEPENDENCY_SNAPSHOT,
+    system: null,
+    logSources: [],
+    notifications: [],
+    projects: [],
+  }
+}
+
+export type Listener<T> = (value: T, previous: T) => void
+
+/**
+ * Minimal observable store.
+ *
+ * `watch()` subscribes to a slice: the listener only fires when that slice
+ * actually changes, so a 1 Hz CPU sample does not repaint the git panel.
+ */
+export class Store<S extends object> {
+  private state: S
+  private readonly watchers = new Set<{
+    select: (state: S) => unknown
+    equals: (a: unknown, b: unknown) => boolean
+    listener: Listener<never>
+    last: unknown
+  }>()
+
+  constructor(initialState: S) {
+    this.state = initialState
+  }
+
+  getState(): S {
+    return this.state
+  }
+
+  /** Replace state via an updater; watchers are notified with the new slices. */
+  setState(updater: (state: S) => S): void {
+    const previous = this.state
+    const next = updater(previous)
+    if (next === previous) return
+    this.state = next
+    this.notify()
+  }
+
+  /** Patch top-level keys. Reference-equal patches are ignored. */
+  patch(patch: Partial<S>): void {
+    this.setState((state) => {
+      let changed = false
+      for (const key of Object.keys(patch) as (keyof S)[]) {
+        if (patch[key] !== state[key]) {
+          changed = true
+          break
+        }
+      }
+      return changed ? { ...state, ...patch } : state
+    })
+  }
+
+  watch<T>(
+    select: (state: S) => T,
+    listener: Listener<T>,
+    equals: (a: T, b: T) => boolean = Object.is,
+  ): () => void {
+    const entry = {
+      select: select as (state: S) => unknown,
+      equals: equals as (a: unknown, b: unknown) => boolean,
+      listener: listener as unknown as Listener<never>,
+      last: select(this.state) as unknown,
+    }
+    this.watchers.add(entry)
+    return () => {
+      this.watchers.delete(entry)
+    }
+  }
+
+  private notify(): void {
+    for (const entry of [...this.watchers]) {
+      const value = entry.select(this.state)
+      if (entry.equals(value, entry.last)) continue
+      const last = entry.last
+      entry.last = value
+      ;(entry.listener as unknown as Listener<unknown>)(value, last)
+    }
+  }
+}
+
+export type AppStore = Store<AppState>
+
+/** Shallow array equality, for watching lists of snapshots. */
+export function shallowArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean {
+  if (a === b) return true
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
+/** Convenience updaters used by the app layer. */
+export function updateUi(store: AppStore, patch: Partial<UiState>): void {
+  store.setState((state) => {
+    let changed = false
+    for (const key of Object.keys(patch) as (keyof UiState)[]) {
+      if (patch[key] !== state.ui[key]) {
+        changed = true
+        break
+      }
+    }
+    return changed ? { ...state, ui: { ...state.ui, ...patch } } : state
+  })
+}
+
+export function setSelection(store: AppStore, view: ViewId, index: number): void {
+  store.setState((state) => {
+    if (state.ui.selection[view] === index) return state
+    return { ...state, ui: { ...state.ui, selection: { ...state.ui.selection, [view]: index } } }
+  })
+}

package/src/devcc/deps/DependencyService.ts

@@ -0,0 +1,152 @@
+import { TypedEmitter } from "../core/events.js"
+import { DevccError } from "../utils/errors.js"
+import { exec } from "../utils/exec.js"
+import type { ScopedLogger } from "../utils/logger.js"
+import type { PackageManager } from "../utils/packageManager.js"
+import {
+  outdatedArgs,
+  parseOutdated,
+  sortOutdated,
+  supportsOutdatedJson,
+  type OutdatedPackage,
+} from "./parse.js"
+
+export interface DependencySnapshot {
+  packages: OutdatedPackage[]
+  /** Null until the first check has run. */
+  checkedAt: Date | null
+  checking: boolean
+  /** Set when the check could not run at all (unsupported manager, no network). */
+  error: string | null
+  supported: boolean
+}
+
+export const EMPTY_DEPENDENCY_SNAPSHOT: DependencySnapshot = {
+  packages: [],
+  checkedAt: null,
+  checking: false,
+  error: null,
+  supported: true,
+}
+
+export type DependencyServiceEvents = {
+  "deps:changed": [DependencySnapshot]
+  "deps:error": [DevccError]
+}
+
+export interface DependencyServiceOptions {
+  rootDir: string
+  manager: PackageManager
+  logger: ScopedLogger
+  /** Registry lookups are slow; the default budget is generous. */
+  timeoutMs?: number
+}
+
+/**
+ * Checks for outdated dependencies via the project's own package manager.
+ *
+ * This is the one panel that never polls: it talks to the registry, so it runs
+ * only when asked. `outdated` exits non-zero when it finds updates, which is a
+ * result and not a failure - only an empty parse plus a non-zero exit is an
+ * error worth reporting.
+ */
+export class DependencyService extends TypedEmitter<DependencyServiceEvents> {
+  private snapshot: DependencySnapshot = { ...EMPTY_DEPENDENCY_SNAPSHOT }
+  private inFlight: Promise<DependencySnapshot> | null = null
+  private readonly timeoutMs: number
+
+  constructor(private readonly options: DependencyServiceOptions) {
+    super()
+    this.timeoutMs = options.timeoutMs ?? 90_000
+    this.snapshot = { ...EMPTY_DEPENDENCY_SNAPSHOT, supported: supportsOutdatedJson(options.manager) }
+  }
+
+  getSnapshot(): DependencySnapshot {
+    return this.snapshot
+  }
+
+  /** Run the check. Concurrent calls share one run. */
+  async check(): Promise<DependencySnapshot> {
+    if (this.inFlight) return this.inFlight
+    this.inFlight = this.run().finally(() => {
+      this.inFlight = null
+    })
+    return this.inFlight
+  }
+
+  private async run(): Promise<DependencySnapshot> {
+    const { manager, rootDir } = this.options
+
+    if (!supportsOutdatedJson(manager)) {
+      return this.publish({
+        ...this.snapshot,
+        supported: false,
+        checking: false,
+        checkedAt: new Date(),
+        error: `${manager} does not provide machine-readable "outdated" output`,
+      })
+    }
+
+    this.publish({ ...this.snapshot, checking: true, error: null })
+
+    const result = await exec(manager, outdatedArgs(manager), {
+      cwd: rootDir,
+      timeoutMs: this.timeoutMs,
+      maxBuffer: 8 * 1024 * 1024,
+    })
+
+    if (result.spawnError) {
+      return this.fail(`${manager} not found on PATH`)
+    }
+    if (result.timedOut) {
+      return this.fail(`${manager} outdated timed out`)
+    }
+
+    const packages = sortOutdated(parseOutdated(manager, result.stdout))
+
+    // `outdated` exits 1 when updates exist, so only treat a non-zero exit with
+    // nothing parsed as a real failure.
+    if (packages.length === 0 && !result.ok && result.stdout.trim() === "") {
+      const detail = result.stderr.trim()
+      if (detail !== "") {
+        this.options.logger.warn("outdated check failed", { code: result.code, detail })
+        return this.fail(detail.split("\n")[0] ?? "outdated check failed")
+      }
+    }
+
+    this.options.logger.info("outdated check complete", { count: packages.length })
+    return this.publish({
+      packages,
+      checkedAt: new Date(),
+      checking: false,
+      error: null,
+      supported: true,
+    })
+  }
+
+  private fail(message: string): DependencySnapshot {
+    const error = new DevccError({ scope: "command", message: `Dependency check failed: ${message}` })
+    this.emit("deps:error", error)
+    return this.publish({ ...this.snapshot, checking: false, checkedAt: new Date(), error: message })
+  }
+
+  private publish(snapshot: DependencySnapshot): DependencySnapshot {
+    this.snapshot = snapshot
+    this.emit("deps:changed", snapshot)
+    return snapshot
+  }
+}
+
+/** The argv that updates a single package to its latest version. */
+export function updateArgs(manager: PackageManager, name: string): string[] {
+  switch (manager) {
+    case "pnpm":
+      return ["update", "--latest", name]
+    case "npm":
+      return ["install", `${name}@latest`]
+    case "yarn":
+      return ["upgrade", `${name}@latest`]
+    case "bun":
+      return ["update", "--latest", name]
+  }
+}

package/src/devcc/deps/parse.ts

@@ -0,0 +1,210 @@
+import type { PackageManager } from "../utils/packageManager.js"
+
+export type DependencyKind = "dependencies" | "devDependencies" | "peerDependencies" | "optionalDependencies"
+
+/** How far behind a package is, derived from the version strings. */
+export type UpdateSeverity = "major" | "minor" | "patch" | "unknown"
+
+export interface OutdatedPackage {
+  name: string
+  /** Installed version. */
+  current: string
+  /** Highest version allowed by the range in package.json. */
+  wanted: string
+  /** Highest version published. */
+  latest: string
+  kind: DependencyKind
+  severity: UpdateSeverity
+  /** True when `current` already satisfies the range but `latest` is newer. */
+  onlyLatest: boolean
+  deprecated?: boolean
+}
+
+/** Managers whose `outdated` command can emit machine-readable output. */
+export const JSON_CAPABLE_MANAGERS: readonly PackageManager[] = ["pnpm", "npm", "yarn"]
+
+export function supportsOutdatedJson(manager: PackageManager): boolean {
+  return JSON_CAPABLE_MANAGERS.includes(manager)
+}
+
+/** The argv that produces JSON `outdated` output for each manager. */
+export function outdatedArgs(manager: PackageManager): string[] {
+  switch (manager) {
+    case "pnpm":
+      return ["outdated", "--format", "json"]
+    case "npm":
+      return ["outdated", "--json", "--long"]
+    case "yarn":
+      return ["outdated", "--json"]
+    case "bun":
+      return ["outdated"]
+  }
+}
+
+/** Strip range operators and build metadata: `^1.2.3-beta.1` -> `[1, 2, 3]`. */
+export function parseVersion(version: string): [number, number, number] | null {
+  const match = /(\d+)\.(\d+)\.(\d+)/u.exec(version.trim())
+  if (!match) return null
+  return [Number(match[1]), Number(match[2]), Number(match[3])]
+}
+
+/**
+ * Classify the gap between two versions. `unknown` when either side is not a
+ * plain semver triple (git refs, `latest`, workspace protocols).
+ */
+export function severityBetween(current: string, latest: string): UpdateSeverity {
+  const from = parseVersion(current)
+  const to = parseVersion(latest)
+  if (!from || !to) return "unknown"
+  if (to[0] !== from[0]) return "major"
+  if (to[1] !== from[1]) return "minor"
+  if (to[2] !== from[2]) return "patch"
+  return "unknown"
+}
+
+function normaliseKind(value: unknown): DependencyKind {
+  switch (typeof value === "string" ? value.toLowerCase() : "") {
+    case "devdependencies":
+    case "dev":
+      return "devDependencies"
+    case "peerdependencies":
+    case "peer":
+      return "peerDependencies"
+    case "optionaldependencies":
+    case "optional":
+      return "optionalDependencies"
+    default:
+      return "dependencies"
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function buildEntry(
+  name: string,
+  current: string,
+  wanted: string,
+  latest: string,
+  kind: DependencyKind,
+  deprecated?: boolean,
+): OutdatedPackage {
+  return {
+    name,
+    current,
+    wanted,
+    latest,
+    kind,
+    severity: severityBetween(current, latest),
+    onlyLatest: current === wanted && wanted !== latest,
+    deprecated,
+  }
+}
+
+/**
+ * pnpm (`--format json`) and npm (`--json`) both emit an object keyed by package
+ * name; only the field names around it differ slightly.
+ */
+export function parseNpmStyleOutdated(json: unknown): OutdatedPackage[] {
+  const root = asRecord(json)
+  if (!root) return []
+
+  const packages: OutdatedPackage[] = []
+  for (const [name, raw] of Object.entries(root)) {
+    // npm --json can produce an array when a package is present at several paths.
+    const entry = asRecord(Array.isArray(raw) ? raw[0] : raw)
+    if (!entry) continue
+
+    const current = asString(entry.current)
+    const latest = asString(entry.latest)
+    if (!latest) continue
+
+    packages.push(
+      buildEntry(
+        name,
+        current ?? "-",
+        asString(entry.wanted) ?? current ?? "-",
+        latest,
+        normaliseKind(entry.dependencyType ?? entry.type),
+        entry.isDeprecated === true,
+      ),
+    )
+  }
+  return packages
+}
+
+/** yarn classic emits newline-delimited JSON with a `table` payload. */
+export function parseYarnOutdated(output: string): OutdatedPackage[] {
+  for (const line of output.split("\n")) {
+    if (line.trim() === "") continue
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(line)
+    } catch {
+      continue
+    }
+    const record = asRecord(parsed)
+    if (record?.type !== "table") continue
+
+    const body = asRecord(record.data)?.body
+    if (!Array.isArray(body)) continue
+
+    return body
+      .filter((row): row is unknown[] => Array.isArray(row))
+      .map((row) => {
+        const [name, current, wanted, latest, kind] = row.map((cell) =>
+          typeof cell === "string" ? cell : "",
+        )
+        return buildEntry(name ?? "", current ?? "-", wanted ?? "-", latest ?? "-", normaliseKind(kind))
+      })
+      .filter((entry) => entry.name !== "")
+  }
+  return []
+}
+
+/** Dispatch to the right parser for the manager that produced `output`. */
+export function parseOutdated(manager: PackageManager, output: string): OutdatedPackage[] {
+  const trimmed = output.trim()
+  if (trimmed === "") return []
+
+  if (manager === "yarn") return parseYarnOutdated(trimmed)
+
+  try {
+    return parseNpmStyleOutdated(JSON.parse(trimmed))
+  } catch {
+    return []
+  }
+}
+
+const SEVERITY_ORDER: Record<UpdateSeverity, number> = { major: 0, minor: 1, patch: 2, unknown: 3 }
+
+/** Most-significant updates first, then alphabetically. */
+export function sortOutdated(packages: readonly OutdatedPackage[]): OutdatedPackage[] {
+  return [...packages].sort((a, b) => {
+    const bySeverity = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]
+    return bySeverity !== 0 ? bySeverity : a.name.localeCompare(b.name)
+  })
+}
+
+export interface OutdatedSummary {
+  total: number
+  major: number
+  minor: number
+  patch: number
+}
+
+export function summariseOutdated(packages: readonly OutdatedPackage[]): OutdatedSummary {
+  return {
+    total: packages.length,
+    major: packages.filter((entry) => entry.severity === "major").length,
+    minor: packages.filter((entry) => entry.severity === "minor").length,
+    patch: packages.filter((entry) => entry.severity === "patch").length,
+  }
+}