@arach/lattices 0.1.0 → 0.2.0

package/app/Sources/Theme.swift

@@ -92,6 +92,41 @@ struct GlassCard: ViewModifier {
     }
 }
 
+struct LiquidGlassCard: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .background(
+                ZStack {
+                    // Base: translucent dark fill
+                    RoundedRectangle(cornerRadius: 10)
+                        .fill(Color.white.opacity(0.04))
+
+                    // Subtle gradient: brighter at top edge for "glass reflection"
+                    RoundedRectangle(cornerRadius: 10)
+                        .fill(
+                            LinearGradient(
+                                colors: [Color.white.opacity(0.06), Color.clear],
+                                startPoint: .top,
+                                endPoint: .center
+                            )
+                        )
+
+                    // Border: top-bright, bottom-dark for depth
+                    RoundedRectangle(cornerRadius: 10)
+                        .strokeBorder(
+                            LinearGradient(
+                                colors: [Color.white.opacity(0.12), Color.white.opacity(0.04)],
+                                startPoint: .top,
+                                endPoint: .bottom
+                            ),
+                            lineWidth: 0.5
+                        )
+                }
+            )
+            .shadow(color: Color.black.opacity(0.2), radius: 8, y: 4)
+    }
+}
+
 struct AngularButton: ViewModifier {
     let color: Color
     var filled: Bool = true
@@ -118,6 +153,10 @@ extension View {
         modifier(GlassCard(isHovered: hovered))
     }
 
+    func liquidGlass() -> some View {
+        modifier(LiquidGlassCard())
+    }
+
     func angularButton(_ color: Color, filled: Bool = true) -> some View {
         modifier(AngularButton(color: color, filled: filled))
     }

package/app/Sources/WindowTiler.swift

@@ -5,6 +5,24 @@ import CoreGraphics
 @_silgen_name("_AXUIElementGetWindow")
 func _AXUIElementGetWindow(_ element: AXUIElement, _ windowID: UnsafeMutablePointer<CGWindowID>) -> AXError
 
+// MARK: - SkyLight Private APIs (instant window moves, no animation)
+// Loaded at runtime via dlsym — graceful fallback if unavailable.
+
+private let skyLight: UnsafeMutableRawPointer? = dlopen("/System/Library/PrivateFrameworks/SkyLight.framework/SkyLight", RTLD_NOW)
+
+private typealias SLSMainConnectionIDFunc = @convention(c) () -> Int32
+private typealias SLSMoveWindowFunc = @convention(c) (Int32, UInt32, UnsafeMutablePointer<CGPoint>) -> CGError
+
+private let _SLSMainConnectionID: SLSMainConnectionIDFunc? = {
+    guard let sl = skyLight, let sym = dlsym(sl, "SLSMainConnectionID") else { return nil }
+    return unsafeBitCast(sym, to: SLSMainConnectionIDFunc.self)
+}()
+
+private let _SLSMoveWindow: SLSMoveWindowFunc? = {
+    guard let sl = skyLight, let sym = dlsym(sl, "SLSMoveWindow") else { return nil }
+    return unsafeBitCast(sym, to: SLSMoveWindowFunc.self)
+}()
+
 // MARK: - Window Highlight Overlay
 
 final class WindowHighlight {
@@ -1626,47 +1644,30 @@ enum WindowTiler {
     /// Tile the frontmost window of any app to a position using AX API.
     /// Works for any application (Finder, Chrome, etc.), not just terminals.
     static func tileFrontmostViaAX(to position: TilePosition) {
-        let diag = DiagnosticLog.shared
-        let t = diag.startTimed("tileFrontmostViaAX: \(position.rawValue)")
-
         // 1. Get frontmost application
-        guard let frontApp = NSWorkspace.shared.frontmostApplication else {
-            diag.warn("tileFrontmostViaAX: no frontmost application")
-            diag.finish(t)
-            return
-        }
-
-        // 2. Skip if Lattices
-        if frontApp.bundleIdentifier == "com.arach.lattices" {
-            diag.info("tileFrontmostViaAX: skipping Lattices")
-            diag.finish(t)
-            return
-        }
+        guard let frontApp = NSWorkspace.shared.frontmostApplication,
+              frontApp.bundleIdentifier != "com.arach.lattices" else { return }
 
-        let pid = frontApp.processIdentifier
-        let appRef = AXUIElementCreateApplication(pid)
+        let appRef = AXUIElementCreateApplication(frontApp.processIdentifier)
 
-        // 3. Get focused window
+        // 2. Get focused window
         var focusedRef: CFTypeRef?
-        let err = AXUIElementCopyAttributeValue(appRef, kAXFocusedWindowAttribute as CFString, &focusedRef)
-        guard err == .success, let axWindow = focusedRef else {
-            diag.warn("tileFrontmostViaAX: no focused window (AX error \(err.rawValue))")
-            diag.finish(t)
-            return
-        }
+        guard AXUIElementCopyAttributeValue(appRef, kAXFocusedWindowAttribute as CFString, &focusedRef) == .success,
+              let axWindow = focusedRef else { return }
 
-        // 4. Read current position → find containing screen
+        let win = axWindow as! AXUIElement
+
+        // 3. Read current position → find containing screen (AX coords: top-left origin)
         var posRef: CFTypeRef?
         var sizeRef: CFTypeRef?
-        AXUIElementCopyAttributeValue(axWindow as! AXUIElement, kAXPositionAttribute as CFString, &posRef)
-        AXUIElementCopyAttributeValue(axWindow as! AXUIElement, kAXSizeAttribute as CFString, &sizeRef)
+        AXUIElementCopyAttributeValue(win, kAXPositionAttribute as CFString, &posRef)
+        AXUIElementCopyAttributeValue(win, kAXSizeAttribute as CFString, &sizeRef)
 
         var currentPos = CGPoint.zero
         var currentSize = CGSize.zero
         if let pv = posRef { AXValueGetValue(pv as! AXValue, .cgPoint, &currentPos) }
         if let sv = sizeRef { AXValueGetValue(sv as! AXValue, .cgSize, &currentSize) }
 
-        // Find screen containing window center (AX uses top-left origin)
         let primaryHeight = NSScreen.screens.first?.frame.height ?? 1080
         let nsCenterX = currentPos.x + currentSize.width / 2
         let nsCenterY = primaryHeight - (currentPos.y + currentSize.height / 2)
@@ -1674,40 +1675,42 @@ enum WindowTiler {
             $0.frame.contains(NSPoint(x: nsCenterX, y: nsCenterY))
         }) ?? NSScreen.main ?? NSScreen.screens[0]
 
-        // 5. Compute target frame
+        // 4. Compute target frame (AX/CGS coords: top-left origin)
         let targetFrame = tileFrame(for: position, on: screen)
-
-        // 6. Double-set: size → pos → size → pos
         var newPos = CGPoint(x: targetFrame.origin.x, y: targetFrame.origin.y)
         var newSize = CGSize(width: targetFrame.width, height: targetFrame.height)
 
-        let win = axWindow as! AXUIElement
-        if let sv = AXValueCreate(.cgSize, &newSize) {
-            AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-        }
-        if let pv = AXValueCreate(.cgPoint, &newPos) {
-            AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-        }
-        if let sv = AXValueCreate(.cgSize, &newSize) {
-            AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
-        }
-        if let pv = AXValueCreate(.cgPoint, &newPos) {
-            AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
-        }
+        // 5. Try SkyLight fast path (instant, no animation)
+        var wid: CGWindowID = 0
+        let hasSkyLight = _SLSMainConnectionID != nil
+            && _SLSMoveWindow != nil
+            && _AXUIElementGetWindow(win, &wid) == .success
+            && wid != 0
 
-        // 7. Flash highlight
-        let nsFrame = NSRect(
-            x: targetFrame.origin.x,
-            y: primaryHeight - targetFrame.origin.y - targetFrame.height,
-            width: targetFrame.width,
-            height: targetFrame.height
-        )
-        DispatchQueue.main.async {
-            WindowHighlight.shared.flash(frame: nsFrame, duration: 0.6)
-        }
+        if hasSkyLight {
+            let cid = _SLSMainConnectionID!()
 
-        diag.success("tileFrontmostViaAX: tiled \(frontApp.localizedName ?? "?") to \(position.rawValue)")
-        diag.finish(t)
+            // Resize via AX (app must handle its own content layout)
+            if let sv = AXValueCreate(.cgSize, &newSize) {
+                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
+            }
+
+            // Move via SkyLight (instant, no animation)
+            if _SLSMoveWindow!(cid, UInt32(wid), &newPos) != .success {
+                // SLS move failed — fall back to AX position
+                if let pv = AXValueCreate(.cgPoint, &newPos) {
+                    AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
+                }
+            }
+        } else {
+            // 6. AX fallback: size then position
+            if let sv = AXValueCreate(.cgSize, &newSize) {
+                AXUIElementSetAttributeValue(win, kAXSizeAttribute as CFString, sv)
+            }
+            if let pv = AXValueCreate(.cgPoint, &newPos) {
+                AXUIElementSetAttributeValue(win, kAXPositionAttribute as CFString, pv)
+            }
+        }
     }
 
     // MARK: - Private

package/bin/lattices-app.js

@@ -19,7 +19,22 @@ const ASSET_NAME = "Lattices-macos-arm64";
 
 function isRunning() {
   try {
-    execSync("pgrep -f Lattices.app", { stdio: "pipe" });
+    execSync("pgrep -x Lattices", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function quit() {
+  try {
+    execSync("pkill -x Lattices", { stdio: "pipe" });
+    // Wait briefly for process to exit
+    try { execSync("sleep 0.5", { stdio: "pipe" }); } catch {}
+    // Force kill if still running
+    if (isRunning()) {
+      execSync("pkill -9 -x Lattices", { stdio: "pipe" });
+    }
     return true;
   } catch {
     return false;
@@ -78,8 +93,8 @@ function buildFromSource() {
   try {
     // Prefer a real signing identity for stable TCC grants; fall back to ad-hoc with fixed identifier
     const identities = execSync("security find-identity -v -p codesigning", { stdio: "pipe" }).toString();
-    const devId = identities.match(/"(Apple Development:[^"]+)"/)?.[1]
-               || identities.match(/"(Developer ID Application:[^"]+)"/)?.[1];
+    const devId = identities.match(/"(Developer ID Application:[^"]+)"/)?.[1]
+               || identities.match(/"(Apple Development:[^"]+)"/)?.[1];
     const signArg = devId ? `'${devId}'` : "-";
     execSync(
       `codesign --force --sign ${signArg} --identifier com.arach.lattices '${bundlePath}'`,
@@ -89,6 +104,8 @@ function buildFromSource() {
     // Non-fatal — app still works, just permissions won't persist across rebuilds
     console.log("Warning: code signing failed — permissions may not persist across rebuilds.");
   }
+  // Update bundle timestamp so Finder shows the correct modified date
+  try { execSync(`touch '${bundlePath}'`, { stdio: "pipe" }); } catch {}
   console.log("Build complete.");
   return true;
 }
@@ -181,15 +198,14 @@ if (cmd === "build") {
   }
   buildFromSource();
 } else if (cmd === "quit") {
-  try {
-    execSync("pkill -f Lattices.app", { stdio: "pipe" });
+  if (quit()) {
     console.log("lattices app stopped.");
-  } catch {
+  } else {
     console.log("lattices app is not running.");
   }
 } else if (cmd === "restart") {
   // Quit → rebuild → relaunch
-  try { execSync("pkill -f Lattices.app", { stdio: "pipe" }); } catch {}
+  quit();
   if (!hasSwift()) {
     console.error("Swift is required. Install with: xcode-select --install");
     process.exit(1);

package/bin/lattices.js

@@ -867,6 +867,122 @@ async function daemonStatusInventory() {
   }
 }
 
+// ── OCR commands ──────────────────────────────────────────────────────
+
+async function ocrCommand(sub, ...rest) {
+  const { daemonCall } = await getDaemonClient();
+
+  if (!sub || sub === "snapshot" || sub === "ls") {
+    // Default: show latest OCR snapshot
+    try {
+      const results = await daemonCall("ocr.snapshot", null, 5000);
+      if (!results.length) {
+        console.log("No OCR results yet. The first scan runs ~60s after launch.");
+        return;
+      }
+      console.log(`\x1b[1mOCR Snapshot\x1b[0m  (${results.length} windows)\n`);
+      for (const r of results) {
+        const age = Math.round((Date.now() / 1000) - r.timestamp);
+        const ageStr = age < 60 ? `${age}s ago` : age < 3600 ? `${Math.floor(age / 60)}m ago` : `${Math.floor(age / 3600)}h ago`;
+        const lines = (r.fullText || "").split("\n").filter(Boolean);
+        const preview = lines.slice(0, 3).map(l => l.length > 80 ? l.slice(0, 77) + "..." : l);
+        console.log(`  \x1b[1m${r.app}\x1b[0m  wid:${r.wid}  \x1b[90m${ageStr}\x1b[0m`);
+        console.log(`    \x1b[36m"${r.title || "(untitled)"}"\x1b[0m`);
+        if (preview.length) {
+          for (const line of preview) {
+            console.log(`    \x1b[90m${line}\x1b[0m`);
+          }
+          if (lines.length > 3) {
+            console.log(`    \x1b[90m… ${lines.length - 3} more lines\x1b[0m`);
+          }
+        } else {
+          console.log(`    \x1b[90m(no text detected)\x1b[0m`);
+        }
+        console.log();
+      }
+    } catch {
+      console.log("Daemon not running. Start with: lattices app");
+    }
+    return;
+  }
+
+  if (sub === "search") {
+    const query = rest.join(" ");
+    if (!query) {
+      console.log("Usage: lattices ocr search <query>");
+      return;
+    }
+    try {
+      const results = await daemonCall("ocr.search", { query }, 5000);
+      if (!results.length) {
+        console.log(`No OCR matches for "${query}".`);
+        return;
+      }
+      console.log(`\x1b[1mOCR Search\x1b[0m  "${query}"  (${results.length} matches)\n`);
+      for (const r of results) {
+        const snippet = r.snippet || r.fullText?.slice(0, 120) || "";
+        console.log(`  \x1b[1m${r.app}\x1b[0m  wid:${r.wid}`);
+        console.log(`    \x1b[36m"${r.title || "(untitled)"}"\x1b[0m`);
+        console.log(`    ${snippet}`);
+        console.log();
+      }
+    } catch (e) {
+      console.log(`Error: ${e.message}`);
+    }
+    return;
+  }
+
+  if (sub === "scan") {
+    try {
+      console.log("Triggering OCR scan...");
+      await daemonCall("ocr.scan", null, 30000);
+      console.log("Scan complete.");
+    } catch (e) {
+      console.log(`Error: ${e.message}`);
+    }
+    return;
+  }
+
+  if (sub === "history") {
+    const wid = parseInt(rest[0], 10);
+    if (isNaN(wid)) {
+      console.log("Usage: lattices ocr history <wid>");
+      return;
+    }
+    try {
+      const results = await daemonCall("ocr.history", { wid }, 5000);
+      if (!results.length) {
+        console.log(`No OCR history for wid:${wid}.`);
+        return;
+      }
+      console.log(`\x1b[1mOCR History\x1b[0m  wid:${wid}  (${results.length} entries)\n`);
+      for (const r of results) {
+        const ts = new Date(r.timestamp * 1000).toLocaleTimeString();
+        const lines = (r.fullText || "").split("\n").filter(Boolean);
+        const preview = lines.slice(0, 2).map(l => l.length > 80 ? l.slice(0, 77) + "..." : l);
+        console.log(`  \x1b[90m${ts}\x1b[0m  \x1b[1m${r.app}\x1b[0m — "${r.title}"`);
+        for (const line of preview) {
+          console.log(`    \x1b[90m${line}\x1b[0m`);
+        }
+        console.log();
+      }
+    } catch (e) {
+      console.log(`Error: ${e.message}`);
+    }
+    return;
+  }
+
+  // Unknown subcommand
+  console.log(`lattices ocr — Screen text recognition
+
+Usage:
+  lattices ocr              Show latest OCR snapshot (all windows)
+  lattices ocr search <q>   Full-text search across all scanned windows
+  lattices ocr scan         Trigger an immediate scan
+  lattices ocr history <id> Show OCR timeline for a window (by wid)
+`);
+}
+
 function printUsage() {
   console.log(`lattices — Claude Code + dev server in tmux
 
@@ -886,6 +1002,10 @@ Usage:
   lattices tile <position>    Tile the frontmost window (left, right, top, etc.)
   lattices distribute         Smart-grid all visible windows (daemon required)
   lattices layer [index]      List layers or switch to a layer (daemon required)
+  lattices ocr                Show latest OCR snapshot (all windows)
+  lattices ocr search <q>     Full-text search screen text
+  lattices ocr scan           Trigger an immediate scan
+  lattices ocr history <wid>  OCR timeline for a specific window
   lattices daemon status      Show daemon status
   lattices app                Launch the menu bar companion app
   lattices app build          Rebuild the menu bar app
@@ -1268,6 +1388,9 @@ switch (command) {
   case "layers":
     await layerCommand(args[1]);
     break;
+  case "ocr":
+    await ocrCommand(args[1], ...args.slice(2));
+    break;
   case "daemon":
     if (args[1] === "status") {
       await daemonStatusCommand();