Transformer Math

import fs from "fs";
import path from "path";
import os from "os";

// Sessions live under ~/.claude/projects/<sanitized-cwd>/<sessionId>.jsonl
const PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");

function getSessionPath(projectDir: string, sessionId: string): string {
  return path.join(PROJECTS_DIR, projectDir, `${sessionId}.jsonl`);
}

class SessionStorage {
  // Persist session: append one JSON event per line (JSONL)
  save(projectDir: string, sessionId: string, state: SessionState): void {
    const filePath = getSessionPath(projectDir, sessionId);
    const event = {
      id: sessionId,
      messages: serializeMessages(state.messages),
      model: state.model,
      cost_usd: state.totalCost,
      file_history: state.filesTouched,
      created_at: state.createdAt,
      updated_at: new Date().toISOString(),
      cwd: state.workingDirectory,
    };
    fs.appendFileSync(filePath, JSON.stringify(event) + "\n");
  }

  // Reconstruct session state: read all lines, use last event
  restore(projectDir: string, sessionId: string): QueryEngine {
    const filePath = getSessionPath(projectDir, sessionId);
    const lines = fs.readFileSync(filePath, "utf-8").trim().split("\n");
    const data = JSON.parse(lines[lines.length - 1]!);

    // Reconstruct multi-domain state
    const engine = new QueryEngine({
      initialMessages: deserializeMessages(data.messages),
      model: data.model,
      cwd: data.cwd,
    });

    // Restore auxiliary state
    restoreFileHistory(data.file_history);
    restoreAttribution(data);
    extractPendingTodos(data.messages);

    return engine;
  }

  // List recent sessions for selection
  listRecent(projectDir: string, limit: number = 20): SessionMetadata[] {
    const dir = path.join(PROJECTS_DIR, projectDir);
    const files = fs.readdirSync(dir)
      .filter((f) => f.endsWith(".jsonl"))
      .map((f) => ({ f, mtime: fs.statSync(path.join(dir, f)).mtime }))
      .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
      .slice(0, limit);
    return files.map((f) => this.readMetadata(f.f));
  }
}

// Arrow-key recall of previous inputs — persists across all sessions
class InputHistory {
  // ~/.claude/history.jsonl — shared across all projects/sessions
  private historyPath: string = path.join(os.homedir(), ".claude", "history.jsonl");
  private entries: string[] = this.load();
  private cursor: number = this.entries.length;

  add(inputText: string): void {
    this.entries.push(inputText);
    this.save(); // append to file immediately
  }

  // Up/down arrow through history
  navigate(direction: "up" | "down"): string {
    if (direction === "up") {
      this.cursor = Math.max(0, this.cursor - 1);
    } else {
      this.cursor = Math.min(this.entries.length - 1, this.cursor + 1);
    }
    return this.entries[this.cursor];
  }

  private load(): string[] {
    if (fs.existsSync(this.historyPath)) {
      // Each line is a JSON object; extract the display field for arrow-key recall
      return fs.readFileSync(this.historyPath, "utf-8")
        .split("\n")
        .filter(Boolean)
        .map((line) => { try { return JSON.parse(line).display ?? line; } catch { return line; } });
    }
    return [];
  }

  private save(): void {
    // Keep last 100 entries (MAX_HISTORY_ITEMS in source)
    const recent = this.entries.slice(-100);
    fs.writeFileSync(this.historyPath, recent.map((e) => JSON.stringify({ display: e })).join("\n") + "\n");
  }
}

// Resume creates a NEW session that inherits old context
function resumeSession(oldSessionId: string): Session {
  const storage = new SessionStorage();
  const oldData = storage.restore(oldSessionId);

  // New session ID — the old session is read-only now
  const newSessionId = generateUuid();

  // The new session starts with old messages as context
  const newSession = new Session({
    id: newSessionId,
    parentId: oldSessionId,   // adoption link
    initialMessages: oldData.messages,
    model: oldData.model,
    cwd: oldData.cwd,
  });

  // Cost tracking starts fresh for the new session,
  // but we can show cumulative cost across the chain
  newSession.inheritedCost = oldData.cost_usd;

  return newSession;
}