@ashwin-pc/pi-web 0.1.2

package/server/settings.ts

@@ -0,0 +1,155 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export type PiWebModelSetting = {
+  provider: string;
+  id: string;
+};
+
+export type PiWebSettings = {
+  version: 1;
+  appearance: {
+    density: "comfortable" | "compact";
+  };
+  composer: {
+    queueMode: "steer" | "followUp";
+    expanded: boolean;
+  };
+  defaults: {
+    model?: PiWebModelSetting;
+    thinkingLevel?: string;
+  };
+};
+
+export type PiWebSettingsPatch = Partial<{
+  appearance: Partial<{
+    density: unknown;
+  }>;
+  composer: Partial<{
+    queueMode: unknown;
+    expanded: unknown;
+  }>;
+  defaults: Partial<{
+    model: unknown;
+    thinkingLevel: unknown;
+  }>;
+}>;
+
+export const defaultPiWebSettings: PiWebSettings = {
+  version: 1,
+  appearance: {
+    density: "comfortable",
+  },
+  composer: {
+    queueMode: "steer",
+    expanded: false,
+  },
+  defaults: {},
+};
+
+function cloneSettings(value: PiWebSettings): PiWebSettings {
+  return JSON.parse(JSON.stringify(value)) as PiWebSettings;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeModel(value: unknown) {
+  if (!isRecord(value)) return undefined;
+  const provider = typeof value.provider === "string" ? value.provider.trim() : "";
+  const id = typeof value.id === "string" ? value.id.trim() : "";
+  return provider && id ? { provider, id } : undefined;
+}
+
+export function normalizeSettings(value: unknown): PiWebSettings {
+  const settings = cloneSettings(defaultPiWebSettings);
+  if (!isRecord(value)) return settings;
+
+  const appearance = isRecord(value.appearance) ? value.appearance : undefined;
+  if (appearance?.density === "compact" || appearance?.density === "comfortable") {
+    settings.appearance.density = appearance.density;
+  }
+
+  const composer = isRecord(value.composer) ? value.composer : undefined;
+  if (composer?.queueMode === "followUp" || composer?.queueMode === "steer") {
+    settings.composer.queueMode = composer.queueMode;
+  }
+  if (typeof composer?.expanded === "boolean") settings.composer.expanded = composer.expanded;
+
+  const defaults = isRecord(value.defaults) ? value.defaults : undefined;
+  const model = normalizeModel(defaults?.model);
+  if (model) settings.defaults.model = model;
+  if (typeof defaults?.thinkingLevel === "string" && defaults.thinkingLevel.trim()) {
+    settings.defaults.thinkingLevel = defaults.thinkingLevel.trim();
+  }
+
+  return settings;
+}
+
+export function applySettingsPatch(current: PiWebSettings, patch: unknown): PiWebSettings {
+  if (!isRecord(patch)) return cloneSettings(current);
+  const next = cloneSettings(current);
+
+  if (isRecord(patch.appearance)) {
+    if (patch.appearance.density === "comfortable" || patch.appearance.density === "compact") {
+      next.appearance.density = patch.appearance.density;
+    }
+  }
+
+  if (isRecord(patch.composer)) {
+    if (patch.composer.queueMode === "steer" || patch.composer.queueMode === "followUp") {
+      next.composer.queueMode = patch.composer.queueMode;
+    }
+    if (typeof patch.composer.expanded === "boolean") next.composer.expanded = patch.composer.expanded;
+  }
+
+  if (isRecord(patch.defaults)) {
+    if ("model" in patch.defaults) {
+      const model = normalizeModel(patch.defaults.model);
+      if (model) next.defaults.model = model;
+      else delete next.defaults.model;
+    }
+    if ("thinkingLevel" in patch.defaults) {
+      if (typeof patch.defaults.thinkingLevel === "string" && patch.defaults.thinkingLevel.trim()) {
+        next.defaults.thinkingLevel = patch.defaults.thinkingLevel.trim();
+      } else {
+        delete next.defaults.thinkingLevel;
+      }
+    }
+  }
+
+  return normalizeSettings(next);
+}
+
+export function createSettingsStore(file: string) {
+  let cached: PiWebSettings | undefined;
+
+  async function read() {
+    if (cached) return cloneSettings(cached);
+    try {
+      cached = normalizeSettings(JSON.parse(await readFile(file, "utf-8")));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        console.warn(`Could not read pi-web settings at ${file}:`, error);
+      }
+      cached = cloneSettings(defaultPiWebSettings);
+    }
+    return cloneSettings(cached);
+  }
+
+  async function write(settings: PiWebSettings) {
+    cached = normalizeSettings(settings);
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(cached, null, 2)}\n`, "utf-8");
+    await rename(tmp, file);
+    return cloneSettings(cached);
+  }
+
+  async function patch(value: unknown) {
+    return write(applySettingsPatch(await read(), value));
+  }
+
+  return { file, read, write, patch };
+}

package/server/types.ts

@@ -0,0 +1,76 @@
+export interface PiWebModel {
+  provider: string;
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+}
+
+export interface PiWebSession {
+  sessionId: string;
+  sessionFile: string;
+  isStreaming: boolean;
+  isCompacting?: boolean;
+  pendingMessageCount?: number;
+  model: PiWebModel;
+  thinkingLevel: string;
+  messages: unknown[];
+  agent: { state: { messages: unknown[] } };
+  sessionName?: string;
+  sessionManager: {
+    newSession(): void;
+    setSessionFile?(path: string): void;
+    buildSessionContext(): { messages: unknown[] };
+    getSessionName?(): string | undefined;
+    getSessionDir?(): string;
+    getLeafId?(): string | null;
+    getEntry?(id: string): unknown;
+    getBranch?(fromId?: string): unknown[];
+    getTree?(): unknown[];
+    getLabel?(id: string): string | undefined;
+    branch?(entryId: string): void;
+    resetLeaf?(): void;
+    appendLabelChange?(targetId: string, label: string | undefined): string;
+  };
+  modelRegistry: {
+    getAvailable(): PiWebModel[];
+    find(provider: string, id: string): PiWebModel | undefined;
+  };
+  extensionRunner?: {
+    getRegisteredCommands?(): unknown[];
+  };
+  promptTemplates?: unknown[];
+  resourceLoader?: {
+    getPrompts?(): { prompts: unknown[] };
+    getSkills?(): { skills: unknown[] };
+  };
+  bindExtensions?(bindings: unknown): Promise<void>;
+  getAvailableThinkingLevels(): string[];
+  getSessionName?(): string | undefined;
+  getContextUsage?(): { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+  setSessionName?(name: string): void;
+  setModel(model: unknown): Promise<void>;
+  setThinkingLevel(level: string): void;
+  reload?(): Promise<void>;
+  navigateTree?(targetId: string, options?: { summarize?: boolean; customInstructions?: string; replaceInstructions?: boolean; label?: string }): Promise<{ editorText?: string; cancelled: boolean; aborted?: boolean; summaryEntry?: unknown }>;
+  abortBranchSummary?(): void;
+  compact?(customInstructions?: string): Promise<unknown>;
+  abortCompaction?(): void;
+  prompt(message: string, options?: { images?: unknown[]; streamingBehavior?: string }): Promise<void>;
+  abort(): Promise<void>;
+  clearQueue?(): void;
+  subscribe?(listener: (event: unknown) => void): (() => void) | undefined;
+}
+
+export interface PiWebSessionInfo {
+  id: string;
+  path: string;
+  name: string;
+  firstMessage: string;
+  created: Date;
+  modified: Date;
+  messageCount: number;
+  allMessagesText: string;
+  cwd: string;
+}