@appkit/llamacpp-cli 1.5.0 → 1.6.0

package/src/utils/downsample-utils.ts

@@ -0,0 +1,128 @@
+/**
+ * Downsampling utilities for time-series chart data
+ * Uses time-aligned buckets to ensure stable charts as new data arrives
+ */
+
+export interface TimeSeriesPoint {
+  timestamp: number;
+  value: number;
+}
+
+type AggregationMethod = 'max' | 'mean';
+
+const ONE_HOUR_MS = 60 * 60 * 1000;
+
+/**
+ * Core bucketing logic shared by all downsampling functions.
+ * Uses ABSOLUTE bucket boundaries that never shift, ensuring chart stability.
+ */
+function createTimeBuckets(
+  data: TimeSeriesPoint[],
+  targetPoints: number,
+  startTime: number,
+  endTime: number
+): number[][] {
+  const timeRange = endTime - startTime;
+  const bucketDuration = Math.ceil(timeRange / targetPoints);
+  const alignedStart = Math.floor(startTime / bucketDuration) * bucketDuration;
+  const buckets: number[][] = Array.from({ length: targetPoints }, () => []);
+
+  for (const point of data) {
+    if (point.timestamp < startTime || point.timestamp > endTime) continue;
+    const bucketIndex = Math.floor((point.timestamp - alignedStart) / bucketDuration);
+    if (bucketIndex >= 0 && bucketIndex < targetPoints) {
+      buckets[bucketIndex].push(point.value);
+    }
+  }
+
+  return buckets;
+}
+
+/**
+ * Aggregate bucket values using the specified method.
+ */
+function aggregateBuckets(buckets: number[][], method: AggregationMethod): number[] {
+  return buckets.map(bucket => {
+    const validValues = method === 'max'
+      ? bucket.filter(v => !isNaN(v) && v > 0)
+      : bucket.filter(v => !isNaN(v) && isFinite(v));
+
+    if (validValues.length === 0) return 0;
+
+    if (method === 'max') {
+      return Math.max(...validValues);
+    }
+    return validValues.reduce((sum, v) => sum + v, 0) / validValues.length;
+  });
+}
+
+/**
+ * Downsample using time-aligned bucket max - preserves peaks.
+ * Best for: GPU/CPU usage, token speeds where peaks matter.
+ */
+export function downsampleMaxTime(data: TimeSeriesPoint[], targetPoints: number): number[] {
+  if (data.length === 0) return [];
+  if (data.length <= targetPoints) return data.map(d => d.value);
+
+  const buckets = createTimeBuckets(
+    data,
+    targetPoints,
+    data[0].timestamp,
+    data[data.length - 1].timestamp
+  );
+  return aggregateBuckets(buckets, 'max');
+}
+
+/**
+ * Downsample using time-aligned bucket mean - preserves average trends.
+ * Best for: Memory usage where average is meaningful.
+ */
+export function downsampleMeanTime(data: TimeSeriesPoint[], targetPoints: number): number[] {
+  if (data.length === 0) return [];
+  if (data.length <= targetPoints) return data.map(d => d.value);
+
+  const buckets = createTimeBuckets(
+    data,
+    targetPoints,
+    data[0].timestamp,
+    data[data.length - 1].timestamp
+  );
+  return aggregateBuckets(buckets, 'mean');
+}
+
+/**
+ * Calculate downsampling ratio as a display string.
+ */
+export function getDownsampleRatio(originalCount: number, targetCount: number): string {
+  if (originalCount <= targetCount) return '1:1';
+  const ratio = Math.round(originalCount / targetCount);
+  return `${ratio}:1`;
+}
+
+/**
+ * Downsample with full hour coverage using max aggregation.
+ * Creates buckets for the entire hour (60 minutes), filling gaps with 0.
+ * Best for: Hour view where we want to show the full time range.
+ */
+export function downsampleMaxTimeWithFullHour(data: TimeSeriesPoint[], targetPoints: number): number[] {
+  if (data.length === 0) return Array(targetPoints).fill(0);
+
+  const now = Date.now();
+  const oneHourAgo = now - ONE_HOUR_MS;
+  const buckets = createTimeBuckets(data, targetPoints, oneHourAgo, now);
+  return aggregateBuckets(buckets, 'max');
+}
+
+/**
+ * Downsample with full hour coverage using mean aggregation.
+ * Creates buckets for the entire hour (60 minutes), filling gaps with 0.
+ * Best for: Hour view where we want to show the full time range.
+ */
+export function downsampleMeanTimeWithFullHour(data: TimeSeriesPoint[], targetPoints: number): number[] {
+  if (data.length === 0) return Array(targetPoints).fill(0);
+
+  const now = Date.now();
+  const oneHourAgo = now - ONE_HOUR_MS;
+  const buckets = createTimeBuckets(data, targetPoints, oneHourAgo, now);
+  return aggregateBuckets(buckets, 'mean');
+}

package/src/utils/file-utils.ts

@@ -104,3 +104,43 @@ export function expandHome(filePath: string): string {
   }
   return filePath;
 }
+
+/**
+ * Parse Metal (GPU) memory allocation from llama-server stderr logs
+ * Looks for line: "load_tensors: Metal_Mapped model buffer size = 11120.23 MiB"
+ * Returns memory in MB, or null if not found
+ */
+export async function parseMetalMemoryFromLog(stderrPath: string): Promise<number | null> {
+  try {
+    // Check if log file exists
+    if (!(await fileExists(stderrPath))) {
+      return null;
+    }
+
+    // Open file for reading
+    const fileHandle = await fs.open(stderrPath, 'r');
+
+    try {
+      // Read first 256KB (Metal allocation happens early during model loading)
+      const buffer = Buffer.alloc(256 * 1024);
+      const { bytesRead } = await fileHandle.read(buffer, 0, buffer.length, 0);
+      const content = buffer.toString('utf-8', 0, bytesRead);
+      const lines = content.split('\n');
+
+      // Look for Metal_Mapped buffer size
+      for (const line of lines) {
+        const match = line.match(/Metal_Mapped model buffer size\s*=\s*([\d.]+)\s*MiB/);
+        if (match) {
+          const sizeInMB = parseFloat(match[1]);
+          return isNaN(sizeInMB) ? null : sizeInMB;
+        }
+      }
+
+      return null;
+    } finally {
+      await fileHandle.close();
+    }
+  } catch {
+    return null;
+  }
+}

package/src/utils/process-utils.ts

@@ -220,13 +220,97 @@ export async function getBatchProcessMemory(pids: number[]): Promise<Map<number,
 
 /**
  * Get memory usage for a single process in bytes
- * Uses 'top' on macOS which includes GPU/Metal memory (more accurate for llama-server)
+ * Uses 'top' on macOS which reports CPU memory only (NOT GPU/Metal memory)
  * Returns null if process not found or error occurs
  * Caches results for 3 seconds to prevent spawning too many top processes
  *
+ * Note: For llama-server processes with GPU offloading, use ServerConfig.metalMemoryMB
+ * to get GPU memory allocation (parsed from logs during server startup)
+ *
  * Note: For multiple PIDs, use getBatchProcessMemory() instead - much more efficient
  */
 export async function getProcessMemory(pid: number): Promise<number | null> {
   const result = await getBatchProcessMemory([pid]);
   return result.get(pid) ?? null;
 }
+
+// Process CPU cache to prevent spawning too many 'ps' processes
+// Cache per PID with 3-second TTL
+const processCpuCache = new Map<number, { value: number | null; timestamp: number }>();
+const PROCESS_CPU_CACHE_TTL = 3000; // 3 seconds
+
+/**
+ * Batch get CPU usage for multiple processes in one ps call
+ * Much more efficient than calling getProcessCpu() multiple times
+ * Returns Map<pid, percentage> for all requested PIDs
+ */
+export async function getBatchProcessCpu(pids: number[]): Promise<Map<number, number | null>> {
+  const result = new Map<number, number | null>();
+  const now = Date.now();
+
+  // Check cache and collect PIDs that need fetching
+  const pidsToFetch: number[] = [];
+  for (const pid of pids) {
+    const cached = processCpuCache.get(pid);
+    if (cached && (now - cached.timestamp) < PROCESS_CPU_CACHE_TTL) {
+      result.set(pid, cached.value);
+    } else {
+      pidsToFetch.push(pid);
+    }
+  }
+
+  // If all PIDs were cached, return early
+  if (pidsToFetch.length === 0) {
+    return result;
+  }
+
+  try {
+    // Build ps command with all PIDs: ps -p X,Y,Z -o pid=,%cpu=
+    const pidList = pidsToFetch.join(',');
+    const output = await execCommand(`ps -p ${pidList} -o pid=,%cpu= 2>/dev/null`);
+
+    // Parse output: each line is "PID  %CPU" (e.g., "1438  45.2")
+    const lines = output.split('\n');
+    for (const line of lines) {
+      const match = line.trim().match(/^(\d+)\s+([\d.]+)\s*$/);
+      if (!match) continue;
+
+      const pid = parseInt(match[1], 10);
+      const cpuPercent = parseFloat(match[2]);
+
+      // Cache and store result
+      processCpuCache.set(pid, { value: cpuPercent, timestamp: now });
+      result.set(pid, cpuPercent);
+    }
+
+    // For any PIDs that weren't in the output, cache null (process not running)
+    for (const pid of pidsToFetch) {
+      if (!result.has(pid)) {
+        processCpuCache.set(pid, { value: null, timestamp: now });
+        result.set(pid, null);
+      }
+    }
+
+    return result;
+  } catch {
+    // On error, cache null for all requested PIDs
+    for (const pid of pidsToFetch) {
+      processCpuCache.set(pid, { value: null, timestamp: now });
+      result.set(pid, null);
+    }
+    return result;
+  }
+}
+
+/**
+ * Get CPU usage for a single process as percentage (0-100+)
+ * Uses 'ps -o %cpu' on macOS
+ * Returns null if process not found or error occurs
+ * Caches results for 3 seconds to prevent spawning too many ps processes
+ *
+ * Note: For multiple PIDs, use getBatchProcessCpu() instead - much more efficient
+ */
+export async function getProcessCpu(pid: number): Promise<number | null> {
+  const result = await getBatchProcessCpu([pid]);
+  return result.get(pid) ?? null;
+}

package/test-load.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+
+# Test script for parallel chat requests to multiple llama servers
+# Usage: ./test-load.sh
+# Stop with CTRL-C
+
+set -e
+
+# Available ports
+PORTS=(9001 9002 9004 9005)
+
+# Test prompts with varying complexity
+PROMPTS=(
+  "Write a hello world program in Python"
+  "Explain quantum computing in simple terms"
+  "Write a flappy bird game in Python"
+  "What are the benefits of functional programming?"
+  "Create a REST API example using FastAPI"
+  "Explain the difference between processes and threads"
+  "Write a binary search algorithm in JavaScript"
+  "What is the difference between HTTP and HTTPS?"
+  "Create a simple todo list app in React"
+  "Explain Docker containers to a beginner"
+  "Write a quicksort implementation in C++"
+  "What are the SOLID principles?"
+  "Create a SQL query to find duplicate records"
+  "Explain async/await in JavaScript"
+  "Write a Fibonacci sequence generator in any language"
+)
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+MAGENTA='\033[0;35m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Counter for requests
+REQUEST_COUNT=0
+
+# Function to run a single chat request
+run_chat() {
+  local port=$1
+  local prompt=$2
+  local request_id=$3
+
+  echo -e "${CYAN}[Request #${request_id}]${NC} ${YELLOW}Port ${port}:${NC} ${prompt}"
+
+  # Run the chat request (suppress output except errors)
+  if npm run dev -- server run -m "$prompt" "$port" > /dev/null 2>&1; then
+    echo -e "${CYAN}[Request #${request_id}]${NC} ${GREEN}✓ Completed${NC} (port ${port})"
+  else
+    echo -e "${CYAN}[Request #${request_id}]${NC} ${RED}✗ Failed${NC} (port ${port})"
+  fi
+}
+
+# Trap CTRL-C for clean exit
+trap 'echo -e "\n${YELLOW}Stopping test load script...${NC}"; echo -e "${GREEN}Total requests sent: ${REQUEST_COUNT}${NC}"; exit 0' INT
+
+echo -e "${MAGENTA}========================================${NC}"
+echo -e "${MAGENTA}  Llama Server Load Test${NC}"
+echo -e "${MAGENTA}========================================${NC}"
+echo -e "${BLUE}Ports: ${PORTS[*]}${NC}"
+echo -e "${BLUE}Parallel requests: 3${NC}"
+echo -e "${BLUE}Press CTRL-C to stop${NC}"
+echo -e "${MAGENTA}========================================${NC}\n"
+
+# Function to count running background jobs
+count_running_jobs() {
+  jobs -r | wc -l | tr -d ' '
+}
+
+# Main loop - maintain exactly 3 concurrent requests at all times
+# Start initial 3 requests
+for i in {1..3}; do
+  PORT=${PORTS[$RANDOM % ${#PORTS[@]}]}
+  PROMPT=${PROMPTS[$RANDOM % ${#PROMPTS[@]}]}
+  ((REQUEST_COUNT++))
+  run_chat "$PORT" "$PROMPT" "$REQUEST_COUNT" &
+done
+
+# Continuously monitor and start new requests as old ones complete
+while true; do
+  # Get count of running background jobs
+  RUNNING=$(count_running_jobs)
+
+  # Start new requests to maintain 3 concurrent
+  while [ "$RUNNING" -lt 3 ]; do
+    PORT=${PORTS[$RANDOM % ${#PORTS[@]}]}
+    PROMPT=${PROMPTS[$RANDOM % ${#PROMPTS[@]}]}
+    ((REQUEST_COUNT++))
+    run_chat "$PORT" "$PROMPT" "$REQUEST_COUNT" &
+    RUNNING=$(count_running_jobs)
+  done
+
+  # Small sleep to avoid busy-waiting
+  sleep 0.5
+done

package/dist/tui/components/ErrorState.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-interface ErrorStateProps {
-    error: string;
-    onRetry: () => void;
-}
-export declare function ErrorState({ error, onRetry }: ErrorStateProps): React.JSX.Element;
-export {};
-//# sourceMappingURL=ErrorState.d.ts.map

package/dist/tui/components/ErrorState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ErrorState.d.ts","sourceRoot":"","sources":["../../../src/tui/components/ErrorState.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,eAAe,qBAsB7D"}

package/dist/tui/components/ErrorState.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorState = ErrorState;
-const react_1 = __importDefault(require("react"));
-const ink_1 = require("ink");
-function ErrorState({ error, onRetry }) {
-    return (react_1.default.createElement(ink_1.Box, { flexDirection: "column", padding: 2, borderStyle: "round", borderColor: "red" },
-        react_1.default.createElement(ink_1.Box, null,
-            react_1.default.createElement(ink_1.Text, { bold: true, color: "red" }, "\u26A0\uFE0F  Connection Error")),
-        react_1.default.createElement(ink_1.Box, { marginTop: 1 },
-            react_1.default.createElement(ink_1.Text, null, error)),
-        react_1.default.createElement(ink_1.Box, { marginTop: 2 },
-            react_1.default.createElement(ink_1.Text, { dimColor: true }, "Press "),
-            react_1.default.createElement(ink_1.Text, { bold: true }, "[R]"),
-            react_1.default.createElement(ink_1.Text, { dimColor: true }, " to retry or "),
-            react_1.default.createElement(ink_1.Text, { bold: true }, "[Q]"),
-            react_1.default.createElement(ink_1.Text, { dimColor: true }, " to quit"))));
-}
-//# sourceMappingURL=ErrorState.js.map

package/dist/tui/components/ErrorState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ErrorState.js","sourceRoot":"","sources":["../../../src/tui/components/ErrorState.tsx"],"names":[],"mappings":";;;;;AAQA,gCAsBC;AA9BD,kDAA0B;AAC1B,6BAAgC;AAOhC,SAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,OAAO,EAAmB;IAC5D,OAAO,CACL,8BAAC,SAAG,IAAC,aAAa,EAAC,QAAQ,EAAC,OAAO,EAAE,CAAC,EAAE,WAAW,EAAC,OAAO,EAAC,WAAW,EAAC,KAAK;QAC3E,8BAAC,SAAG;YACF,8BAAC,UAAI,IAAC,IAAI,QAAC,KAAK,EAAC,KAAK,qCAEf,CACH;QAEN,8BAAC,SAAG,IAAC,SAAS,EAAE,CAAC;YACf,8BAAC,UAAI,QAAE,KAAK,CAAQ,CAChB;QAEN,8BAAC,SAAG,IAAC,SAAS,EAAE,CAAC;YACf,8BAAC,UAAI,IAAC,QAAQ,mBAAc;YAC5B,8BAAC,UAAI,IAAC,IAAI,gBAAW;YACrB,8BAAC,UAAI,IAAC,QAAQ,0BAAqB;YACnC,8BAAC,UAAI,IAAC,IAAI,gBAAW;YACrB,8BAAC,UAAI,IAAC,QAAQ,qBAAgB,CAC1B,CACF,CACP,CAAC;AACJ,CAAC"}

package/dist/tui/components/LoadingState.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-interface LoadingStateProps {
-    message?: string;
-    progress?: number;
-}
-export declare function LoadingState({ message, progress }: LoadingStateProps): React.JSX.Element;
-export {};
-//# sourceMappingURL=LoadingState.d.ts.map

package/dist/tui/components/LoadingState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoadingState.d.ts","sourceRoot":"","sources":["../../../src/tui/components/LoadingState.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,YAAY,CAAC,EAAE,OAAsB,EAAE,QAAQ,EAAE,EAAE,iBAAiB,qBAanF"}

package/dist/tui/components/LoadingState.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadingState = LoadingState;
-const react_1 = __importDefault(require("react"));
-const ink_1 = require("ink");
-function LoadingState({ message = 'Loading...', progress }) {
-    return (react_1.default.createElement(ink_1.Box, { flexDirection: "column", padding: 2 },
-        react_1.default.createElement(ink_1.Box, null,
-            react_1.default.createElement(ink_1.Text, { color: "cyan" },
-                "\u23F3 ",
-                message)),
-        progress !== undefined && (react_1.default.createElement(ink_1.Box, { marginTop: 1 },
-            react_1.default.createElement(ink_1.Text, { dimColor: true },
-                "Progress: ",
-                Math.round(progress),
-                "%")))));
-}
-//# sourceMappingURL=LoadingState.js.map

package/dist/tui/components/LoadingState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoadingState.js","sourceRoot":"","sources":["../../../src/tui/components/LoadingState.tsx"],"names":[],"mappings":";;;;;AAQA,oCAaC;AArBD,kDAA0B;AAC1B,6BAAgC;AAOhC,SAAgB,YAAY,CAAC,EAAE,OAAO,GAAG,YAAY,EAAE,QAAQ,EAAqB;IAClF,OAAO,CACL,8BAAC,SAAG,IAAC,aAAa,EAAC,QAAQ,EAAC,OAAO,EAAE,CAAC;QACpC,8BAAC,SAAG;YACF,8BAAC,UAAI,IAAC,KAAK,EAAC,MAAM;;gBAAI,OAAO,CAAQ,CACjC;QACL,QAAQ,KAAK,SAAS,IAAI,CACzB,8BAAC,SAAG,IAAC,SAAS,EAAE,CAAC;YACf,8BAAC,UAAI,IAAC,QAAQ;;gBAAY,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;oBAAS,CACnD,CACP,CACG,CACP,CAAC;AACJ,CAAC"}