procm-cli 0.0.1

package/lib.test.ts

@@ -0,0 +1,258 @@
+import { test, expect, describe } from "bun:test"
+import {
+  parseProcessLine,
+  pad,
+  rpad,
+  cpuColor,
+  memColor,
+  statLabel,
+  statColor,
+  sortProcs,
+  sortFields,
+  c,
+  type Process,
+} from "./lib"
+
+// ── parseProcessLine ────────────────────────────────────────────────────────────
+
+describe("parseProcessLine", () => {
+  test("parses a valid ps output line", () => {
+    const line = "  123     1   2.3  0.5 Ss   ??  Thu Feb 20 14:30:00 2026 /usr/sbin/syslogd"
+    const p = parseProcessLine(line)
+    expect(p).toEqual({
+      pid: 123,
+      ppid: 1,
+      cpu: 2.3,
+      mem: 0.5,
+      stat: "Ss",
+      tty: "??",
+      command: "/usr/sbin/syslogd",
+    })
+  })
+
+  test("parses command with spaces", () => {
+    const line = "  200     1   0.0  0.1 Ss   ??  Thu Feb 20 14:30:00 2026 /usr/bin/some command with spaces"
+    const p = parseProcessLine(line)
+    expect(p).not.toBeNull()
+    expect(p!.command).toBe("/usr/bin/some command with spaces")
+  })
+
+  test("skips header line", () => {
+    const line = "  PID  PPID  %CPU %MEM STAT TT       LSTART                    COMMAND"
+    expect(parseProcessLine(line)).toBeNull()
+  })
+
+  test("skips empty lines", () => {
+    expect(parseProcessLine("")).toBeNull()
+  })
+
+  test("includes processes with tty=??", () => {
+    const line = "  300     1   1.0  0.2 R+   ??  Thu Feb 20 14:30:00 2026 /usr/bin/daemon"
+    const p = parseProcessLine(line)
+    expect(p).not.toBeNull()
+    expect(p!.pid).toBe(300)
+  })
+
+  test("includes sleeping process with a TTY", () => {
+    const line = "  400     1   0.0  0.1 S    ttys000  Thu Feb 20 14:30:00 2026 /bin/zsh"
+    const p = parseProcessLine(line)
+    expect(p).not.toBeNull()
+    expect(p!.pid).toBe(400)
+  })
+
+  test("excludes running process with a TTY", () => {
+    const line = "  500     1   5.2  1.3 R+   ttys000  Thu Feb 20 14:30:00 2026 vim test.txt"
+    expect(parseProcessLine(line)).toBeNull()
+  })
+})
+
+// ── pad / rpad ──────────────────────────────────────────────────────────────────
+
+describe("pad", () => {
+  test("right-pads short string", () => {
+    expect(pad("foo", 10)).toBe("foo       ")
+  })
+
+  test("truncates long string with ~", () => {
+    expect(pad("very long string", 5)).toBe("very~")
+  })
+
+  test("returns exact length string unchanged", () => {
+    expect(pad("hello", 5)).toBe("hello")
+  })
+})
+
+describe("rpad", () => {
+  test("left-pads short string", () => {
+    expect(rpad("42", 7)).toBe("     42")
+  })
+
+  test("truncates long string with ~", () => {
+    expect(rpad("very long string", 5)).toBe("very~")
+  })
+
+  test("returns exact length string unchanged", () => {
+    expect(rpad("hello", 5)).toBe("hello")
+  })
+})
+
+// ── cpuColor / memColor ─────────────────────────────────────────────────────────
+
+describe("cpuColor", () => {
+  test(">50 returns red", () => {
+    expect(cpuColor(51)).toBe(c.red)
+  })
+
+  test(">20 returns orange", () => {
+    expect(cpuColor(21)).toBe(c.orange)
+  })
+
+  test(">5 returns yellow", () => {
+    expect(cpuColor(6)).toBe(c.yellow)
+  })
+
+  test("<=5 returns green", () => {
+    expect(cpuColor(5)).toBe(c.green)
+    expect(cpuColor(0)).toBe(c.green)
+  })
+})
+
+describe("memColor", () => {
+  test(">30 returns red", () => {
+    expect(memColor(31)).toBe(c.red)
+  })
+
+  test(">10 returns orange", () => {
+    expect(memColor(11)).toBe(c.orange)
+  })
+
+  test(">3 returns yellow", () => {
+    expect(memColor(4)).toBe(c.yellow)
+  })
+
+  test("<=3 returns green", () => {
+    expect(memColor(3)).toBe(c.green)
+    expect(memColor(0)).toBe(c.green)
+  })
+})
+
+// ── statLabel / statColor ───────────────────────────────────────────────────────
+
+describe("statLabel", () => {
+  test("R+ → Running", () => {
+    expect(statLabel("R+")).toBe("Running")
+  })
+
+  test("Ss → Sleeping", () => {
+    expect(statLabel("Ss")).toBe("Sleeping")
+  })
+
+  test("D → Disk", () => {
+    expect(statLabel("D")).toBe("Disk")
+  })
+
+  test("T → Stopped", () => {
+    expect(statLabel("T")).toBe("Stopped")
+  })
+
+  test("Z → Zombie", () => {
+    expect(statLabel("Z")).toBe("Zombie")
+  })
+
+  test("I → Idle", () => {
+    expect(statLabel("I")).toBe("Idle")
+  })
+
+  test("unknown status returns raw string", () => {
+    expect(statLabel("X+")).toBe("X+")
+  })
+})
+
+describe("statColor", () => {
+  test("R → green", () => {
+    expect(statColor("R+")).toBe(c.green)
+  })
+
+  test("T → yellow", () => {
+    expect(statColor("T")).toBe(c.yellow)
+  })
+
+  test("Z → red", () => {
+    expect(statColor("Z")).toBe(c.red)
+  })
+
+  test("D → orange", () => {
+    expect(statColor("D")).toBe(c.orange)
+  })
+
+  test("S → dim (default)", () => {
+    expect(statColor("Ss")).toBe(c.dim)
+  })
+})
+
+// ── sortProcs ───────────────────────────────────────────────────────────────────
+
+function makeProc(overrides: Partial<Process> = {}): Process {
+  return {
+    pid: 1,
+    ppid: 0,
+    cpu: 0,
+    mem: 0,
+    stat: "Ss",
+    tty: "??",
+    command: "/bin/test",
+    ...overrides,
+  }
+}
+
+describe("sortProcs", () => {
+  test("sorts by CPU descending (default)", () => {
+    const procs = [
+      makeProc({ pid: 1, cpu: 5 }),
+      makeProc({ pid: 2, cpu: 50 }),
+      makeProc({ pid: 3, cpu: 20 }),
+    ]
+    const sorted = sortProcs(procs, "cpu", false)
+    expect(sorted.map((p) => p.cpu)).toEqual([50, 20, 5])
+  })
+
+  test("sorts by PID ascending", () => {
+    const procs = [
+      makeProc({ pid: 300 }),
+      makeProc({ pid: 100 }),
+      makeProc({ pid: 200 }),
+    ]
+    const sorted = sortProcs(procs, "pid", true)
+    expect(sorted.map((p) => p.pid)).toEqual([100, 200, 300])
+  })
+
+  test("sorts by command alphabetically ascending", () => {
+    const procs = [
+      makeProc({ command: "zsh" }),
+      makeProc({ command: "bash" }),
+      makeProc({ command: "fish" }),
+    ]
+    const sorted = sortProcs(procs, "command", true)
+    expect(sorted.map((p) => p.command)).toEqual(["bash", "fish", "zsh"])
+  })
+
+  test("flipping sort direction reverses order", () => {
+    const procs = [
+      makeProc({ pid: 1, cpu: 5 }),
+      makeProc({ pid: 2, cpu: 50 }),
+      makeProc({ pid: 3, cpu: 20 }),
+    ]
+    const asc = sortProcs([...procs], "cpu", true)
+    const desc = sortProcs([...procs], "cpu", false)
+    expect(asc.map((p) => p.cpu)).toEqual([5, 20, 50])
+    expect(desc.map((p) => p.cpu)).toEqual([50, 20, 5])
+  })
+})
+
+// ── sortFields ──────────────────────────────────────────────────────────────────
+
+describe("sortFields", () => {
+  test("contains all expected fields", () => {
+    expect(sortFields).toEqual(["pid", "cpu", "mem", "status", "command"])
+  })
+})

package/lib.ts

@@ -0,0 +1,122 @@
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface Process {
+  pid: number
+  ppid: number
+  cpu: number
+  mem: number
+  stat: string
+  tty: string
+  command: string
+}
+
+// ── Process data ───────────────────────────────────────────────────────────────
+
+export const PS_REGEX =
+  /^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(\S+)\s+\w+\s+\w+\s+\d+\s+[\d:]+\s+\d+\s+(.+)$/
+
+export function parseProcessLine(line: string): Process | null {
+  if (line.length === 0) return null
+  const m = PS_REGEX.exec(line)
+  if (!m) return null
+
+  const stat = m[5]
+  const tty = m[6]
+  // Daemon filter: no TTY or sleeping/idle
+  const ch0 = stat.charCodeAt(0)
+  if (tty !== "??" && ch0 !== 83 && ch0 !== 115 && ch0 !== 73) return null // S=83,s=115,I=73
+
+  return {
+    pid: +m[1],
+    ppid: +m[2],
+    cpu: +m[3],
+    mem: +m[4],
+    stat,
+    tty,
+    command: m[7],
+  }
+}
+
+// ── Colors ─────────────────────────────────────────────────────────────────────
+
+export const c = {
+  bg: "#1a1b26",
+  bgAlt: "#24283b",
+  bgHl: "#364a82",
+  border: "#565f89",
+  text: "#c0caf5",
+  dim: "#565f89",
+  muted: "#a9b1d6",
+  green: "#9ece6a",
+  red: "#f7768e",
+  yellow: "#e0af68",
+  blue: "#7aa2f7",
+  cyan: "#7dcfff",
+  magenta: "#bb9af7",
+  orange: "#ff9e64",
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+export function pad(s: string, n: number) {
+  return s.length > n ? s.slice(0, n - 1) + "~" : s.padEnd(n)
+}
+
+export function rpad(s: string, n: number) {
+  return s.length > n ? s.slice(0, n - 1) + "~" : s.padStart(n)
+}
+
+export function cpuColor(v: number) {
+  if (v > 50) return c.red
+  if (v > 20) return c.orange
+  if (v > 5) return c.yellow
+  return c.green
+}
+
+export function memColor(v: number) {
+  if (v > 30) return c.red
+  if (v > 10) return c.orange
+  if (v > 3) return c.yellow
+  return c.green
+}
+
+export function statLabel(s: string) {
+  switch (s.charCodeAt(0)) {
+    case 82: return "Running"  // R
+    case 83: return "Sleeping" // S
+    case 68: return "Disk"     // D
+    case 84: return "Stopped"  // T
+    case 90: return "Zombie"   // Z
+    case 73: return "Idle"     // I
+    default: return s
+  }
+}
+
+export function statColor(s: string) {
+  switch (s.charCodeAt(0)) {
+    case 82: return c.green   // R
+    case 84: return c.yellow  // T
+    case 90: return c.red     // Z
+    case 68: return c.orange  // D
+    default: return c.dim
+  }
+}
+
+// ── Sort ────────────────────────────────────────────────────────────────────────
+
+export type SortField = "pid" | "cpu" | "mem" | "status" | "command"
+export const sortFields: SortField[] = ["pid", "cpu", "mem", "status", "command"]
+
+export function sortProcs(procs: Process[], sortBy: SortField, sortAsc: boolean) {
+  return procs.sort((a, b) => {
+    let v = 0
+    switch (sortBy) {
+      case "pid":     v = a.pid - b.pid; break
+      case "cpu":     v = a.cpu - b.cpu; break
+      case "mem":     v = a.mem - b.mem; break
+      case "status":  v = a.stat.localeCompare(b.stat); break
+      case "command": v = a.command.localeCompare(b.command); break
+    }
+    return sortAsc ? v : -v
+  })
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "procm-cli",
+  "version": "0.0.1",
+  "description": "Terminal process manager with sorting, filtering, and kill/restart",
+  "module": "index.ts",
+  "type": "module",
+  "bin": {
+    "procm": "./index.ts"
+  },
+  "scripts": {
+    "start": "bun index.ts"
+  },
+  "keywords": [
+    "process",
+    "manager",
+    "tui",
+    "terminal",
+    "cli",
+    "daemon"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.80"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}