astrabot 0.1.0

package/session/store.ts

@@ -0,0 +1,278 @@
+import fs from "fs";
+import path from "path";
+import { getConfigDir } from "../ai/config-loader";
+import type { ActionLog } from "../modes/agent/types";
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export type SessionMode = "agent" | "ask" | "plan" | "multi" | "auto";
+export type SessionStatus = "active" | "completed" | "interrupted";
+
+export interface TranscriptMessage {
+  role: "user" | "agent" | "system";
+  content: string;
+  timestamp: string;
+}
+
+export interface SessionEntry {
+  id: string;
+  workspacePath: string;
+  mode: SessionMode;
+  status: SessionStatus;
+  /** Natural-language summary of what happened in this session. */
+  summary: string;
+  /** The last user prompt / goal that was provided */
+  lastGoal: string;
+  /** All user goals across the session (for multi-turn awareness) */
+  allGoals: string[];
+  /** Key files that were touched (created, modified, read) */
+  touchedFiles: string[];
+  /** Number of actions that were approved and applied */
+  appliedActions: number;
+  /** Number of actions that were rejected or discarded */
+  rejectedActions: number;
+  /**
+   * The full conversation transcript for this session.
+   * Stored inline so context reconstruction doesn't need a separate file read.
+   * Capped at TRANSCRIPT_CAP messages (oldest trimmed first).
+   */
+  transcript: TranscriptMessage[];
+  /**
+   * Tasks/sub-goals the agent identified but didn't complete.
+   * Enables "pick up where we left off" without re-analysing the transcript.
+   */
+  pendingTasks: string[];
+  /**
+   * The agent's final message verbatim (truncated to 2 000 chars).
+   * Useful for one-shot context injection without loading the full transcript.
+   */
+  lastAgentResponse: string;
+  /** ISO-8601 timestamps */
+  createdAt: string;
+  updatedAt: string;
+  /** Previous session ID for chaining */
+  previousSessionId?: string;
+}
+
+export interface SessionStoreIndex {
+  version: number;
+  sessions: SessionEntry[];
+  maxSessions: number;
+}
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const STORE_DIR = path.join(getConfigDir(), "sessions");
+const INDEX_FILE = path.join(STORE_DIR, "index.json");
+const MAX_SESSIONS = 100;
+const TRANSCRIPT_CAP = 60; // max messages kept inline
+const CURRENT_VERSION = 2;
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function ensureStoreDir(): void {
+  if (!fs.existsSync(STORE_DIR)) {
+    fs.mkdirSync(STORE_DIR, { recursive: true });
+  }
+}
+
+function generateSessionId(): string {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `sess_${ts}_${rand}`;
+}
+
+function now(): string {
+  return new Date().toISOString();
+}
+
+function atomicWrite(filePath: string, data: string): void {
+  ensureStoreDir();
+  const tmp = `${filePath}.tmp_${process.pid}_${Date.now()}`;
+  fs.writeFileSync(tmp, data, "utf8");
+  fs.renameSync(tmp, filePath);
+}
+
+// ── Index Operations ───────────────────────────────────────────────────────
+
+function readIndex(): SessionStoreIndex {
+  if (!fs.existsSync(INDEX_FILE)) {
+    return { version: CURRENT_VERSION, sessions: [], maxSessions: MAX_SESSIONS };
+  }
+  try {
+    const raw = fs.readFileSync(INDEX_FILE, "utf8");
+    const parsed = JSON.parse(raw) as SessionStoreIndex;
+    // Back-compat: fill missing fields from older entries
+    for (const s of parsed.sessions) {
+      s.allGoals ??= [s.lastGoal];
+      s.transcript ??= [];
+      s.pendingTasks ??= [];
+      s.lastAgentResponse ??= "";
+    }
+    parsed.sessions.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+    return parsed;
+  } catch {
+    return { version: CURRENT_VERSION, sessions: [], maxSessions: MAX_SESSIONS };
+  }
+}
+
+function writeIndex(index: SessionStoreIndex): void {
+  atomicWrite(INDEX_FILE, JSON.stringify(index, null, 2));
+}
+
+// ── Public API ─────────────────────────────────────────────────────────────
+
+export function listSessions(
+  workspacePath?: string,
+  limit = 20
+): SessionEntry[] {
+  const index = readIndex();
+  let sessions = index.sessions;
+  if (workspacePath) {
+    const root = path.resolve(workspacePath);
+    sessions = sessions.filter((s) => path.resolve(s.workspacePath) === root);
+  }
+  return sessions.slice(0, limit);
+}
+
+export function getSession(id: string): SessionEntry | undefined {
+  const index = readIndex();
+  return index.sessions.find((s) => s.id === id);
+}
+
+export function getMostRecentSession(
+  workspacePath?: string
+): SessionEntry | undefined {
+  return listSessions(workspacePath, 1)[0];
+}
+
+export function createSession(input: {
+  workspacePath: string;
+  mode: SessionMode;
+  goal: string;
+  previousSessionId?: string;
+}): SessionEntry {
+  const entry: SessionEntry = {
+    id: generateSessionId(),
+    workspacePath: path.resolve(input.workspacePath),
+    mode: input.mode,
+    status: "active",
+    summary: "",
+    lastGoal: input.goal,
+    allGoals: [input.goal],
+    touchedFiles: [],
+    appliedActions: 0,
+    rejectedActions: 0,
+    transcript: [],
+    pendingTasks: [],
+    lastAgentResponse: "",
+    createdAt: now(),
+    updatedAt: now(),
+    previousSessionId: input.previousSessionId,
+  };
+
+  const index = readIndex();
+  index.sessions.unshift(entry);
+  if (index.sessions.length > MAX_SESSIONS) {
+    const removed = index.sessions.splice(MAX_SESSIONS);
+    for (const r of removed) {
+      try {
+        fs.unlinkSync(path.join(STORE_DIR, `${r.id}.json`));
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  writeIndex(index);
+  return entry;
+}
+
+export function updateSession(
+  id: string,
+  patch: Partial<Omit<SessionEntry, "id" | "createdAt">>,
+  actions?: readonly ActionLog[]
+): SessionEntry | undefined {
+  const index = readIndex();
+  const entry = index.sessions.find((s) => s.id === id);
+  if (!entry) return undefined;
+
+  // Merge transcript carefully: cap at TRANSCRIPT_CAP
+  if (patch.transcript) {
+    const merged = [...entry.transcript, ...patch.transcript];
+    patch.transcript = merged.slice(-TRANSCRIPT_CAP);
+  }
+
+  // Merge allGoals without duplicates
+  if (patch.lastGoal && !entry.allGoals.includes(patch.lastGoal)) {
+    patch.allGoals = [...entry.allGoals, patch.lastGoal];
+  }
+
+  Object.assign(entry, patch, { updatedAt: now() });
+  writeIndex(index);
+
+  if (actions) {
+    const historyFile = path.join(STORE_DIR, `${id}.json`);
+    atomicWrite(historyFile, JSON.stringify(actions, null, 2));
+  }
+
+  return entry;
+}
+
+/**
+ * Append transcript messages to an active session without a full patch.
+ * More efficient for high-frequency updates during a live session.
+ */
+export function appendTranscript(
+  id: string,
+  messages: TranscriptMessage[]
+): void {
+  const index = readIndex();
+  const entry = index.sessions.find((s) => s.id === id);
+  if (!entry) return;
+  entry.transcript.push(...messages);
+  if (entry.transcript.length > TRANSCRIPT_CAP) {
+    entry.transcript = entry.transcript.slice(-TRANSCRIPT_CAP);
+  }
+  entry.updatedAt = now();
+  writeIndex(index);
+}
+
+export function deleteSession(id: string): boolean {
+  const index = readIndex();
+  const idx = index.sessions.findIndex((s) => s.id === id);
+  if (idx === -1) return false;
+  index.sessions.splice(idx, 1);
+  writeIndex(index);
+  try {
+    fs.unlinkSync(path.join(STORE_DIR, `${id}.json`));
+  } catch {
+    /* ignore */
+  }
+  return true;
+}
+
+export function clearAllSessions(): number {
+  const index = readIndex();
+  const count = index.sessions.length;
+  for (const s of index.sessions) {
+    try {
+      fs.unlinkSync(path.join(STORE_DIR, `${s.id}.json`));
+    } catch {
+      /* ignore */
+    }
+  }
+  writeIndex({ version: CURRENT_VERSION, sessions: [], maxSessions: MAX_SESSIONS });
+  return count;
+}
+
+export function readSessionActions(id: string): ActionLog[] {
+  const historyFile = path.join(STORE_DIR, `${id}.json`);
+  if (!fs.existsSync(historyFile)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(historyFile, "utf8"));
+  } catch {
+    return [];
+  }
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/tui/spinner.ts

@@ -0,0 +1,182 @@
+import chalk from "chalk";
+
+// ── Biological Neuro-States ───────────────────────────────────────────────
+const METABOLIC_RATES = {
+    HYPER: 45,   // Rapid heart rate for immediate tasks
+    STEADY: 75,  // Cruising breath rhythm
+    STRESSED: 110, // Fast, irregular twitching
+    HIBERNATE: 180 // Deep, slow dynamic sighing
+};
+
+// Shifting structural shapes based on kinetic mood
+const MOODS = {
+    PULSE:   ["⬖", "⬘", "⬗", "⬙"],
+    CRAWL:   ["•««««", "»•«««", "»»•««", "»»»•«", "»»»»•", "»»»•«", "»»•««", "»•«««"],
+    TWITCH:  ["⤜•⤛  ", " ⤜•⤛ ", "  ⤜•⤛", " ⤜•⤛ "],
+    SIGH:    ["⦾🪶   ", " ⦾🪶  ", "  ⦾🪶 ", "   ⦾🪶", "  ⦾🪶 ", " ⦾🪶  "]
+};
+
+const C = {
+    // Dynamic color gradient engine mappings
+    vitality: (pct: number) => {
+        // Blends from energetic Violet/Cyan to a stressed Crimson Magenta as fatigue mounts
+        if (pct < 0.4) return chalk.bold.hex("#a78bfa"); // Calm Lavender
+        if (pct < 0.7) return chalk.bold.hex("#38bdf8"); // Processing Cyan
+        if (pct < 0.9) return chalk.bold.hex("#fb7185"); // Agitated Rose
+        return chalk.bold.hex("#f43f5e");               // High-Panic Crimson
+    },
+    text: chalk.hex("#f3f4f6"),
+    dim: chalk.hex("#4b5563"),
+    success: chalk.bold.hex("#34d399"),
+    error: chalk.bold.hex("#ef4444"),
+    telemetry: chalk.hex("#60a5fa")
+};
+
+function formatElapsed(ms: number): string {
+    const s = Math.floor(ms / 1000);
+    const dec = Math.floor((ms % 1000) / 100);
+    return `${s}.${dec}s`;
+}
+
+export interface SpinnerContext {
+    updateMessage: (msg: string) => void;
+    updateMetric: (metric: string) => void;
+}
+
+export interface SpinnerOptions {
+    message: string;
+    doneMessage?: string;
+    failMessage?: string;
+    hideTime?: boolean;
+}
+
+// ── The Autonomous Organism Engine ────────────────────────────────────────
+class AutonomousLoader {
+    private timer: ReturnType<typeof setInterval> | null = null;
+    private currentInterval = METABOLIC_RATES.STEADY;
+    private tickCount = 0;
+    private startTime = 0;
+    private message: string;
+    private metric = "";
+    private readonly showTime: boolean;
+
+    constructor(message: string, showTime = true) {
+        this.message = message;
+        this.showTime = showTime;
+    }
+
+    get elapsed(): number {
+        return Date.now() - this.startTime;
+    }
+
+    public updateMessage(msg: string) {
+        this.message = msg;
+    }
+
+    public updateMetric(metric: string) {
+        this.metric = metric;
+    }
+
+    start(): void {
+        this.startTime = Date.now();
+        this.tickCount = 0;
+        process.stdout.write("\u001B[?25l"); // Clean interface focus mode
+        this.loop();
+    }
+
+    private loop(): void {
+        this.render();
+        this.tickCount++;
+
+        // Calculate a physiological "fatigue index" from 0.0 to 1.0 (Caps at 12 seconds)
+        const fatigue = Math.min(this.elapsed / 12000, 1.0);
+        
+        // The heart rate dynamically mutates based on the current system load
+        let targetInterval = METABOLIC_RATES.STEADY;
+        if (fatigue < 0.15) targetInterval = METABOLIC_RATES.HYPER;
+        else if (fatigue > 0.8) targetInterval = METABOLIC_RATES.HIBERNATE;
+        else if (fatigue > 0.5) targetInterval = METABOLIC_RATES.STRESSED;
+
+        // Smooth metabolic shifting to avoid jagged frame skips
+        this.currentInterval = Math.round(this.currentInterval * 0.7 + targetInterval * 0.3);
+        
+        this.timer = setTimeout(() => this.loop(), this.currentInterval);
+    }
+
+    private render(): void {
+        const ms = this.elapsed;
+        const fatigue = Math.min(ms / 12000, 1.0);
+
+        let shape = "";
+        
+        // Morph structural behavior profiles cleanly
+        if (fatigue > 0.8) {
+            shape = MOODS.SIGH[Math.floor(this.tickCount / 2) % MOODS.SIGH.length] ?? "";
+        } else if (fatigue > 0.5) {
+            shape = MOODS.TWITCH[this.tickCount % MOODS.TWITCH.length] ?? "";
+        } else if (fatigue > 0.15) {
+            shape = MOODS.CRAWL[this.tickCount % MOODS.CRAWL.length] ?? "";
+        } else {
+            // Heartbeat ambient pulse for immediate executions
+            shape = MOODS.PULSE[this.tickCount % MOODS.PULSE.length] ?? "";
+        }
+
+        const telemetry = this.metric ? ` ${C.dim("➔")} ${C.telemetry(this.metric)}` : "";
+        const ageIndicator = this.showTime ? ` ${C.dim(`[${formatElapsed(ms)}]`)}` : "";
+
+        // Build composite biological visual output
+        const coreNode = C.vitality(fatigue)(shape);
+        const line = `  ${coreNode}  ${C.text(this.message)}${telemetry}${ageIndicator}`;
+
+        const cols = process.stdout.columns || 80;
+        process.stdout.write(`\r${"\u001B[K"}${line.slice(0, cols - 1)}`);
+    }
+
+    stop(finalLine: string): void {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        process.stdout.write(`\r${"\u001B[K"}${finalLine}\n\u001B[?25h`);
+    }
+}
+
+// ── Public API Orchestration ────────────────────────────────────────────
+export async function withSpinner<T>(
+    opts: SpinnerOptions,
+    task: (ctx: SpinnerContext) => Promise<T>,
+): Promise<T> {
+    const loader = new AutonomousLoader(opts.message, !opts.hideTime);
+    loader.start();
+
+    const ctx: SpinnerContext = {
+        updateMessage: (msg) => loader.updateMessage(msg),
+        updateMetric: (metric) => loader.updateMetric(metric),
+    };
+
+    try {
+        const result = await task(ctx);
+        const totalTime = loader.elapsed;
+        const elapsedStr = formatElapsed(totalTime);
+        
+        // Celebratory reactive state: entity expresses joy/relief depending on runtime friction
+        let endingIcon = "🌱";
+        if (totalTime < 800) endingIcon = "⚡"; 
+        else if (totalTime > 6000) endingIcon = "🧘";
+
+        const done = opts.doneMessage
+            ? ` ${endingIcon} ${C.success("●")} ${C.text(opts.message)} ${C.dim(`— ${opts.doneMessage}`)} ${C.dim(`(${elapsedStr})`)}`
+            : ` ${endingIcon} ${C.success("●")} ${C.text(opts.message)} ${C.dim(`(${elapsedStr})`)}`;
+            
+        loader.stop(done);
+        return result;
+    } catch (e) {
+        const elapsedStr = formatElapsed(loader.elapsed);
+        const fail = opts.failMessage
+            ? ` 🌋 ${C.error("✘")} ${C.text(opts.message)} ${C.dim(`— ${opts.failMessage}`)} ${C.dim(`(${elapsedStr})`)}`
+            : ` 🌋 ${C.error("✘")} ${C.text(opts.message)} ${C.dim(`— system rupture (${elapsedStr})`)}`;
+            
+        loader.stop(fail);
+        throw e;
+    }
+}

package/tui/terminal-md.ts

@@ -0,0 +1,17 @@
+import { marked } from "marked";
+import {markedTerminal} from 'marked-terminal'
+
+let ready = false
+
+function ensureMarked(): void {
+    if (ready) return
+    const w = Math.max(40, Math.min(process.stdout.columns || 80,120))
+    //@ts-ignore
+    marked.use(markedTerminal({width:w, reflowText: true}, {}))
+    ready = true
+}
+
+export function renderTerminalMarkdown(source:string):string{
+    ensureMarked()
+    return marked.parse(source.trimEnd(), {async:false})
+}