@cryptiklemur/lattice 0.0.0

package/server/src/features/scheduler.ts

@@ -0,0 +1,281 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getLatticeHome } from "../config";
+import { broadcast } from "../ws/broadcast";
+import type { ScheduledTask } from "@lattice/shared";
+
+var schedulesFile = "";
+var tasks: ScheduledTask[] = [];
+var timerId: ReturnType<typeof setInterval> | null = null;
+var lastTriggeredMinute: Record<string, boolean> = {};
+
+var CHECK_INTERVAL = 30 * 1000;
+
+function getSchedulesPath(): string {
+  if (!schedulesFile) {
+    schedulesFile = join(getLatticeHome(), "schedules.json");
+  }
+  return schedulesFile;
+}
+
+function parseCronField(field: string, min: number, max: number): number[] {
+  var values: number[] = [];
+  var parts = field.split(",");
+
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i].trim();
+
+    if (part.indexOf("/") !== -1) {
+      var slashParts = part.split("/");
+      var step = parseInt(slashParts[1], 10);
+      var rangeStr = slashParts[0];
+      var rangeMin = min;
+      var rangeMax = max;
+      if (rangeStr !== "*") {
+        var rp = rangeStr.split("-");
+        rangeMin = parseInt(rp[0], 10);
+        rangeMax = rp.length > 1 ? parseInt(rp[1], 10) : rangeMin;
+      }
+      for (var v = rangeMin; v <= rangeMax; v += step) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    if (part === "*") {
+      for (var v = min; v <= max; v++) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    if (part.indexOf("-") !== -1) {
+      var rangeParts = part.split("-");
+      var from = parseInt(rangeParts[0], 10);
+      var to = parseInt(rangeParts[1], 10);
+      for (var v = from; v <= to; v++) {
+        values.push(v);
+      }
+      continue;
+    }
+
+    values.push(parseInt(part, 10));
+  }
+
+  return values;
+}
+
+interface ParsedCron {
+  minutes: number[];
+  hours: number[];
+  daysOfMonth: number[];
+  months: number[];
+  daysOfWeek: number[];
+}
+
+function parseCron(expr: string): ParsedCron | null {
+  var fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    return null;
+  }
+  return {
+    minutes: parseCronField(fields[0], 0, 59),
+    hours: parseCronField(fields[1], 0, 23),
+    daysOfMonth: parseCronField(fields[2], 1, 31),
+    months: parseCronField(fields[3], 1, 12),
+    daysOfWeek: parseCronField(fields[4], 0, 6),
+  };
+}
+
+function cronMatches(parsed: ParsedCron, date: Date): boolean {
+  return (
+    parsed.minutes.indexOf(date.getMinutes()) !== -1 &&
+    parsed.hours.indexOf(date.getHours()) !== -1 &&
+    parsed.daysOfMonth.indexOf(date.getDate()) !== -1 &&
+    parsed.months.indexOf(date.getMonth() + 1) !== -1 &&
+    parsed.daysOfWeek.indexOf(date.getDay()) !== -1
+  );
+}
+
+function nextRunTime(cronExpr: string, after?: number): number | null {
+  var parsed = parseCron(cronExpr);
+  if (!parsed) {
+    return null;
+  }
+
+  var d = new Date(after || Date.now());
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+
+  var limit = 366 * 24 * 60;
+  for (var i = 0; i < limit; i++) {
+    if (cronMatches(parsed, d)) {
+      return d.getTime();
+    }
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+
+export function loadSchedules(): void {
+  var path = getSchedulesPath();
+  if (!existsSync(path)) {
+    tasks = [];
+    return;
+  }
+  try {
+    var raw = readFileSync(path, "utf-8");
+    var parsed = JSON.parse(raw) as { tasks?: ScheduledTask[] };
+    tasks = parsed.tasks || [];
+    for (var i = 0; i < tasks.length; i++) {
+      var task = tasks[i];
+      if (task.enabled && task.cron) {
+        task.nextRunAt = nextRunTime(task.cron);
+      }
+    }
+  } catch (err) {
+    console.error("[scheduler] Failed to load schedules:", err);
+    tasks = [];
+  }
+}
+
+function saveSchedules(): void {
+  var path = getSchedulesPath();
+  var dir = join(path, "..");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  var tmp = path + ".tmp";
+  try {
+    writeFileSync(tmp, JSON.stringify({ tasks }, null, 2));
+    renameSync(tmp, path);
+  } catch (err) {
+    console.error("[scheduler] Failed to save schedules:", err);
+  }
+}
+
+function tick(): void {
+  var now = Date.now();
+  var nowMinuteKey = Math.floor(now / 60000);
+
+  for (var i = 0; i < tasks.length; i++) {
+    var task = tasks[i];
+    if (!task.enabled || !task.nextRunAt) {
+      continue;
+    }
+    if (task.nextRunAt > now) {
+      continue;
+    }
+
+    var triggerKey = task.id + "_" + nowMinuteKey;
+    if (lastTriggeredMinute[triggerKey]) {
+      continue;
+    }
+    lastTriggeredMinute[triggerKey] = true;
+
+    var keys = Object.keys(lastTriggeredMinute);
+    for (var k = 0; k < keys.length; k++) {
+      var keyParts = keys[k].split("_");
+      var keyMinute = parseInt(keyParts[keyParts.length - 1], 10);
+      if (keyMinute < nowMinuteKey - 1) {
+        delete lastTriggeredMinute[keys[k]];
+      }
+    }
+
+    task.lastRunAt = now;
+    task.nextRunAt = nextRunTime(task.cron, now);
+    task.updatedAt = now;
+    saveSchedules();
+
+    console.log("[scheduler] Triggering task:", task.name, "(", task.id, ")");
+    broadcast({ type: "scheduler:tasks", tasks: tasks.slice() });
+  }
+}
+
+export function startScheduler(): void {
+  loadSchedules();
+  if (timerId) {
+    return;
+  }
+  timerId = setInterval(function () {
+    tick();
+  }, CHECK_INTERVAL);
+  tick();
+}
+
+export function stopScheduler(): void {
+  if (timerId) {
+    clearInterval(timerId);
+    timerId = null;
+  }
+}
+
+export function listTasks(): ScheduledTask[] {
+  return tasks.slice();
+}
+
+export function createTask(data: {
+  name: string;
+  prompt: string;
+  cron: string;
+  projectSlug: string;
+}): ScheduledTask | null {
+  var parsed = parseCron(data.cron);
+  if (!parsed) {
+    return null;
+  }
+
+  var now = Date.now();
+  var task: ScheduledTask = {
+    id: "task_" + now + "_" + randomBytes(3).toString("hex"),
+    name: data.name,
+    prompt: data.prompt,
+    cron: data.cron,
+    enabled: true,
+    projectSlug: data.projectSlug,
+    createdAt: now,
+    updatedAt: now,
+    lastRunAt: null,
+    nextRunAt: nextRunTime(data.cron),
+  };
+
+  tasks.push(task);
+  saveSchedules();
+  return task;
+}
+
+export function deleteTask(taskId: string): boolean {
+  var idx = -1;
+  for (var i = 0; i < tasks.length; i++) {
+    if (tasks[i].id === taskId) {
+      idx = i;
+      break;
+    }
+  }
+  if (idx === -1) {
+    return false;
+  }
+  tasks.splice(idx, 1);
+  saveSchedules();
+  return true;
+}
+
+export function toggleTask(taskId: string): ScheduledTask | null {
+  var task: ScheduledTask | null = null;
+  for (var i = 0; i < tasks.length; i++) {
+    if (tasks[i].id === taskId) {
+      task = tasks[i];
+      break;
+    }
+  }
+  if (!task) {
+    return null;
+  }
+
+  task.enabled = !task.enabled;
+  task.updatedAt = Date.now();
+  task.nextRunAt = task.enabled ? nextRunTime(task.cron) : null;
+  saveSchedules();
+  return task;
+}

package/server/src/features/sticky-notes.ts

@@ -0,0 +1,102 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getLatticeHome } from "../config";
+import type { StickyNote } from "@lattice/shared";
+
+var notesFile = "";
+var notes: StickyNote[] = [];
+
+function getNotesPath(): string {
+  if (!notesFile) {
+    notesFile = join(getLatticeHome(), "notes.jsonl");
+  }
+  return notesFile;
+}
+
+export function loadNotes(): void {
+  var path = getNotesPath();
+  if (!existsSync(path)) {
+    notes = [];
+    return;
+  }
+  try {
+    var raw = readFileSync(path, "utf-8");
+    var lines = raw.trim().split("\n");
+    notes = [];
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (!line) {
+        continue;
+      }
+      try {
+        var note = JSON.parse(line) as StickyNote;
+        notes.push(note);
+      } catch {
+        // skip malformed line
+      }
+    }
+  } catch (err) {
+    console.error("[sticky-notes] Failed to load notes:", err);
+    notes = [];
+  }
+}
+
+function saveNotes(): void {
+  var path = getNotesPath();
+  var dir = join(path, "..");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  var tmp = path + ".tmp";
+  try {
+    var lines: string[] = [];
+    for (var i = 0; i < notes.length; i++) {
+      lines.push(JSON.stringify(notes[i]));
+    }
+    writeFileSync(tmp, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+    renameSync(tmp, path);
+  } catch (err) {
+    console.error("[sticky-notes] Failed to save notes:", err);
+  }
+}
+
+export function listNotes(): StickyNote[] {
+  return notes.slice();
+}
+
+export function createNote(content: string): StickyNote {
+  var now = Date.now();
+  var note: StickyNote = {
+    id: "note_" + now + "_" + randomBytes(3).toString("hex"),
+    content,
+    createdAt: now,
+    updatedAt: now,
+  };
+  notes.push(note);
+  saveNotes();
+  return note;
+}
+
+export function updateNote(id: string, content: string): StickyNote | null {
+  for (var i = 0; i < notes.length; i++) {
+    if (notes[i].id === id) {
+      notes[i].content = content;
+      notes[i].updatedAt = Date.now();
+      saveNotes();
+      return notes[i];
+    }
+  }
+  return null;
+}
+
+export function deleteNote(id: string): boolean {
+  for (var i = 0; i < notes.length; i++) {
+    if (notes[i].id === id) {
+      notes.splice(i, 1);
+      saveNotes();
+      return true;
+    }
+  }
+  return false;
+}

package/server/src/handlers/chat.ts

@@ -0,0 +1,194 @@
+import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { getProjectBySlug } from "../project/registry";
+import { loadConfig } from "../config";
+import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, buildPermissionRule } from "../project/sdk-bridge";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function formatSdkRule(rule: { toolName: string; ruleContent?: string }): string {
+  if (!rule.ruleContent) return rule.toolName;
+  if (rule.toolName === "Bash") {
+    var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
+    if (firstWord === "curl" || firstWord === "wget") {
+      var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
+      if (urlMatch) {
+        try {
+          var parsed = new URL(urlMatch[0]);
+          return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
+        } catch {}
+      }
+    }
+    return rule.toolName + "(" + firstWord + ":*)";
+  }
+  return rule.toolName + "(" + rule.ruleContent + ")";
+}
+
+function addProjectAllowRules(projectPath: string, suggestions: Array<{ type: string; rules?: Array<{ toolName: string; ruleContent?: string }>; directories?: string[]; behavior?: string }> | undefined, fallbackToolName: string, fallbackInput: Record<string, unknown>): void {
+  var claudeDir = join(projectPath, ".claude");
+  var settingsPath = join(claudeDir, "settings.json");
+
+  var settings: Record<string, unknown> = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.permissions) {
+    settings.permissions = {};
+  }
+  var permissions = settings.permissions as Record<string, unknown>;
+  if (!Array.isArray(permissions.allow)) {
+    permissions.allow = [];
+  }
+  if (!Array.isArray(permissions.additionalDirectories)) {
+    permissions.additionalDirectories = [];
+  }
+  var allowList = permissions.allow as string[];
+  var additionalDirs = permissions.additionalDirectories as string[];
+
+  if (suggestions && suggestions.length > 0) {
+    for (var si = 0; si < suggestions.length; si++) {
+      var suggestion = suggestions[si];
+      if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
+        for (var ri = 0; ri < suggestion.rules.length; ri++) {
+          var rule = formatSdkRule(suggestion.rules[ri]);
+          if (!allowList.includes(rule)) {
+            allowList.push(rule);
+          }
+          if (suggestion.rules[ri].ruleContent) {
+            var ruleDir = suggestion.rules[ri].ruleContent!.replace(/\/\*\*$/, "").replace(/^\//, "");
+            if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
+              additionalDirs.push(ruleDir);
+            }
+          }
+        }
+      }
+      if (suggestion.type === "addDirectories" && suggestion.directories) {
+        for (var di = 0; di < suggestion.directories.length; di++) {
+          if (!additionalDirs.includes(suggestion.directories[di])) {
+            additionalDirs.push(suggestion.directories[di]);
+          }
+        }
+      }
+    }
+  } else {
+    var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
+    if (!allowList.includes(fallbackRule)) {
+      allowList.push(fallbackRule);
+    }
+  }
+
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+}
+
+var activeSessionByClient = new Map<string, { projectSlug: string; sessionId: string }>();
+
+export function setActiveSession(clientId: string, projectSlug: string, sessionId: string): void {
+  activeSessionByClient.set(clientId, { projectSlug, sessionId });
+}
+
+export function clearActiveSession(clientId: string): void {
+  activeSessionByClient.delete(clientId);
+}
+
+export function getActiveSession(clientId: string): { projectSlug: string; sessionId: string } | undefined {
+  return activeSessionByClient.get(clientId);
+}
+
+registerHandler("chat", function (clientId: string, message: ClientMessage) {
+  if (message.type === "chat:send") {
+    var sendMsg = message as ChatSendMessage;
+    var active = activeSessionByClient.get(clientId);
+
+    if (!active) {
+      sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
+      return;
+    }
+
+    var project = getProjectBySlug(active.projectSlug);
+    if (!project) {
+      sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
+      return;
+    }
+
+    var config = loadConfig();
+    var env = Object.assign({}, config.globalEnv, project.env);
+
+    startChatStream({
+      projectSlug: active.projectSlug,
+      sessionId: active.sessionId,
+      text: sendMsg.text,
+      clientId,
+      cwd: project.path,
+      env: Object.keys(env).length > 0 ? env : undefined,
+      model: sendMsg.model,
+      effort: sendMsg.effort as "low" | "medium" | "high" | "max" | undefined,
+    });
+
+    return;
+  }
+
+  if (message.type === "chat:cancel") {
+    sendTo(clientId, { type: "chat:error", message: "Cancel not yet implemented." });
+    return;
+  }
+
+  if (message.type === "chat:permission_response") {
+    var permMsg = message as ChatPermissionResponseMessage;
+    var pending = getPendingPermission(permMsg.requestId);
+    if (!pending) {
+      return;
+    }
+
+    var active = activeSessionByClient.get(clientId);
+
+    if (permMsg.allow) {
+      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
+        addAutoApprovedTool(active.sessionId, pending.toolName);
+      }
+
+      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
+        var project = getProjectBySlug(active.projectSlug);
+        if (project) {
+          addProjectAllowRules(project.path, pending.suggestions as any, pending.toolName, pending.input);
+        }
+        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+      } else {
+        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+      }
+
+      var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
+      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
+    } else {
+      pending.resolve({ behavior: "deny", message: "User denied this operation.", toolUseID: pending.toolUseID });
+      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: "denied" });
+    }
+
+    deletePendingPermission(permMsg.requestId);
+    return;
+  }
+
+  if (message.type === "chat:set_permission_mode") {
+    var modeMsg = message as ChatSetPermissionModeMessage;
+    var activeSession = activeSessionByClient.get(clientId);
+    if (!activeSession) {
+      return;
+    }
+
+    var stream = getActiveStream(activeSession.sessionId);
+    if (stream) {
+      void stream.setPermissionMode(modeMsg.mode);
+    } else {
+      setSessionPermissionOverride(activeSession.sessionId, modeMsg.mode);
+    }
+    return;
+  }
+});

package/server/src/handlers/fs.ts

@@ -0,0 +1,84 @@
+import type { ClientMessage, FsListMessage, FsReadMessage, FsWriteMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { getProjectBySlug } from "../project/registry";
+import { listDirectory, readFile, writeFile } from "../project/file-browser";
+
+var activeProjectByClient = new Map<string, string>();
+
+export function setActiveProject(clientId: string, projectSlug: string): void {
+  activeProjectByClient.set(clientId, projectSlug);
+}
+
+export function clearActiveProject(clientId: string): void {
+  activeProjectByClient.delete(clientId);
+}
+
+registerHandler("fs", function (clientId: string, message: ClientMessage) {
+  if (message.type === "fs:list") {
+    var listMsg = message as FsListMessage;
+    var projectSlug = activeProjectByClient.get(clientId);
+    if (!projectSlug) {
+      sendTo(clientId, { type: "chat:error", message: "No active project for fs:list" });
+      return;
+    }
+
+    var project = getProjectBySlug(projectSlug);
+    if (!project) {
+      sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlug });
+      return;
+    }
+
+    var entries = listDirectory(project.path, listMsg.path);
+    sendTo(clientId, { type: "fs:list_result", path: listMsg.path, entries });
+    return;
+  }
+
+  if (message.type === "fs:read") {
+    var readMsg = message as FsReadMessage;
+    var projectSlugRead = activeProjectByClient.get(clientId);
+    if (!projectSlugRead) {
+      sendTo(clientId, { type: "chat:error", message: "No active project for fs:read" });
+      return;
+    }
+
+    var projectRead = getProjectBySlug(projectSlugRead);
+    if (!projectRead) {
+      sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugRead });
+      return;
+    }
+
+    var content = readFile(projectRead.path, readMsg.path);
+    if (content === null) {
+      sendTo(clientId, { type: "chat:error", message: "Cannot read file: " + readMsg.path });
+      return;
+    }
+
+    sendTo(clientId, { type: "fs:read_result", path: readMsg.path, content });
+    return;
+  }
+
+  if (message.type === "fs:write") {
+    var writeMsg = message as FsWriteMessage;
+    var projectSlugWrite = activeProjectByClient.get(clientId);
+    if (!projectSlugWrite) {
+      sendTo(clientId, { type: "chat:error", message: "No active project for fs:write" });
+      return;
+    }
+
+    var projectWrite = getProjectBySlug(projectSlugWrite);
+    if (!projectWrite) {
+      sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugWrite });
+      return;
+    }
+
+    var ok = writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
+    if (!ok) {
+      sendTo(clientId, { type: "chat:error", message: "Cannot write file: " + writeMsg.path });
+      return;
+    }
+
+    broadcast({ type: "fs:changed", path: writeMsg.path });
+    return;
+  }
+});

package/server/src/handlers/loop.ts

@@ -0,0 +1,37 @@
+import type { ClientMessage, LoopStartMessage, LoopStopMessage, LoopStatusRequestMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { startLoop, stopLoop, getLoopStatus } from "../features/ralph-loop";
+
+registerHandler("loop", function (clientId: string, message: ClientMessage) {
+  if (message.type === "loop:start") {
+    var startMsg = message as LoopStartMessage;
+    var loop = startLoop(startMsg.projectSlug);
+    if (!loop) {
+      sendTo(clientId, { type: "chat:error", message: "No PROMPT.md found in .claude/loops/ for this project" });
+      return;
+    }
+    sendTo(clientId, { type: "loop:started", loop });
+    return;
+  }
+
+  if (message.type === "loop:stop") {
+    var stopMsg = message as LoopStopMessage;
+    var stopped = stopLoop(stopMsg.loopId);
+    if (!stopped) {
+      sendTo(clientId, { type: "chat:error", message: "Loop not found or not running" });
+    }
+    return;
+  }
+
+  if (message.type === "loop:status") {
+    var statusMsg = message as LoopStatusRequestMessage;
+    var status = getLoopStatus(statusMsg.loopId);
+    if (!status) {
+      sendTo(clientId, { type: "chat:error", message: "Loop not found" });
+      return;
+    }
+    sendTo(clientId, { type: "loop:status_update", loop: status });
+    return;
+  }
+});