indusagi-coding-agent 0.2.8 → 0.2.9

package/src/sessions/library.ts

@@ -0,0 +1,229 @@
+/**
+ * SessionLibrary — the catalog-and-navigation layer over persisted transcripts.
+ */
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  stat,
+} from "node:fs/promises";
+import { basename, join } from "node:path";
+import { TranscriptStore, fsBackend } from "../conductor/index.js";
+import type { BranchNode, PriorTurn, SavedSession } from "./contract.js";
+
+const SESSION_FILE_EXT = ".ndjson";
+const PREVIEW_LIMIT = 72;
+
+export interface SessionLibraryOptions {
+  readonly sessionsDir: string;
+}
+
+export class SessionLibrary {
+  readonly #dir: string;
+  readonly #backend: ReturnType<typeof fsBackend>;
+
+  constructor(options: SessionLibraryOptions) {
+    this.#dir = options.sessionsDir;
+    this.#backend = fsBackend(options.sessionsDir);
+  }
+
+  get directory(): string {
+    return this.#dir;
+  }
+
+  async list(options: { readonly deep?: boolean } = {}): Promise<SavedSession[]> {
+    const ids = await this.#sessionIds();
+    const rows = await Promise.all(
+      ids.map((id) => (options.deep ? this.#deepRow(id) : this.#shallowRow(id))),
+    );
+    return rows.sort(byMostRecent);
+  }
+
+  async open(id: string): Promise<TranscriptStore | null> {
+    return TranscriptStore.open(id, { backend: this.#backend });
+  }
+
+  async rename(fromId: string, toId: string): Promise<string> {
+    const fromPath = this.pathOf(fromId);
+    const toPath = this.pathOf(toId);
+    if (await this.#missing(fromPath)) {
+      throw new Error(`SessionLibrary.rename: no session "${fromId}"`);
+    }
+    if (!(await this.#missing(toPath))) {
+      throw new Error(`SessionLibrary.rename: session "${toId}" already exists`);
+    }
+    await mkdir(this.#dir, { recursive: true });
+    await rename(fromPath, toPath);
+    return toPath;
+  }
+
+  async remove(id: string): Promise<boolean> {
+    const path = this.pathOf(id);
+    if (await this.#missing(path)) return false;
+    await rm(path, { force: true });
+    return true;
+  }
+
+  pathOf(id: string): string {
+    return join(this.#dir, `${id}${SESSION_FILE_EXT}`);
+  }
+
+  tree(store: TranscriptStore): BranchNode[] {
+    const nodes = [...store.state().nodes.values()];
+    const currentLeaf = store.head.leaf;
+    const childrenOf = new Map<string | null, typeof nodes>();
+    for (const node of nodes) {
+      const bucket = childrenOf.get(node.parent) ?? [];
+      bucket.push(node);
+      childrenOf.set(node.parent, bucket);
+    }
+    const hasChildren = new Set<string>();
+    for (const node of nodes) {
+      if (node.parent !== null) hasChildren.add(node.parent);
+    }
+    const out: BranchNode[] = [];
+    const walk = (entry: (typeof nodes)[number], depth: number): void => {
+      out.push({
+        id: entry.id,
+        parent: entry.parent,
+        label: labelFor(entry, depth),
+        depth,
+        isLeaf: !hasChildren.has(entry.id),
+        isCurrent: entry.id === currentLeaf,
+      });
+      for (const child of childrenOf.get(entry.id) ?? []) {
+        walk(child, depth + 1);
+      }
+    };
+    for (const root of childrenOf.get(null) ?? []) {
+      walk(root, 0);
+    }
+    return out;
+  }
+
+  priorTurns(store: TranscriptStore): PriorTurn[] {
+    const out: PriorTurn[] = [];
+    for (const entry of store.pathTo()) {
+      if (entry.role !== "user") continue;
+      const text = messageText(entry.content).trim();
+      if (text.length === 0) continue;
+      out.push({ entryId: entry.id, text, preview: previewOf(text) });
+    }
+    return out;
+  }
+
+  async #sessionIds(): Promise<string[]> {
+    let names: string[];
+    try {
+      names = await readdir(this.#dir);
+    } catch {
+      return [];
+    }
+    return names
+      .filter((name) => name.endsWith(SESSION_FILE_EXT))
+      .map((name) => basename(name, SESSION_FILE_EXT));
+  }
+
+  async #shallowRow(id: string): Promise<SavedSession> {
+    const path = this.pathOf(id);
+    const meta = await this.#fileMeta(path);
+    return { id, path, ...meta };
+  }
+
+  async #deepRow(id: string): Promise<SavedSession> {
+    const path = this.pathOf(id);
+    const meta = await this.#fileMeta(path);
+    const store = await this.open(id);
+    if (store === null) return { id, path, ...meta };
+    const branch = store.pathTo();
+    const conversational = branch.filter(isConversational);
+    const opener = conversational.find((entry) => entry.role === "user");
+    const preview = opener ? previewOf(messageText(opener.content)) : undefined;
+    return {
+      id,
+      path,
+      ...meta,
+      messageCount: conversational.length,
+      ...(preview ? { preview, name: preview } : {}),
+    };
+  }
+
+  async #fileMeta(path: string): Promise<{ size?: number; lastModified?: number }> {
+    try {
+      const info = await stat(path);
+      return { size: info.size, lastModified: info.mtimeMs };
+    } catch {
+      return {};
+    }
+  }
+
+  async #missing(path: string): Promise<boolean> {
+    try {
+      await readFile(path);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+}
+
+function isConversational(entry: { role: string }): boolean {
+  return entry.role === "user" || entry.role === "assistant" || entry.role === "tool";
+}
+
+function byMostRecent(a: SavedSession, b: SavedSession): number {
+  const delta = (b.lastModified ?? 0) - (a.lastModified ?? 0);
+  return delta !== 0 ? delta : a.id.localeCompare(b.id);
+}
+
+function labelFor(
+  entry: { id: string; role: string; content: unknown },
+  depth: number,
+): string {
+  const indent = "  ".repeat(depth);
+  switch (entry.role) {
+    case "user":
+      return `${indent}user: ${previewOf(messageText(entry.content))}`;
+    case "assistant":
+      return `${indent}assistant`;
+    case "tool":
+      return `${indent}tool: ${toolNameOf(entry.content)}`;
+    case "condense":
+      return `${indent}condense`;
+    case "system":
+      return `${indent}system`;
+    default:
+      return `${indent}note`;
+  }
+}
+
+function toolNameOf(message: { toolName?: unknown }): string {
+  const candidate = message.toolName;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : "tool";
+}
+
+function messageText(message: unknown): string {
+  const content = (message as { content?: unknown }).content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const block of content) {
+    if (
+      block &&
+      typeof block === "object" &&
+      (block as { type?: unknown }).type === "text"
+    ) {
+      const text = (block as { text?: unknown }).text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+
+function previewOf(text: string, limit: number = PREVIEW_LIMIT): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= limit) return flat;
+  return `${flat.slice(0, Math.max(0, limit - 1))}\u2026`;
+}

package/src/settings/contract.ts

@@ -0,0 +1,114 @@
+/**
+ * Settings subsystem — the typed surface of the user-tunable preferences an
+ * interactive coding-agent session reads at startup and while it runs.
+ */
+import type { ThinkingLevel } from "indusagi/agent";
+
+export type { ThinkingLevel };
+
+export type EscapeAction = "tree" | "fork" | "clear" | "rewind" | "branch";
+
+export const ESCAPE_ACTIONS: readonly EscapeAction[] = ["tree", "fork", "clear"];
+
+export function isEscapeAction(value: unknown): value is EscapeAction {
+  return typeof value === "string" && (ESCAPE_ACTIONS as readonly string[]).includes(value);
+}
+
+export type DeliveryMode = "all" | "one-at-a-time";
+
+export const DELIVERY_MODES: readonly DeliveryMode[] = ["all", "one-at-a-time"];
+
+export function isDeliveryMode(value: unknown): value is DeliveryMode {
+  return typeof value === "string" && (DELIVERY_MODES as readonly string[]).includes(value);
+}
+
+export type PermissionMode =
+  | "default"
+  | "acceptEdits"
+  | "bypass"
+  | "plan"
+  | "bypassPermissions";
+
+export const PERMISSION_MODES: readonly PermissionMode[] = [
+  "default",
+  "acceptEdits",
+  "bypass",
+  "plan",
+];
+
+export function isPermissionMode(value: unknown): value is PermissionMode {
+  return (
+    value === "default" ||
+    value === "acceptEdits" ||
+    value === "bypass" ||
+    value === "plan" ||
+    value === "bypassPermissions"
+  );
+}
+
+export interface PermissionSettings {
+  allow?: string[];
+  ask?: string[];
+  deny?: string[];
+  defaultMode?: PermissionMode;
+}
+
+export interface Preferences {
+  colourScheme?: string;
+  showImages?: boolean;
+  showReasoning?: boolean;
+  hideThinking?: boolean;
+  imageAutoResize?: boolean;
+  blockImages?: boolean;
+  enableSkillCommands?: boolean;
+  steeringMode?: DeliveryMode;
+  followUpMode?: DeliveryMode;
+  collapseChangelog?: boolean;
+  showHardwareCursor?: boolean;
+  editorPaddingX?: number;
+  enabledModels?: string[];
+  defaultProvider?: string;
+  defaultModel?: string;
+  defaultThinkingLevel?: ThinkingLevel;
+  quietStartup?: boolean;
+  lastSeenVersion?: string;
+  logoSweep?: boolean;
+  reducedMotion?: boolean;
+  autoCompact?: boolean;
+  doubleEscapeAction?: EscapeAction;
+  extensionPackages?: string[];
+  permissions?: PermissionSettings;
+}
+
+export type SettingKey = keyof Preferences;
+
+export const DEFAULT_PREFERENCES: Required<Preferences> = Object.freeze({
+  colourScheme: "default",
+  showImages: true,
+  showReasoning: true,
+  hideThinking: false,
+  imageAutoResize: true,
+  blockImages: false,
+  enableSkillCommands: true,
+  steeringMode: "all",
+  followUpMode: "all",
+  collapseChangelog: false,
+  showHardwareCursor: false,
+  editorPaddingX: 1,
+  enabledModels: [],
+  defaultProvider: "anthropic",
+  defaultModel: "",
+  defaultThinkingLevel: "medium",
+  quietStartup: false,
+  lastSeenVersion: "",
+  logoSweep: false,
+  reducedMotion: false,
+  autoCompact: true,
+  doubleEscapeAction: "clear",
+  extensionPackages: [],
+  permissions: { allow: [], ask: [], deny: [], defaultMode: "default" },
+}) as Required<Preferences>;
+
+export const SETTING_KEYS: readonly SettingKey[] = Object.freeze(
+  Object.keys(DEFAULT_PREFERENCES) as SettingKey[],
+);

package/src/settings/index.ts

@@ -0,0 +1,32 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Settings subsystem — public barrel.
+ *
+ * One import site for the typed {@link Preferences} record and its
+ * {@link SettingKey} / {@link EscapeAction} / {@link ThinkingLevel}
+ * vocabularies, the frozen {@link DEFAULT_PREFERENCES}, and the two-tier
+ * {@link PreferenceStore} reader/writer. Console surfaces and boot stages depend
+ * on this module rather than reaching into the individual files.
+ */
+export type {
+  Preferences,
+  SettingKey,
+  EscapeAction,
+  DeliveryMode,
+  ThinkingLevel,
+  PermissionMode,
+  PermissionSettings,
+} from "./contract.js";
+export {
+  DEFAULT_PREFERENCES,
+  SETTING_KEYS,
+  ESCAPE_ACTIONS,
+  isEscapeAction,
+  DELIVERY_MODES,
+  isDeliveryMode,
+  PERMISSION_MODES,
+  isPermissionMode,
+} from "./contract.js";
+export { PreferenceStore } from "./manager.js";
+export type { PreferenceLocations } from "./manager.js";

package/src/settings/manager.ts

@@ -0,0 +1,117 @@
+/**
+ * Settings manager — the two-tier reader/writer over the preference record.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { Workspace } from "../boot/contract.js";
+import { BRAND } from "../workspace/brand.js";
+import { DEFAULT_PREFERENCES, type Preferences, type SettingKey } from "./contract.js";
+
+export interface PreferenceLocations {
+  readonly global: string;
+  readonly project: string;
+}
+
+type PreferencesPartial = Partial<Preferences>;
+
+function loadTier(filePath: string): PreferencesPartial {
+  if (!existsSync(filePath)) return {};
+  let raw: string;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return {};
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {};
+  }
+  return { ...(parsed as Record<string, unknown>) } as PreferencesPartial;
+}
+
+function writeTier(filePath: string, tier: PreferencesPartial): void {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(tier, null, 2)}\n`, "utf-8");
+}
+
+export class PreferenceStore {
+  readonly #locations: PreferenceLocations;
+  #globalTier: PreferencesPartial;
+  #projectTier: PreferencesPartial;
+
+  private constructor(locations: PreferenceLocations) {
+    this.#locations = locations;
+    this.#globalTier = loadTier(locations.global);
+    this.#projectTier = loadTier(locations.project);
+  }
+
+  static atPaths(locations: PreferenceLocations): PreferenceStore {
+    return new PreferenceStore(locations);
+  }
+
+  static fromWorkspace(workspace: Workspace, cwd: string = process.cwd()): PreferenceStore {
+    return new PreferenceStore({
+      global: workspace.settingsPath,
+      project: join(cwd, BRAND.profileDirName, "settings.json"),
+    });
+  }
+
+  paths(): PreferenceLocations {
+    return { ...this.#locations };
+  }
+
+  reload(): void {
+    this.#globalTier = loadTier(this.#locations.global);
+    this.#projectTier = loadTier(this.#locations.project);
+  }
+
+  get<K extends SettingKey>(key: K): Required<Preferences>[K] {
+    const fromProject = (this.#projectTier as Record<string, unknown>)[key];
+    if (fromProject !== undefined) return fromProject as Required<Preferences>[K];
+    const fromGlobal = (this.#globalTier as Record<string, unknown>)[key];
+    if (fromGlobal !== undefined) return fromGlobal as Required<Preferences>[K];
+    return DEFAULT_PREFERENCES[key];
+  }
+
+  set<K extends SettingKey>(key: K, value: Preferences[K]): void {
+    if (value === undefined) {
+      delete (this.#projectTier as Record<string, unknown>)[key];
+      return;
+    }
+    (this.#projectTier as Record<string, unknown>)[key] = value as unknown;
+  }
+
+  snapshot(): Required<Preferences> {
+    return {
+      ...DEFAULT_PREFERENCES,
+      ...stripUndefined(this.#globalTier),
+      ...stripUndefined(this.#projectTier),
+    } as Required<Preferences>;
+  }
+
+  projectOverrides(): Preferences {
+    return { ...this.#projectTier };
+  }
+
+  globalDefaults(): Preferences {
+    return { ...this.#globalTier };
+  }
+
+  save(): void {
+    writeTier(this.#locations.project, this.#projectTier);
+  }
+}
+
+function stripUndefined(tier: PreferencesPartial): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(tier)) {
+    if (value !== undefined) out[key] = value;
+  }
+  return out;
+}

package/src/transcript-export/index.ts

@@ -0,0 +1,45 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Transcript-export subsystem — public barrel.
+ *
+ * The HTML transcript publisher and its supporting machinery: the table-driven
+ * SGR painter ({@link paintSgr}) that turns terminal-styled output into safe HTML
+ * spans, the {@link ThemeBridge} that computes export colors from an
+ * {@link ExportTheme} via a WCAG luminance LUT, the regenerated page-shell
+ * {@link PAGE_SHELL} template with its `{{TOKEN}}` slots and {@link fill} helper,
+ * and {@link publishTranscript} which renders a session transcript to a
+ * standalone HTML document using `marked`, `highlight.js`, and the painter.
+ *
+ * Consumers import the publish surface from `src/transcript-export` rather than
+ * reaching into individual modules.
+ */
+export { paintSgr, tokenizeSgr, foldSgr, SGR_CODE_TABLE } from "./sgr.js";
+export {
+  DefaultThemeBridge,
+  createThemeBridge,
+  buildLuminanceLut,
+  parseColor,
+  formatColor,
+} from "./theme-bridge.js";
+export { PAGE_SHELL, PAGE_STYLES, CLIENT_SCRIPT, fill } from "./template.js";
+export {
+  publishTranscript,
+  type TranscriptEntry,
+  type TranscriptWidget,
+  type PublishOptions,
+} from "./publish.js";
+export {
+  FALLBACK_EXPORT_THEME,
+  SHELL_SLOTS,
+  SGR_INITIAL_STATE,
+  briefingFault,
+} from "../briefing/contract.js";
+export type {
+  ExportTheme,
+  ThemeMode,
+  LuminanceLut,
+  SgrState,
+  SgrToken,
+  SgrMutation,
+} from "../briefing/contract.js";