ashlrcode 1.0.0

package/src/agent/ipc.ts

@@ -0,0 +1,256 @@
+/**
+ * IPC — Inter-Process Communication via Unix Domain Sockets.
+ * Allows multiple AshlrCode instances to discover and message each other.
+ *
+ * Each running instance registers itself by writing a .json peer-info file
+ * and listening on a .sock Unix domain socket. Other instances discover
+ * peers by scanning the sockets directory and can send newline-delimited
+ * JSON messages over the socket.
+ */
+
+import { createServer, connect, type Server, type Socket } from "net";
+import { existsSync } from "fs";
+import { readdir, readFile, writeFile, unlink, mkdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+import { randomUUID } from "crypto";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface PeerInfo {
+  id: string;
+  pid: number;
+  cwd: string;
+  sessionId: string;
+  startedAt: string;
+  socketPath: string;
+}
+
+export interface IPCMessage {
+  from: string;
+  to: string;
+  type: "ping" | "pong" | "message" | "task" | "result";
+  payload: string;
+  timestamp: string;
+}
+
+// ── Internal state ───────────────────────────────────────────────────
+
+function getSocketsDir(): string {
+  return join(getConfigDir(), "sockets");
+}
+
+function getSocketPath(id: string): string {
+  return join(getSocketsDir(), `${id}.sock`);
+}
+
+function getPeerInfoPath(id: string): string {
+  return join(getSocketsDir(), `${id}.json`);
+}
+
+let _server: Server | null = null;
+let _peerId: string | null = null;
+let _inbox: IPCMessage[] = [];
+let _onMessage: ((msg: IPCMessage) => void) | null = null;
+
+// ── Server lifecycle ─────────────────────────────────────────────────
+
+/**
+ * Start listening for IPC messages on a Unix domain socket.
+ * Registers this instance as a discoverable peer.
+ */
+export async function startIPCServer(
+  sessionId: string,
+  cwd: string,
+  onMessage?: (msg: IPCMessage) => void,
+): Promise<string> {
+  const dir = getSocketsDir();
+  await mkdir(dir, { recursive: true });
+
+  // Clean up sockets left behind by dead processes
+  await cleanStaleSockets();
+
+  _peerId = randomUUID().slice(0, 8);
+  _onMessage = onMessage ?? null;
+  const socketPath = getSocketPath(_peerId);
+
+  // Write peer info so other instances can discover us
+  const peerInfo: PeerInfo = {
+    id: _peerId,
+    pid: process.pid,
+    cwd,
+    sessionId,
+    startedAt: new Date().toISOString(),
+    socketPath,
+  };
+  await writeFile(getPeerInfoPath(_peerId), JSON.stringify(peerInfo), "utf-8");
+
+  // Create the UDS server
+  _server = createServer((socket: Socket) => {
+    let buffer = "";
+    socket.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? ""; // keep incomplete trailing line
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line) as IPCMessage;
+          _inbox.push(msg);
+          _onMessage?.(msg);
+        } catch {
+          // Ignore malformed messages
+        }
+      }
+    });
+  });
+
+  // Remove leftover socket file if it exists
+  if (existsSync(socketPath)) {
+    await unlink(socketPath).catch(() => {});
+  }
+
+  _server.listen(socketPath);
+  return _peerId;
+}
+
+/**
+ * Stop the IPC server and remove this peer's registration files.
+ */
+export async function stopIPCServer(): Promise<void> {
+  if (_server) {
+    _server.close();
+    _server = null;
+  }
+  if (_peerId) {
+    await unlink(getSocketPath(_peerId)).catch(() => {});
+    await unlink(getPeerInfoPath(_peerId)).catch(() => {});
+    _peerId = null;
+  }
+  _inbox = [];
+  _onMessage = null;
+}
+
+// ── Peer discovery ───────────────────────────────────────────────────
+
+/**
+ * List all active AshlrCode peers (including self).
+ * Dead peers whose process no longer exists are excluded.
+ */
+export async function listPeers(): Promise<PeerInfo[]> {
+  const dir = getSocketsDir();
+  if (!existsSync(dir)) return [];
+
+  const files = await readdir(dir);
+  const peers: PeerInfo[] = [];
+
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      const peer = JSON.parse(raw) as PeerInfo;
+
+      // Verify the process is still alive (signal 0 = existence check)
+      try {
+        process.kill(peer.pid, 0);
+        peers.push(peer);
+      } catch {
+        // Process is dead — skip (cleanup happens on server start)
+      }
+    } catch {
+      // Corrupt file — skip
+    }
+  }
+
+  return peers;
+}
+
+// ── Messaging ────────────────────────────────────────────────────────
+
+/**
+ * Send a message to a specific peer by ID.
+ * Returns true if the message was delivered, false otherwise.
+ */
+export async function sendToPeer(
+  peerId: string,
+  type: IPCMessage["type"],
+  payload: string,
+): Promise<boolean> {
+  const peers = await listPeers();
+  const peer = peers.find((p) => p.id === peerId);
+  if (!peer) return false;
+
+  const msg: IPCMessage = {
+    from: _peerId ?? "unknown",
+    to: peerId,
+    type,
+    payload,
+    timestamp: new Date().toISOString(),
+  };
+
+  return new Promise<boolean>((resolve) => {
+    const socket = connect(peer.socketPath, () => {
+      socket.write(JSON.stringify(msg) + "\n");
+      socket.end();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+    // 5-second timeout to avoid hanging
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 5000);
+    socket.on("close", () => clearTimeout(timer));
+  });
+}
+
+/**
+ * Read and clear the inbox — returns all messages received since last read.
+ */
+export function readInbox(): IPCMessage[] {
+  const msgs = [..._inbox];
+  _inbox = [];
+  return msgs;
+}
+
+/**
+ * Peek at inbox without clearing it.
+ */
+export function peekInbox(): readonly IPCMessage[] {
+  return _inbox;
+}
+
+/**
+ * Get this instance's peer ID (null if IPC server not started).
+ */
+export function getPeerId(): string | null {
+  return _peerId;
+}
+
+// ── Maintenance ──────────────────────────────────────────────────────
+
+/**
+ * Remove socket and info files for peers whose process is no longer alive.
+ */
+async function cleanStaleSockets(): Promise<void> {
+  const dir = getSocketsDir();
+  if (!existsSync(dir)) return;
+
+  const files = await readdir(dir);
+
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      const peer = JSON.parse(raw) as PeerInfo;
+      try {
+        process.kill(peer.pid, 0);
+      } catch {
+        // Process is dead — clean up both files
+        await unlink(join(dir, file)).catch(() => {});
+        await unlink(peer.socketPath).catch(() => {});
+      }
+    } catch {
+      // Corrupt info file — remove it
+      await unlink(join(dir, file)).catch(() => {});
+    }
+  }
+}

package/src/agent/kairos.ts

@@ -0,0 +1,207 @@
+/**
+ * KAIROS — Autonomous Agent Mode.
+ *
+ * Heartbeat-driven loop that keeps the agent alive between user inputs.
+ * Terminal focus detection adjusts autonomy level:
+ *   - focused   → collaborative (ask before big changes)
+ *   - unfocused  → full-auto (lean into autonomous action)
+ *   - unknown    → autonomous (balanced default)
+ */
+
+import { runAgentLoop } from "./loop.ts";
+import type { ProviderRouter } from "../providers/router.ts";
+import type { ToolRegistry } from "../tools/registry.ts";
+import type { ToolContext } from "../tools/types.ts";
+import type { Message } from "../providers/types.ts";
+
+/* ── Configuration ──────────────────────────────────────────────── */
+
+export interface KairosConfig {
+  router: ProviderRouter;
+  toolRegistry: ToolRegistry;
+  toolContext: ToolContext;
+  systemPrompt: string;
+  /** Milliseconds between autonomous heartbeats. Default: 30_000 */
+  heartbeatIntervalMs: number;
+  /** Max tool-loop iterations per heartbeat tick. Default: 5 */
+  maxAutonomousIterations: number;
+  onOutput: (text: string) => void;
+  onToolStart?: (name: string, input: Record<string, unknown>) => void;
+  onToolEnd?: (name: string, result: string, isError: boolean) => void;
+}
+
+export type AutonomyLevel = "collaborative" | "autonomous" | "full-auto";
+
+/* ── Focus detection ────────────────────────────────────────────── */
+
+export type FocusState = "focused" | "unfocused" | "unknown";
+
+/**
+ * Detect whether a terminal application is the frontmost window.
+ * macOS: uses osascript.  Linux: uses xdotool.  Otherwise: unknown.
+ */
+export async function detectTerminalFocus(): Promise<FocusState> {
+  try {
+    const platform = process.platform;
+
+    if (platform === "darwin") {
+      const proc = Bun.spawn(
+        ["osascript", "-e", 'tell application "System Events" to get name of first process whose frontmost is true'],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+      const output = (await new Response(proc.stdout).text()).trim();
+      await proc.exited;
+      const terminals = ["Terminal", "iTerm2", "Alacritty", "kitty", "Warp", "Hyper", "WezTerm"];
+      return terminals.some(t => output.includes(t)) ? "focused" : "unfocused";
+    }
+
+    if (platform === "linux") {
+      const proc = Bun.spawn(
+        ["bash", "-c", "xdotool getactivewindow getwindowname 2>/dev/null || echo unknown"],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+      const output = (await new Response(proc.stdout).text()).trim().toLowerCase();
+      await proc.exited;
+      if (output === "unknown") return "unknown";
+      const terminals = ["terminal", "konsole", "alacritty", "kitty", "tmux", "screen"];
+      return terminals.some(t => output.includes(t)) ? "focused" : "unfocused";
+    }
+
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/* ── Autonomy helpers ───────────────────────────────────────────── */
+
+function getAutonomyLevel(focusState: FocusState): AutonomyLevel {
+  switch (focusState) {
+    case "unfocused": return "full-auto";
+    case "focused":   return "collaborative";
+    default:          return "autonomous";
+  }
+}
+
+function getAutonomyPrompt(level: AutonomyLevel): string {
+  switch (level) {
+    case "full-auto":
+      return "\n\n[AUTONOMOUS MODE — User is away]\nLean heavily into autonomous action. Read files, make changes, commit, push. Decide independently. Only pause for truly irreversible or ambiguous decisions.";
+    case "collaborative":
+      return "\n\n[COLLABORATIVE MODE — User is watching]\nBe more collaborative. Ask before making significant changes. Explain your reasoning. Use AskUser for decisions.";
+    case "autonomous":
+      return "\n\n[AUTONOMOUS MODE]\nYou are running autonomously. Complete tasks independently but use good judgment about what requires confirmation.";
+  }
+}
+
+/* ── KAIROS loop ────────────────────────────────────────────────── */
+
+export class KairosLoop {
+  private running = false;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private focusTimer: ReturnType<typeof setInterval> | null = null;
+  private history: Message[] = [];
+  private config: KairosConfig;
+  private tickCount = 0;
+  private _focusState: FocusState = "unknown";
+
+  constructor(config: KairosConfig) {
+    this.config = config;
+  }
+
+  /** Kick off the autonomous loop with an initial goal. */
+  async start(initialGoal: string): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    this.tickCount = 0;
+
+    this.config.onOutput(
+      `  KAIROS active — heartbeat every ${this.config.heartbeatIntervalMs / 1000}s\n`,
+    );
+
+    // Poll terminal focus every 10 s
+    this.focusTimer = setInterval(async () => {
+      this._focusState = await detectTerminalFocus();
+    }, 10_000);
+
+    // Initial goal execution
+    await this.executeTick(initialGoal);
+
+    // Recurring heartbeat
+    this.timer = setInterval(() => {
+      if (this.running) this.heartbeat().catch(() => {});
+    }, this.config.heartbeatIntervalMs);
+  }
+
+  /** Gracefully stop the loop. */
+  async stop(): Promise<void> {
+    this.running = false;
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+    if (this.focusTimer) { clearInterval(this.focusTimer); this.focusTimer = null; }
+    this.config.onOutput("  KAIROS stopped\n");
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  /** Inject a user message into the running autonomous loop. */
+  async injectMessage(message: string): Promise<void> {
+    await this.executeTick(message);
+  }
+
+  /* ── internals ──────────────────────────────────────────────── */
+
+  private async heartbeat(): Promise<void> {
+    if (!this.running) return;
+    this.tickCount++;
+
+    const level = getAutonomyLevel(this._focusState);
+    const tick = [
+      `<tick count="${this.tickCount}" focus="${this._focusState}" autonomy="${level}" time="${new Date().toISOString()}">`,
+      "Continue your current work. Check task list for pending items.",
+      "If nothing is pending, check if there are improvements to make or tests to run.",
+    ].join("\n");
+
+    this.config.onOutput(`  tick #${this.tickCount} [${level}]\n`);
+    await this.executeTick(tick);
+  }
+
+  private async executeTick(prompt: string): Promise<void> {
+    const level = getAutonomyLevel(this._focusState);
+    const autonomyPrompt = getAutonomyPrompt(level);
+
+    try {
+      const result = await runAgentLoop(prompt, this.history, {
+        systemPrompt: this.config.systemPrompt + autonomyPrompt,
+        router: this.config.router,
+        toolRegistry: this.config.toolRegistry,
+        toolContext: this.config.toolContext,
+        maxIterations: this.config.maxAutonomousIterations,
+        onText: (text) => this.config.onOutput(text),
+        onToolStart: this.config.onToolStart,
+        onToolEnd: this.config.onToolEnd,
+      });
+
+      this.history = result.messages;
+
+      // Cap history to prevent unbounded growth
+      const MAX_HISTORY = 100;
+      if (this.history.length > MAX_HISTORY) {
+        this.history = this.history.slice(-MAX_HISTORY);
+      }
+
+      // Auto-stop if the model signals completion
+      if (
+        result.finalText.includes("[KAIROS_STOP]") ||
+        result.finalText.includes("nothing left to do")
+      ) {
+        await this.stop();
+      }
+    } catch (err) {
+      this.config.onOutput(
+        `  KAIROS error: ${err instanceof Error ? err.message : String(err)}\n`,
+      );
+    }
+  }
+}