pi-observability 1.0.0 → 1.3.0

package/extensions/lib/settings/types.ts

@@ -0,0 +1,40 @@
+export type SegmentKey =
+  | "modelThink"
+  | "runtime"
+  | "pwd"
+  | "git"
+  | "contextUsage"
+  | "contextProgress"
+  | "contextPercentage"
+  | "contextNumbers"
+  | "tokens"
+  | "tps"
+  | "cost";
+
+export type PresetName = "minimal" | "standard" | "verbose" | "performance";
+
+export interface SettingsConfig {
+  version: number;
+  preset: PresetName;
+  segments: Record<SegmentKey, boolean>;
+  contextZones: { expert: number; warning: number };
+}
+
+export interface SettingsListItem {
+  id: string;
+  label: string;
+  description: string;
+  currentValue: string;
+  values: string[];
+}
+
+export interface SettingsUpdateResult {
+  config: SettingsConfig;
+  derivedUpdates: Array<{ id: string; value: string }>;
+}
+
+export interface SegmentMetadata {
+  id: SegmentKey;
+  label: string;
+  description: string;
+}

package/extensions/lib/storage/file-backend.ts

@@ -0,0 +1,62 @@
+import { mkdir, readFile, rename, writeFile, appendFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { RawBackend } from "./types.js";
+
+export interface FileBackendOptions {
+  dir: string;
+}
+
+export function createFileBackend(options: FileBackendOptions): RawBackend {
+  const { dir } = options;
+  let ensured = false;
+
+  async function ensureDir() {
+    if (ensured) return;
+    await mkdir(dir, { recursive: true });
+    ensured = true;
+  }
+
+  function pathFor(name: string): string {
+    return join(dir, name);
+  }
+
+  return {
+    async read(name) {
+      try {
+        return await readFile(pathFor(name), "utf8");
+      } catch {
+        return undefined;
+      }
+    },
+
+    async write(name, content) {
+      await ensureDir();
+      const target = pathFor(name);
+      const temp = `${target}.tmp`;
+      await writeFile(temp, content, "utf8");
+      await rename(temp, target);
+    },
+
+    async append(name, line) {
+      await ensureDir();
+      await appendFile(pathFor(name), `${line}\n`, "utf8");
+    },
+
+    async readLines(name, options) {
+      const text = await this.read(name);
+      if (!text) return [];
+      const lines = text.split("\n").filter((l) => l.trim());
+      if (options?.last !== undefined && options.last > 0) {
+        return lines.slice(-options.last);
+      }
+      return lines;
+    },
+
+    async trimLines(name, keepLast) {
+      const lines = await this.readLines(name);
+      if (lines.length <= keepLast) return;
+      const kept = lines.slice(-keepLast);
+      await this.write(name, kept.map((l) => `${l}\n`).join(""));
+    },
+  };
+}

package/extensions/lib/storage/index.ts

@@ -0,0 +1,33 @@
+export { createJsonStore } from "./json-store.js";
+export { createJsonlStore } from "./jsonl-store.js";
+export { createFileBackend, type FileBackendOptions } from "./file-backend.js";
+export { createMemoryBackend } from "./memory-backend.js";
+export type { JsonStore, JsonlStore, Storage, RawBackend } from "./types.js";
+
+import { createJsonStore } from "./json-store.js";
+import { createJsonlStore } from "./jsonl-store.js";
+import type { Storage, RawBackend } from "./types.js";
+
+export function createStorage(backend: RawBackend): Storage {
+  return {
+    json<T>(name: string, options?: { defaults?: T }) {
+      return createJsonStore(backend, name, options);
+    },
+    jsonl(name: string) {
+      return createJsonlStore(backend, name);
+    },
+  };
+}
+
+import { createFileBackend } from "./file-backend.js";
+import { createMemoryBackend } from "./memory-backend.js";
+
+export function createFileStorage(options: { dir: string }): Storage {
+  const backend = createFileBackend(options);
+  return createStorage(backend);
+}
+
+export function createMemoryStorage(): Storage {
+  const backend = createMemoryBackend();
+  return createStorage(backend);
+}

package/extensions/lib/storage/json-store.ts

@@ -0,0 +1,32 @@
+import type { JsonStore, RawBackend } from "./types.js";
+
+export function createJsonStore<T>(
+  backend: RawBackend,
+  name: string,
+  options?: { defaults?: T },
+): JsonStore<T> {
+  const fileName = `${name}.json`;
+  const defaults = options?.defaults;
+
+  return {
+    async load(): Promise<T> {
+      const text = await backend.read(fileName);
+      if (text === undefined) {
+        if (defaults !== undefined) return defaults;
+        throw new Error(`Missing file and no defaults for ${fileName}`);
+      }
+      try {
+        return JSON.parse(text) as T;
+      } catch (err) {
+        console.error(`[storage] corrupt JSON in ${fileName}, using defaults:`, err);
+        if (defaults !== undefined) return defaults;
+        throw err;
+      }
+    },
+
+    async save(value: T): Promise<void> {
+      const text = JSON.stringify(value, null, 2);
+      await backend.write(fileName, text);
+    },
+  };
+}

package/extensions/lib/storage/jsonl-store.ts

@@ -0,0 +1,29 @@
+import type { JsonlStore, RawBackend } from "./types.js";
+
+export function createJsonlStore<T>(backend: RawBackend, name: string): JsonlStore<T> {
+  const fileName = `${name}.jsonl`;
+
+  return {
+    async append(value: T): Promise<void> {
+      const line = JSON.stringify(value);
+      await backend.append(fileName, line);
+    },
+
+    async read(options?: { last?: number }): Promise<T[]> {
+      const lines = await backend.readLines(fileName, options);
+      const results: T[] = [];
+      for (const line of lines) {
+        try {
+          results.push(JSON.parse(line) as T);
+        } catch (err) {
+          console.error(`[storage] corrupt JSONL line in ${fileName}, skipping:`, err);
+        }
+      }
+      return results;
+    },
+
+    async trim(options: { keepLast: number }): Promise<void> {
+      await backend.trimLines(fileName, options.keepLast);
+    },
+  };
+}

package/extensions/lib/storage/memory-backend.ts

@@ -0,0 +1,37 @@
+import type { RawBackend } from "./types.js";
+
+export function createMemoryBackend(initial?: Map<string, string>): RawBackend {
+  const store = initial ?? new Map<string, string>();
+
+  return {
+    async read(name) {
+      return store.get(name);
+    },
+
+    async write(name, content) {
+      store.set(name, content);
+    },
+
+    async append(name, line) {
+      const existing = store.get(name) ?? "";
+      store.set(name, `${existing}${line}\n`);
+    },
+
+    async readLines(name, options) {
+      const text = store.get(name);
+      if (!text) return [];
+      const lines = text.split("\n").filter((l) => l.trim());
+      if (options?.last !== undefined && options.last > 0) {
+        return lines.slice(-options.last);
+      }
+      return lines;
+    },
+
+    async trimLines(name, keepLast) {
+      const lines = await this.readLines(name);
+      if (lines.length <= keepLast) return;
+      const kept = lines.slice(-keepLast);
+      store.set(name, kept.map((l) => `${l}\n`).join(""));
+    },
+  };
+}

package/extensions/lib/storage/types.ts

@@ -0,0 +1,23 @@
+export interface JsonStore<T> {
+  load(): Promise<T>;
+  save(value: T): Promise<void>;
+}
+
+export interface JsonlStore<T> {
+  append(value: T): Promise<void>;
+  read(options?: { last?: number }): Promise<T[]>;
+  trim(options: { keepLast: number }): Promise<void>;
+}
+
+export interface Storage {
+  json<T>(name: string, options?: { defaults?: T }): JsonStore<T>;
+  jsonl<T>(name: string): JsonlStore<T>;
+}
+
+export interface RawBackend {
+  read(name: string): Promise<string | undefined>;
+  write(name: string, content: string): Promise<void>;
+  append(name: string, line: string): Promise<void>;
+  readLines(name: string, options?: { last?: number }): Promise<string[]>;
+  trimLines(name: string, keepLast: number): Promise<void>;
+}