@arach/lattices 0.2.1 → 0.6.1

package/bin/cli/search.ts

@@ -0,0 +1,141 @@
+import { relativeTime } from "./helpers.ts";
+import { withDaemon, type DaemonClient } from "./daemon.ts";
+
+export interface SearchResult {
+  score: number;
+  window: any;
+  tabs: { tab: number; cwd: string; title: string; hasClaude: boolean; tmuxSession: string }[];
+  reasons: string[];
+}
+
+export interface SearchOptions {
+  sources?: string[];
+  after?: string;
+  before?: string;
+  recency?: boolean;
+  mode?: string;
+}
+
+async function searchWithClient(client: DaemonClient, query: string, opts: SearchOptions = {}): Promise<SearchResult[]> {
+  const { daemonCall } = client;
+  const params: Record<string, any> = { query };
+  if (opts.sources) params.sources = opts.sources;
+  if (opts.after) params.after = opts.after;
+  if (opts.before) params.before = opts.before;
+  if (opts.recency !== undefined) params.recency = opts.recency;
+  if (opts.mode) params.mode = opts.mode;
+  const hits = await daemonCall("lattices.search", params, 10000) as any[];
+  return hits.map((w: any) => ({
+    score: w.score || 0,
+    window: w,
+    tabs: (w.terminalTabs || []).map((t: any) => ({
+      tab: t.tabIndex, cwd: t.cwd, title: t.tabTitle, hasClaude: t.hasClaude, tmuxSession: t.tmuxSession,
+    })),
+    reasons: w.matchSources || [],
+  }));
+}
+
+export async function search(query: string, opts: SearchOptions = {}): Promise<SearchResult[]> {
+  return withDaemon(client => searchWithClient(client, query, opts));
+}
+
+export async function deepSearch(query: string): Promise<SearchResult[]> {
+  return search(query, { sources: ["all"] });
+}
+
+export function printResults(ranked: SearchResult[]): void {
+  if (!ranked.length) return;
+  for (const r of ranked) {
+    const w = r.window;
+    const age = w.lastInteraction ? ` \x1b[2m${relativeTime(w.lastInteraction)}\x1b[0m` : "";
+    console.log(`  \x1b[1m${w.app}\x1b[0m  "${w.title}"  wid:${w.wid}  score:${r.score}  (${r.reasons.join(", ")})${age}`);
+    for (const t of r.tabs) {
+      const claude = t.hasClaude ? " \x1b[32m●\x1b[0m" : "";
+      const tmux = t.tmuxSession ? ` \x1b[36m[${t.tmuxSession}]\x1b[0m` : "";
+      console.log(`    tab ${t.tab}: ${t.cwd || t.title}${claude}${tmux}`);
+    }
+    if (w.ocrSnippet) console.log(`    ocr: "${w.ocrSnippet}"`);
+  }
+  console.log();
+}
+
+export async function searchCommand(
+  query: string | undefined,
+  flags: Set<string>,
+  rawArgs: string[] = []
+): Promise<void> {
+  if (!query) {
+    console.log("Usage: lattices search <query> [--quick | --terminal | --all | --deep | --sources=... | --after=... | --before=... | --json | --wid]");
+    return;
+  }
+
+  const opts: SearchOptions = {};
+
+  const sourcesFlag = rawArgs.find(a => a.startsWith("--sources="));
+  if (sourcesFlag) {
+    opts.sources = sourcesFlag.slice("--sources=".length).split(",");
+  } else if (flags.has("--all") || flags.has("--deep")) {
+    opts.sources = ["all"];
+  } else if (flags.has("--quick")) {
+    opts.sources = ["titles", "apps", "sessions"];
+  } else if (flags.has("--terminal")) {
+    opts.sources = ["terminals"];
+  }
+
+  const afterFlag = rawArgs.find(a => a.startsWith("--after="));
+  if (afterFlag) opts.after = afterFlag.slice("--after=".length);
+  const beforeFlag = rawArgs.find(a => a.startsWith("--before="));
+  if (beforeFlag) opts.before = beforeFlag.slice("--before=".length);
+
+  if (flags.has("--no-recency")) opts.recency = false;
+
+  const ranked = await search(query, opts);
+  const jsonOut = flags.has("--json");
+  const widOnly = flags.has("--wid");
+
+  if (jsonOut) {
+    console.log(JSON.stringify(ranked.map(r => ({
+      wid: r.window.wid, app: r.window.app, title: r.window.title,
+      score: r.score, reasons: r.reasons, tabs: r.tabs, ocrSnippet: r.window.ocrSnippet,
+    })), null, 2));
+    return;
+  }
+
+  if (widOnly) {
+    for (const r of ranked) console.log(r.window.wid);
+    return;
+  }
+
+  if (!ranked.length) {
+    console.log(`No results for "${query}"`);
+    return;
+  }
+
+  printResults(ranked);
+}
+
+export async function placeCommand(query?: string, tilePosition?: string): Promise<void> {
+  if (!query) {
+    console.log("Usage: lattices place <query> [position]");
+    return;
+  }
+
+  await withDaemon(async (client) => {
+    const { daemonCall } = client;
+    const ranked = await searchWithClient(client, query, { sources: ["all"] });
+
+    if (!ranked.length) {
+      console.log(`No window matching "${query}"`);
+      return;
+    }
+
+    const pos = tilePosition || "bottom-right";
+    const win = ranked[0].window;
+    await daemonCall("window.focus", { wid: win.wid });
+    await daemonCall("intents.execute", {
+      intent: "tile_window",
+      slots: { position: pos, wid: win.wid }
+    }, 3000);
+    console.log(`${win.app} "${win.title}" (wid:${win.wid}) → ${pos}`);
+  });
+}

package/bin/cli/session.ts

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import { basename, resolve } from "node:path";
+import { runQuiet } from "./helpers.ts";
+
+export function pathHash(dir: string): string {
+  return createHash("sha256").update(resolve(dir)).digest("hex").slice(0, 6);
+}
+
+export function toSessionName(dir: string): string {
+  const base = basename(dir).replace(/[^a-zA-Z0-9_-]/g, "-");
+  return `${base}-${pathHash(dir)}`;
+}
+
+export function esc(str: string): string {
+  return str.replace(/'/g, "'\\''");
+}
+
+export function slugify(str: string): string {
+  return str
+    .toLowerCase()
+    .replace(/\.app$/i, "")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "app";
+}
+
+export function sessionExists(name: string): boolean {
+  return runQuiet(`tmux has-session -t "${name}" 2>&1`) !== null;
+}
+
+export function toGroupSessionName(groupId: string): string {
+  return `lattices-group-${groupId}`;
+}

package/bin/client.ts

@@ -0,0 +1,17 @@
+// Public API — re-exports from daemon-client for a cleaner import path.
+// Usage: import { daemonCall, isDaemonRunning } from '@arach/lattices'
+// Also published as @lattices/cli for back-compat.
+
+export { daemonCall, isDaemonRunning } from "./daemon-client.ts";
+export {
+  ProjectTwin,
+  createProjectTwin,
+  readOpenScoutRelayContext,
+  type OpenScoutRelayContext,
+  type ProjectTwinEvent,
+  type ProjectTwinInvokeRequest,
+  type ProjectTwinOptions,
+  type ProjectTwinResult,
+  type ProjectTwinState,
+  type ProjectTwinThinkingLevel,
+} from "./project-twin.ts";

package/bin/cua.ts

@@ -0,0 +1,26 @@
+export {
+  click,
+  computerClickParamsSchema,
+  computerClickTransportSchema,
+  computerMagicCursorParamsSchema,
+  computerTreatmentSchema,
+  createCuaClient,
+  cua,
+  cursorEdgeSchema,
+  cursorGlowSchema,
+  cursorIdleSchema,
+  cursorMotionSchema,
+  cursorShapeSchema,
+  cursorSizeSchema,
+  cursorStyleSchema,
+  cursorTrailSchema,
+  cursorTrajectorySchema,
+  magicCursor,
+  type ComputerClickParams,
+  type ComputerMagicCursorParams,
+  type CursorEdge,
+  type CursorGlow,
+  type CursorIdle,
+  type CuaClient,
+  type CuaClientOptions,
+} from "../packages/npm/sdk/cua.mjs";

package/bin/{daemon-client.js → daemon-client.ts}

@@ -1,21 +1,26 @@
 // Lightweight WebSocket client for lattices daemon (ws://127.0.0.1:9399)
 // Uses Node `net` module with manual HTTP upgrade + minimal WS framing.
-// Zero npm dependencies. Requires Node >= 18.
+// Zero npm dependencies.
 
-import { createConnection } from "node:net";
+import { createConnection, type Socket } from "node:net";
 import { randomBytes } from "node:crypto";
 
 const DAEMON_HOST = "127.0.0.1";
 const DAEMON_PORT = 9399;
 
+interface ParsedFrame {
+  payload: string;
+  rest: Buffer<ArrayBuffer>;
+}
+
 /**
  * Send a JSON-RPC-style request to the daemon and return the response.
- * @param {string} method
- * @param {object} [params]
- * @param {number} [timeoutMs=3000]
- * @returns {Promise<object>} The result field from the response
  */
-export async function daemonCall(method, params, timeoutMs = 3000) {
+export async function daemonCall(
+  method: string,
+  params?: Record<string, unknown> | null,
+  timeoutMs = 3000
+): Promise<unknown> {
   const id = randomBytes(4).toString("hex");
   const request = JSON.stringify({ id, method, params: params ?? null });
 
@@ -62,8 +67,8 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
       socket.write(upgrade);
     });
 
-    socket.on("data", (chunk) => {
-      buffer = Buffer.concat([buffer, chunk]);
+    socket.on("data", (chunk: Buffer) => {
+      buffer = Buffer.concat([buffer, chunk]) as Buffer<ArrayBuffer>;
 
       if (!upgraded) {
         const headerEnd = buffer.indexOf("\r\n\r\n");
@@ -82,23 +87,38 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
         sendFrame(socket, request);
       }
 
-      // Try to parse a WebSocket frame from the buffer
-      const result = parseFrame(buffer);
-      if (result) {
+      // The daemon can push broadcast events before the RPC response.
+      // Keep consuming frames until we see our matching response id.
+      while (true) {
+        const result = parseFrame(buffer);
+        if (!result) break;
         buffer = result.rest;
-        if (!settled) {
-          settled = true;
-          cleanup();
-          try {
-            const parsed = JSON.parse(result.payload);
+
+        try {
+          const parsed = JSON.parse(result.payload);
+          if (parsed.event) {
+            continue;
+          }
+          if (parsed.id !== id) {
+            continue;
+          }
+          if (!settled) {
+            settled = true;
+            cleanup();
             if (parsed.error) {
               reject(new Error(parsed.error));
             } else {
               resolve(parsed.result);
             }
-          } catch (e) {
+          }
+          return;
+        } catch {
+          if (!settled) {
+            settled = true;
+            cleanup();
             reject(new Error("Invalid JSON response from daemon"));
           }
+          return;
         }
       }
     });
@@ -107,9 +127,8 @@ export async function daemonCall(method, params, timeoutMs = 3000) {
 
 /**
  * Check if the daemon is reachable.
- * @returns {Promise<boolean>}
  */
-export async function isDaemonRunning() {
+export async function isDaemonRunning(): Promise<boolean> {
   try {
     await daemonCall("daemon.status", null, 1000);
     return true;
@@ -120,12 +139,12 @@ export async function isDaemonRunning() {
 
 // MARK: - WebSocket framing helpers
 
-function sendFrame(socket, text) {
+function sendFrame(socket: Socket, text: string): void {
   const payload = Buffer.from(text, "utf8");
   const mask = randomBytes(4);
   const len = payload.length;
 
-  let header;
+  let header: Buffer;
   if (len < 126) {
     header = Buffer.alloc(2);
     header[0] = 0x81; // FIN + text opcode
@@ -145,17 +164,17 @@ function sendFrame(socket, text) {
   // Mask payload
   const masked = Buffer.alloc(payload.length);
   for (let i = 0; i < payload.length; i++) {
-    masked[i] = payload[i] ^ mask[i % 4];
+    masked[i] = payload[i]! ^ mask[i % 4]!;
   }
 
   socket.write(Buffer.concat([header, mask, masked]));
 }
 
-function parseFrame(buf) {
+function parseFrame(buf: Buffer): ParsedFrame | null {
   if (buf.length < 2) return null;
 
-  const masked = (buf[1] & 0x80) !== 0;
-  let payloadLen = buf[1] & 0x7f;
+  const isMasked = (buf[1]! & 0x80) !== 0;
+  let payloadLen = buf[1]! & 0x7f;
   let offset = 2;
 
   if (payloadLen === 126) {
@@ -168,20 +187,20 @@ function parseFrame(buf) {
     offset = 10;
   }
 
-  if (masked) offset += 4;
+  if (isMasked) offset += 4;
   if (buf.length < offset + payloadLen) return null;
 
   let payload = buf.subarray(offset, offset + payloadLen);
-  if (masked) {
+  if (isMasked) {
     const maskKey = buf.subarray(offset - 4, offset);
     payload = Buffer.alloc(payloadLen);
     for (let i = 0; i < payloadLen; i++) {
-      payload[i] = buf[offset + i] ^ maskKey[i % 4];
+      payload[i] = buf[offset + i]! ^ maskKey[i % 4]!;
     }
   }
 
   return {
     payload: payload.toString("utf8"),
-    rest: buf.subarray(offset + payloadLen),
+    rest: buf.subarray(offset + payloadLen) as Buffer<ArrayBuffer>,
   };
 }

package/bin/handsoff-infer.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+/**
+ * Hands-off inference script — called by HandsOffSession.swift.
+ *
+ * Usage: echo '{"transcript":"tile chrome left","snapshot":{...}}' | bun run bin/handsoff-infer.ts
+ *
+ * Reads JSON from stdin, calls the configured voice inference provider, prints JSON result to stdout.
+ * All logging goes to stderr so it doesn't pollute the JSON output.
+ */
+
+import {
+  buildAssistantContextMessage,
+  buildAssistantSystemPrompt,
+  normalizeAssistantPlan,
+  tryLocalAssistantPlan,
+} from "./assistant-intelligence.ts";
+import { inferJSON, resolveVoiceInferenceOptions } from "./infer.ts";
+
+const INFER_TIMEOUT_MS = 15_000;
+
+// ── Read input from stdin ──────────────────────────────────────────
+
+const input = await Bun.stdin.text();
+const req = JSON.parse(input) as {
+  transcript: string;
+  snapshot: {
+    stageManager?: boolean;
+    smGrouping?: string;
+    activeStage?: Array<{ wid: number; app: string; title: string; frame: string }>;
+    stripApps?: string[];
+    hiddenApps?: string[];
+    currentLayer?: string;
+    screen?: string;
+  };
+  history?: Array<{ role: "user" | "assistant"; content: string }>;
+};
+
+const transcript = req.transcript ?? "";
+const systemPrompt = buildAssistantSystemPrompt();
+const userMessage = buildAssistantContextMessage(transcript, req.snapshot ?? {});
+const voiceInference = resolveVoiceInferenceOptions();
+
+const localPlan = tryLocalAssistantPlan(transcript, req.snapshot ?? {});
+if (localPlan) {
+  console.log(JSON.stringify(localPlan));
+  process.exit(0);
+}
+
+// ── Call inference ──────────────────────────────────────────────────
+
+const messages = (req.history ?? []).map((h) => ({
+  role: h.role as "user" | "assistant",
+  content: h.content,
+}));
+
+const controller = new AbortController();
+const timer = setTimeout(() => controller.abort(), INFER_TIMEOUT_MS);
+
+try {
+  const { data, raw } = await inferJSON(userMessage, {
+    provider: voiceInference.provider,
+    model: voiceInference.model,
+    system: systemPrompt,
+    messages,
+    temperature: 0.2,
+    maxTokens: 512,
+    abortSignal: controller.signal,
+    tag: "hands-off",
+  });
+
+  // Output result as JSON to stdout
+  const plan = normalizeAssistantPlan(data, transcript);
+  const output = {
+    ...plan,
+    _meta: {
+      ...plan._meta,
+      provider: raw.provider,
+      model: raw.model,
+      durationMs: raw.durationMs,
+      tokens: raw.usage?.totalTokens,
+    },
+  };
+
+  console.log(JSON.stringify(output));
+} catch (err: any) {
+  console.log(
+    JSON.stringify({
+      actions: [],
+      spoken: "Sorry, I had trouble processing that.",
+      _meta: { error: err.message },
+    })
+  );
+  process.exitCode = 1;
+} finally {
+  clearTimeout(timer);
+}