@doriandev/devcc 0.1.2

package/src/devcc/app/builtinCommands.ts

@@ -0,0 +1,429 @@
+import type { CommandConfigEntry } from "../core/config.js"
+import type { CommandContext, CommandDefinition } from "../core/commands.js"
+import { isActive } from "../processes/ManagedProcess.js"
+import { VIEW_IDS } from "../core/state.js"
+import { selectedPackageIndex } from "../views/DependenciesView.js"
+import { errorMessage } from "../utils/errors.js"
+
+/**
+ * The built-in command set.
+ *
+ * Everything the UI can do is registered here (or contributed by config), so
+ * the palette is a complete inventory of the app's capabilities rather than a
+ * subset of them.
+ */
+export function createBuiltinCommands(): CommandDefinition[] {
+  const commands: CommandDefinition[] = []
+
+  // --- Navigation ---------------------------------------------------------
+  for (const view of VIEW_IDS) {
+    commands.push({
+      id: `view.${view}`,
+      title: `Go to ${titleCase(view)}`,
+      category: "Navigation",
+      keywords: ["open", "show", view],
+      execute: (context) => context.navigate(view),
+    })
+  }
+
+  // --- Processes ----------------------------------------------------------
+  commands.push(
+    {
+      id: "process.startAll",
+      title: "Start all managed processes (in dependency order)",
+      category: "Processes",
+      keywords: ["run", "boot", "up", "stack"],
+      execute: async (context) => {
+        const before = context.processes.list().filter((process) => !isActive(process.status)).length
+        if (before === 0) {
+          context.notify("info", "Everything is already running")
+          return
+        }
+        const plan = await context.processes.startAll()
+        const summary = plan.waves.map((wave) => wave.join("+")).join(" → ")
+        context.notify(
+          plan.cycle.length > 0 ? "warn" : "success",
+          `Started ${before} process(es): ${summary}`,
+        )
+      },
+    },
+    {
+      id: "process.stopAll",
+      title: "Stop all managed processes",
+      category: "Processes",
+      keywords: ["kill", "halt", "down"],
+      confirm: {
+        title: "Stop all managed processes?",
+        message: "Every process devcc started will receive SIGTERM, then SIGKILL after the grace period.",
+      },
+      execute: async (context) => {
+        await context.processes.stopAll()
+        context.notify("info", "Stopped all managed processes")
+      },
+    },
+    {
+      id: "process.restartAll",
+      title: "Restart all running processes",
+      category: "Processes",
+      keywords: ["reload", "bounce"],
+      execute: async (context) => {
+        const running = context.processes.list().filter((process) => isActive(process.status))
+        for (const process of running) {
+          try {
+            await context.processes.restart(process.id)
+          } catch (error) {
+            context.notify("error", errorMessage(error))
+          }
+        }
+        context.notify("success", `Restarted ${running.length} process(es)`)
+      },
+    },
+  )
+
+  // --- Git ----------------------------------------------------------------
+  commands.push(
+    {
+      id: "git.refresh",
+      title: "Git: refresh status",
+      category: "Git",
+      shortcut: "r",
+      execute: async (context) => {
+        await context.git.refresh()
+        context.notify("info", "Git status refreshed")
+      },
+    },
+    {
+      id: "git.fetch",
+      title: "Git: fetch",
+      category: "Git",
+      keywords: ["remote", "prune"],
+      execute: async (context) => {
+        context.notify("info", "Fetching…")
+        try {
+          await context.git.fetch()
+          context.notify("success", "Fetched from remote")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "git.pull",
+      title: "Git: pull (fast-forward only)",
+      category: "Git",
+      execute: async (context) => {
+        context.notify("info", "Pulling…")
+        try {
+          await context.git.pull()
+          context.notify("success", "Pulled")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "git.push",
+      title: "Git: push",
+      category: "Git",
+      confirm: {
+        title: "Push to remote?",
+        message: "This publishes your local commits. Make sure the branch is what you expect.",
+      },
+      execute: async (context) => {
+        context.notify("info", "Pushing…")
+        try {
+          await context.git.push()
+          context.notify("success", "Pushed")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "git.stageAll",
+      title: "Git: stage all changes",
+      category: "Git",
+      execute: async (context) => {
+        try {
+          await context.git.stageAll()
+          context.notify("success", "Staged all changes")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "git.commit",
+      title: "Git: commit staged changes",
+      category: "Git",
+      execute: async (context) => {
+        const message = await context.prompt("Commit message", "Describe the change")
+        if (message === null || message.trim() === "") return
+        try {
+          await context.git.commit(message)
+          context.notify("success", "Committed")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+  )
+
+  // --- Docker -------------------------------------------------------------
+  commands.push(
+    {
+      id: "docker.up",
+      title: "Docker: compose up (detached)",
+      category: "Docker",
+      when: (context) => context.services.get("docker") !== undefined,
+      execute: async (context) => {
+        context.notify("info", "docker compose up…")
+        try {
+          await context.services.runAction("docker", "start", { confirm: context.confirm })
+          context.notify("success", "Compose services started")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "docker.stop",
+      title: "Docker: compose stop",
+      category: "Docker",
+      when: (context) => context.services.get("docker") !== undefined,
+      execute: async (context) => {
+        try {
+          await context.services.runAction("docker", "stop", { confirm: context.confirm })
+          context.notify("success", "Compose services stopped")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+    {
+      id: "docker.down",
+      title: "Docker: compose down",
+      category: "Docker",
+      keywords: ["remove", "destroy"],
+      when: (context) => context.services.get("docker") !== undefined,
+      confirm: {
+        title: "docker compose down?",
+        message: "This removes the containers and networks compose created. Volumes are kept.",
+      },
+      execute: async (context) => {
+        const adapter = context.services.getAdapter("docker")
+        if (!adapter || !("down" in adapter)) {
+          context.notify("warn", "Docker adapter unavailable")
+          return
+        }
+        try {
+          // The adapter asks for its own confirmation too; auto-approve the second one.
+          await (adapter as { down(ctx: { confirm: () => Promise<boolean> }): Promise<void> }).down({
+            confirm: async () => true,
+          })
+          context.notify("success", "Compose stack removed")
+        } catch (error) {
+          context.notify("error", errorMessage(error))
+        }
+      },
+    },
+  )
+
+  // --- Dependencies -------------------------------------------------------
+  commands.push(
+    {
+      id: "deps.check",
+      title: "Dependencies: check for updates",
+      category: "Dependencies",
+      shortcut: "r",
+      keywords: ["outdated", "upgrade", "npm", "registry"],
+      execute: async (context) => {
+        context.navigate("dependencies")
+        context.notify("info", "Checking the registry…")
+        const snapshot = await context.deps.check()
+        if (snapshot.error) return
+        context.notify(
+          snapshot.packages.length === 0 ? "success" : "info",
+          snapshot.packages.length === 0
+            ? "All dependencies are up to date"
+            : `${snapshot.packages.length} outdated package(s)`,
+        )
+      },
+    },
+    {
+      id: "deps.updateSelected",
+      title: "Dependencies: update the selected package",
+      category: "Dependencies",
+      keywords: ["upgrade", "bump"],
+      when: (context) => context.store.getState().dependencies.packages.length > 0,
+      execute: async (context) => {
+        const state = context.store.getState()
+        const target = state.dependencies.packages[selectedPackageIndex(state.ui.selection.dependencies)]
+        if (!target) {
+          context.notify("warn", "No package selected")
+          return
+        }
+        await context.updateDependency(target.name, target.latest)
+      },
+    },
+  )
+
+  // --- Projects -----------------------------------------------------------
+  commands.push(
+    {
+      id: "project.next",
+      title: "Next open project",
+      category: "Project",
+      shortcut: "ctrl+o",
+      keywords: ["cycle", "tab", "workspace"],
+      when: (context) => context.openProjects().length > 1,
+      execute: async (context) => {
+        const open = context.openProjects()
+        const index = open.findIndex((entry) => entry.source === "current")
+        const next = open[(index + 1) % open.length]
+        if (next) await context.switchProject(next.path)
+      },
+    },
+    {
+      id: "project.close",
+      title: "Close current project",
+      category: "Project",
+      keywords: ["remove", "exit", "workspace"],
+      when: (context) => context.openProjects().length > 1,
+      execute: async (context) => {
+        await context.closeProject()
+      },
+    },
+  )
+  commands.push({
+    id: "project.switch",
+    title: "Open project…",
+    category: "Project",
+    shortcut: "ctrl+p",
+    keywords: ["open", "workspace", "repo", "cd"],
+    execute: async (context) => {
+      const projects = context.listProjects().filter((entry) => entry.source !== "current")
+      if (projects.length === 0) {
+        context.notify("warn", "No other projects found nearby")
+        return
+      }
+      const answer = await context.prompt("Switch to project", projects[0]?.name ?? "path or name")
+      if (answer === null || answer.trim() === "") return
+
+      const query = answer.trim().toLowerCase()
+      const match =
+        projects.find((entry) => entry.path.toLowerCase() === query) ??
+        projects.find((entry) => entry.name.toLowerCase() === query) ??
+        projects.find((entry) => entry.name.toLowerCase().includes(query))
+
+      if (!match) {
+        context.notify("error", `No project matching "${answer}"`)
+        return
+      }
+      await context.switchProject(match.path)
+    },
+  })
+
+  // --- Logs & app ---------------------------------------------------------
+  commands.push(
+    {
+      id: "logs.clearCurrent",
+      title: "Logs: clear current source",
+      category: "Logs",
+      execute: (context) => {
+        const source = context.store.getState().ui.logSource
+        if (!source) {
+          context.notify("warn", "No log source selected")
+          return
+        }
+        context.logs.clear(source)
+        context.notify("info", "Cleared logs")
+      },
+    },
+    {
+      id: "logs.clearAll",
+      title: "Logs: clear all sources",
+      category: "Logs",
+      confirm: {
+        title: "Clear every log buffer?",
+        message: "Buffered output for all sources will be discarded.",
+      },
+      execute: (context) => {
+        context.logs.clearAll()
+        context.notify("info", "Cleared all logs")
+      },
+    },
+    {
+      id: "app.refresh",
+      title: "Refresh everything",
+      category: "App",
+      keywords: ["reload", "poll"],
+      execute: async (context) => {
+        await Promise.all([context.git.refresh(), context.services.refresh(), context.system.sample()])
+        context.notify("info", "Refreshed")
+      },
+    },
+    {
+      id: "help.manual",
+      title: "Open the manual",
+      category: "App",
+      shortcut: "? / F1 / ctrl+k",
+      keywords: ["help", "docs", "documentation", "keys", "shortcuts", "how", "guide", "readme"],
+      execute: (context) => context.showHelp(),
+    },
+    {
+      id: "app.quit",
+      title: "Quit Dev Command Center",
+      category: "App",
+      shortcut: "q",
+      keywords: ["exit", "close"],
+      execute: (context) => context.quit(),
+    },
+  )
+
+  return commands
+}
+
+/** Turn `package.json` scripts into palette commands. */
+export function createScriptCommands(scripts: readonly { name: string }[]): CommandDefinition[] {
+  return scripts.map((script) => ({
+    id: `script.${script.name}`,
+    title: `Run script: ${script.name}`,
+    category: "Scripts",
+    keywords: ["npm", "run", script.name],
+    execute: async (context: CommandContext) => {
+      await context.runScript(script.name)
+    },
+  }))
+}
+
+/** Turn config-declared commands into palette commands. */
+export function createConfigCommands(
+  entries: readonly CommandConfigEntry[],
+  run: (entry: CommandConfigEntry) => Promise<void>,
+): CommandDefinition[] {
+  return entries.map((entry) => ({
+    id: `config.${entry.id}`,
+    title: entry.title,
+    category: entry.category ?? "Project",
+    keywords: entry.keywords,
+    confirm: resolveConfirm(entry),
+    execute: async () => {
+      await run(entry)
+    },
+  }))
+}
+
+function resolveConfirm(entry: CommandConfigEntry): CommandDefinition["confirm"] {
+  if (entry.confirm === true) {
+    return {
+      title: `Run "${entry.title}"?`,
+      message: `${entry.command} ${(entry.args ?? []).join(" ")}`.trim(),
+    }
+  }
+  return entry.confirm === undefined || entry.confirm === false ? undefined : entry.confirm
+}
+
+function titleCase(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}

package/src/devcc/app/keymap.ts

@@ -0,0 +1,167 @@
+import type { HelpSection } from "../components/HelpOverlay.js"
+import type { ViewId } from "../core/state.js"
+
+/** Global single-key bindings that jump straight to a view. */
+export const VIEW_SHORTCUTS: Readonly<Record<string, ViewId>> = {
+  "1": "overview",
+  "2": "processes",
+  "3": "services",
+  "4": "scripts",
+  "5": "git",
+  "6": "logs",
+  "7": "dependencies",
+  "8": "system",
+  "9": "settings",
+  p: "processes",
+  g: "git",
+  l: "logs",
+  d: "dependencies",
+}
+
+/**
+ * The hint shown next to a section in the sidebar: its number, plus the
+ * mnemonic letter when it has one (`"7 d"`).
+ *
+ * Derived from the bindings above so the rail can never advertise a key that
+ * is not actually bound, or omit one that is.
+ */
+export function shortcutHintFor(view: ViewId): string {
+  const keys = Object.entries(VIEW_SHORTCUTS)
+    .filter(([, target]) => target === view)
+    .map(([key]) => key)
+
+  const digits = keys.filter((key) => /^\d$/u.test(key)).sort()
+  const letters = keys.filter((key) => !/^\d$/u.test(key)).sort()
+  return [...digits, ...letters].join(" ")
+}
+
+/**
+ * The in-app manual (`?`, `F1`, or "Open the manual" in the palette).
+ *
+ * Starts with what each section is for, then the keys, then the config fields
+ * you are most likely to want. Kept next to the bindings it documents so the
+ * two cannot drift apart.
+ */
+export const HELP_SECTIONS: HelpSection[] = [
+  {
+    title: "What each section does",
+    entries: [
+      { keys: "Overview", description: "git, running processes, services and load at a glance" },
+      { keys: "Processes", description: "dev servers devcc launched: start, stop, restart, inspect" },
+      { keys: "Services", description: "things detected on this machine: Docker, databases, Ollama" },
+      { keys: "Scripts", description: "package.json scripts, run through your package manager" },
+      { keys: "Git", description: "branch, changes, commits; stage, commit, pull, push" },
+      { keys: "Logs", description: "output of everything devcc started, per source or merged" },
+      { keys: "Dependencies", description: "outdated packages, checked only when you ask" },
+      { keys: "System", description: "host, toolchain versions, CPU, memory, disk" },
+      { keys: "Settings", description: "detection results, config issues, diagnostics history" },
+    ],
+  },
+  {
+    title: "Getting started",
+    entries: [
+      { keys: ".devcc.ts", description: "declare processes devcc can control (see Config below)" },
+      { keys: "ctrl+p", description: "open another project; the current one keeps running" },
+      { keys: "/", description: "the palette lists everything the app can do" },
+      { keys: ".devcc/devcc.log", description: "internal diagnostics, if something looks wrong" },
+    ],
+  },
+  {
+    title: "Navigation",
+    entries: [
+      { keys: "↑ / k", description: "previous item" },
+      { keys: "↓ / j", description: "next item" },
+      { keys: "← / h", description: "previous section" },
+      { keys: "→", description: "next section" },
+      { keys: "tab / S-tab", description: "cycle sections" },
+      { keys: "1…9", description: "jump to a section" },
+      { keys: "p / g / l / d", description: "processes / git / logs / dependencies" },
+      { keys: "enter", description: "open or activate" },
+      { keys: "esc", description: "close overlay / back" },
+    ],
+  },
+  {
+    title: "Processes & services",
+    entries: [
+      { keys: "s", description: "start or stop the selection" },
+      { keys: "r", description: "restart the selection" },
+      { keys: "i", description: "inspect the selection" },
+      { keys: "d", description: "docker compose down (confirmed)" },
+    ],
+  },
+  {
+    title: "Scripts",
+    entries: [
+      { keys: "enter", description: "run the selected script" },
+      { keys: "x", description: "stop a running script" },
+      { keys: "f", description: "filter the list" },
+      { keys: "c", description: "clear the filter" },
+    ],
+  },
+  {
+    title: "Git",
+    entries: [
+      { keys: "s / u", description: "stage / unstage the selected file" },
+      { keys: "d", description: "discard file changes (confirmed)" },
+      { keys: "c", description: "commit staged changes" },
+      { keys: "p / P", description: "pull / push (push is confirmed)" },
+      { keys: "f", description: "fetch" },
+      { keys: "r", description: "refresh status" },
+    ],
+  },
+  {
+    title: "Logs",
+    entries: [
+      { keys: "j / k", description: "scroll" },
+      { keys: "PgUp / PgDn", description: "page" },
+      { keys: "home / end", description: "jump to start / end" },
+      { keys: "f", description: "toggle follow" },
+      { keys: "s", description: "search (text or regex)" },
+      { keys: "x", description: "clear the search" },
+      { keys: "e", description: "toggle errors only" },
+      { keys: "a", description: "merged stream of all sources" },
+      { keys: "tab / ← →", description: "change log source" },
+      { keys: "c", description: "clear the current buffer" },
+    ],
+  },
+  {
+    title: "Dependencies",
+    entries: [
+      { keys: "r", description: "check the registry for updates" },
+      { keys: "u", description: "update the selected package (confirmed)" },
+    ],
+  },
+  {
+    title: "Projects",
+    entries: [
+      { keys: "ctrl+p", description: "open another project (others stay running)" },
+      { keys: "ctrl+o", description: "cycle through open projects" },
+      { keys: "enter", description: "open the highlighted project" },
+      { keys: "/ close", description: "close the current project (palette)" },
+    ],
+  },
+  {
+    title: "Global",
+    entries: [
+      { keys: "? / F1 / ctrl+k", description: "this manual" },
+      { keys: "/", description: "command palette" },
+      { keys: "ctrl+p / ctrl+o", description: "open / cycle projects" },
+      { keys: "?", description: "this help" },
+      { keys: "R", description: "refresh everything" },
+      { keys: "q / ctrl+c", description: "quit" },
+    ],
+  },
+  {
+    title: "Config quick reference (.devcc.ts)",
+    entries: [
+      { keys: "processes[]", description: "id, name, command, args, cwd, autoStart, url, port" },
+      { keys: "  restartOnCrash", description: "auto-restart with backoff; maxCrashRestarts caps it" },
+      { keys: "  dependsOn", description: "ids that must be ready first (start all / autostart)" },
+      { keys: "  readiness", description: "{ port } or { logPattern }: running means usable" },
+      { keys: "commands[]", description: "id, title, command, args, confirm - shown in the palette" },
+      { keys: "services[]", description: "extra ports to watch: id, name, port, healthPath" },
+      { keys: "projects[]", description: "extra paths offered by the project switcher" },
+      { keys: "refresh", description: "{ system, services, git, clock } intervals in ms" },
+    ],
+  },
+]

package/src/devcc/app/theme.ts

@@ -0,0 +1,83 @@
+import type { ProcessStatus } from "../processes/ManagedProcess.js"
+import type { ServiceState } from "../services/types.js"
+
+/**
+ * One restrained palette for the whole app.
+ *
+ * Colour carries meaning only: state (running/stopped/failed), selection, and a
+ * single accent for headings. Everything else is one of three greys.
+ */
+export const theme = {
+  background: "#0b0f14",
+  panel: "#0f141b",
+  panelAlt: "#131a23",
+  border: "#243040",
+  borderFocus: "#3b6ea5",
+
+  text: "#c6d0da",
+  textDim: "#6b7885",
+  textBright: "#eaf0f6",
+
+  accent: "#6aa9ff",
+  success: "#4cc38a",
+  warning: "#d9a441",
+  danger: "#f2685e",
+  info: "#6aa9ff",
+
+  selectionBackground: "#1d3b63",
+  selectionText: "#ffffff",
+
+  headerBackground: "#131a23",
+  footerBackground: "#131a23",
+} as const
+
+export const glyphs = {
+  running: "●",
+  stopped: "○",
+  starting: "◐",
+  stopping: "◑",
+  failed: "✖",
+  degraded: "◍",
+  unknown: "·",
+  bullet: "•",
+  arrowRight: "›",
+  check: "✓",
+  cross: "✗",
+  warning: "⚠",
+} as const
+
+export interface StatusStyle {
+  glyph: string
+  color: string
+  label: string
+}
+
+export function processStatusStyle(status: ProcessStatus): StatusStyle {
+  switch (status) {
+    case "running":
+      return { glyph: glyphs.running, color: theme.success, label: "running" }
+    case "starting":
+      return { glyph: glyphs.starting, color: theme.warning, label: "starting" }
+    case "stopping":
+      return { glyph: glyphs.stopping, color: theme.warning, label: "stopping" }
+    case "failed":
+      return { glyph: glyphs.failed, color: theme.danger, label: "failed" }
+    case "stopped":
+      return { glyph: glyphs.stopped, color: theme.textDim, label: "stopped" }
+  }
+}
+
+export function serviceStateStyle(state: ServiceState): StatusStyle {
+  switch (state) {
+    case "running":
+      return { glyph: glyphs.running, color: theme.success, label: "running" }
+    case "degraded":
+      return { glyph: glyphs.degraded, color: theme.warning, label: "degraded" }
+    case "stopped":
+      return { glyph: glyphs.stopped, color: theme.textDim, label: "stopped" }
+    case "unavailable":
+      return { glyph: glyphs.cross, color: theme.danger, label: "unavailable" }
+    case "unknown":
+      return { glyph: glyphs.unknown, color: theme.textDim, label: "unknown" }
+  }
+}