@arach/lattices 0.2.0 → 0.6.1

package/bin/lattices-build

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# lattices-build - explicit dev/package/dist build entry points
+
+set -euo pipefail
+
+SCRIPT_PATH="$(readlink -f "$0" 2>/dev/null || python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$0")"
+ROOT="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+
+DEV_APPS_DIR="${LATTICES_DEV_APPS_DIR:-$HOME/Applications/dev/Lattices}"
+DEV_BUNDLE="${LATTICES_DEV_APP:-$DEV_APPS_DIR/Lattices.app}"
+DEV_BUNDLE_ID="${LATTICES_DEV_BUNDLE_ID:-dev.lattices.app.dev}"
+RELEASE_BUNDLE="$ROOT/apps/mac/Lattices.app"
+RELEASE_BUNDLE_ID="dev.lattices.app"
+DIST_BUNDLE="$ROOT/dist/Lattices.app"
+DIST_DMG="$ROOT/dist/Lattices.dmg"
+PROD_INSTALL_BUNDLE="/Applications/Lattices.app"
+
+green() { printf "\033[32m%s\033[0m\n" "$*"; }
+dim()   { printf "\033[2m%s\033[0m\n" "$*"; }
+red()   { printf "\033[31m%s\033[0m\n" "$*"; }
+
+usage() {
+    cat <<EOF
+lattices-build - build Lattices without mixing dev and release identities
+
+Usage:
+  bin/lattices-build dev           Build/install dev app
+  bin/lattices-build dev:restart   Build/install/relaunch dev app
+  bin/lattices-build package       Build repo app bundle for npm packaging
+  bin/lattices-build dist          Build signed/notarized release DMG
+  bin/lattices-build dist:local    Build local release DMG without notarizing
+  bin/lattices-build where         Show canonical paths and bundle ids
+
+Channels:
+  dev      $DEV_BUNDLE_ID -> $DEV_BUNDLE
+  release  $RELEASE_BUNDLE_ID -> $PROD_INSTALL_BUNDLE via $DIST_DMG
+EOF
+}
+
+plist_value() {
+    local app="$1"
+    local key="$2"
+    [ -d "$app" ] || return 0
+    /usr/bin/defaults read "$app/Contents/Info.plist" "$key" 2>/dev/null || true
+}
+
+show_app() {
+    local label="$1"
+    local app="$2"
+
+    echo "$label"
+    echo "  path: $app"
+    if [ -d "$app" ]; then
+        echo "  bundle id: $(plist_value "$app" CFBundleIdentifier)"
+        echo "  channel:   $(plist_value "$app" LatticesBuildChannel)"
+        echo "  built at:  $(plist_value "$app" LatticesBuildTimestamp)"
+    else
+        echo "  status:    not built"
+    fi
+}
+
+cmd_dev() {
+    "$ROOT/bin/lattices-dev" build
+    show_app "Dev app" "$DEV_BUNDLE"
+    green "Dev permission target: $DEV_BUNDLE"
+}
+
+cmd_dev_restart() {
+    "$ROOT/bin/lattices-dev" restart
+    show_app "Running dev app" "$DEV_BUNDLE"
+}
+
+cmd_package() {
+    if ! command -v bun >/dev/null 2>&1; then
+        red "bun is required for package builds."
+        exit 1
+    fi
+
+    bun "$ROOT/bin/lattices-app.ts" build
+    show_app "Package app bundle" "$RELEASE_BUNDLE"
+    green "Package bundle ready: $RELEASE_BUNDLE"
+}
+
+cmd_dist() {
+    "$ROOT/tools/release/build-dmg.sh" "$@"
+    show_app "Release app artifact" "$DIST_BUNDLE"
+    [ -f "$DIST_DMG" ] && ls -lh "$DIST_DMG"
+}
+
+cmd_dist_local() {
+    LATTICES_SKIP_NOTARIZE=1 "$ROOT/tools/release/build-dmg.sh" "$@"
+    show_app "Local release app artifact" "$DIST_BUNDLE"
+    [ -f "$DIST_DMG" ] && ls -lh "$DIST_DMG"
+}
+
+cmd_where() {
+    show_app "Dev app" "$DEV_BUNDLE"
+    echo "  expected bundle id: $DEV_BUNDLE_ID"
+    echo
+    show_app "Package app bundle" "$RELEASE_BUNDLE"
+    echo "  expected bundle id: $RELEASE_BUNDLE_ID"
+    echo
+    show_app "Release app artifact" "$DIST_BUNDLE"
+    echo "  expected install target: $PROD_INSTALL_BUNDLE"
+    [ -f "$DIST_DMG" ] && echo "  dmg: $DIST_DMG"
+}
+
+cmd="${1:-help}"
+shift || true
+
+case "$cmd" in
+    dev)         cmd_dev ;;
+    dev:restart|restart) cmd_dev_restart ;;
+    package)     cmd_package ;;
+    dist)        cmd_dist "$@" ;;
+    dist:local)  cmd_dist_local "$@" ;;
+    where)       cmd_where ;;
+    help|-h|--help) usage ;;
+    *)
+        red "Unknown command: $cmd"
+        echo
+        usage
+        exit 1
+        ;;
+esac

package/bin/lattices-build-env.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+/**
+ * lattices-build-env — declarative build-feature resolver.
+ *
+ * Mirrors openscout's `hkit` style: an app names *features* in a manifest
+ * (apps/mac/build.json), never raw env vars. The feature → build-env mapping
+ * lives in the catalog below, so every build entrypoint (package / dev / dist)
+ * resolves the same way from one source of truth, instead of each hardcoding
+ * its own `HUDSONKIT_WITH_*` flags.
+ *
+ *   import { resolveBuildEnv } from "./lattices-build-env";  // TS callers
+ *   eval "$(bun bin/lattices-build-env.ts shell)"            // bash callers
+ *   bun bin/lattices-build-env.ts json                       // inspect
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Feature catalog: feature name -> build env HudsonKit gates on at SwiftPM
+// manifest-eval time. HudsonVoice (Vox/Parakeet dictation) is an optional
+// backend HudsonKit only declares when HUDSONKIT_WITH_VOICE=1 is set at build
+// time. Name a *feature* here; never sprinkle the env var across build scripts.
+export const FEATURE_CATALOG: Record<string, { env: Record<string, string>; note: string }> = {
+  voice: { env: { HUDSONKIT_WITH_VOICE: "1" }, note: "HudsonVoice — Vox/Parakeet dictation" },
+};
+
+export interface BuildManifest {
+  app?: string;
+  features?: string[];
+}
+
+const MANIFEST_PATH = join(import.meta.dir, "../apps/mac/build.json");
+
+export function loadManifest(path = MANIFEST_PATH): BuildManifest {
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf8")) as BuildManifest;
+}
+
+export function resolveFeatureEnv(features: string[] = []): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const f of features) {
+    const entry = FEATURE_CATALOG[f];
+    if (!entry) {
+      throw new Error(
+        `unknown build feature "${f}" — known features: ${Object.keys(FEATURE_CATALOG).join(", ")}`,
+      );
+    }
+    Object.assign(env, entry.env);
+  }
+  return env;
+}
+
+/** Resolve the manifest's declared features into a build-env map. */
+export function resolveBuildEnv(manifestPath?: string): Record<string, string> {
+  const features = loadManifest(manifestPath).features ?? [];
+  const env = resolveFeatureEnv(features);
+  // HudsonKit enables HudsonVoice by default; opt out unless the voice feature is declared.
+  if (!features.includes("voice")) {
+    env.HUDSONKIT_WITH_VOICE = "0";
+  }
+  return env;
+}
+
+// --- CLI: emit the resolved env for shell / json consumers -------------------
+if (import.meta.main) {
+  const mode = process.argv[2] ?? "shell";
+  const env = resolveBuildEnv();
+  if (mode === "json") {
+    console.log(JSON.stringify(env, null, 2));
+  } else if (mode === "shell") {
+    // eval-able by bash: `eval "$(bun bin/lattices-build-env.ts shell)"`
+    for (const [k, v] of Object.entries(env)) console.log(`export ${k}=${JSON.stringify(v)}`);
+  } else {
+    console.error(`lattices-build-env: unknown mode "${mode}" (use: shell | json)`);
+    process.exit(1);
+  }
+}

package/bin/lattices-dev

@@ -0,0 +1,362 @@
+#!/usr/bin/env bash
+# lattices-dev — convenience commands for Lattices development
+
+set -euo pipefail
+
+SCRIPT_PATH="$(readlink -f "$0" 2>/dev/null || python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$0")"
+APP_DIR="$(cd "$(dirname "$SCRIPT_PATH")/../apps/mac" && pwd)"
+ROOT="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+LOG_FILE="$HOME/.lattices/lattices.log"
+BINARY="$APP_DIR/.build/release/Lattices"
+BUILD_BASE="$ROOT/build/macos/Lattices"
+BUNDLE="$BUILD_BASE/Build/Products/Debug/Lattices.app"
+DEV_APPS_DIR="${LATTICES_DEV_APPS_DIR:-$HOME/Applications/dev/Lattices}"
+INSTALL_BUNDLE="${LATTICES_DEV_APP:-$DEV_APPS_DIR/Lattices.app}"
+BUNDLE_BIN="$BUNDLE/Contents/MacOS/Lattices"
+RESOURCES_DIR="$BUNDLE/Contents/Resources"
+ENTITLEMENTS="$APP_DIR/Lattices.entitlements"
+BUNDLE_ID="${LATTICES_DEV_BUNDLE_ID:-dev.lattices.app.dev}"
+ICON="$ROOT/assets/AppIcon.icns"
+TAP_SOUND="$APP_DIR/Resources/tap.wav"
+VERSION="$(node -p "require('$ROOT/package.json').version" 2>/dev/null || echo '0.1.0')"
+GIT_REVISION="$(git -C "$ROOT" rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+BUILD_TIMESTAMP="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+
+red()   { printf "\033[31m%s\033[0m\n" "$*"; }
+green() { printf "\033[32m%s\033[0m\n" "$*"; }
+dim()   { printf "\033[2m%s\033[0m\n" "$*"; }
+
+select_sign_identity() {
+    local identities identity=""
+    identities="$(security find-identity -v -p codesigning 2>/dev/null || true)"
+    # Prefer Developer ID Application: its designated requirement pins to the stable
+    # team OU, so TCC permissions survive rebuilds and Apple Development cert rotations.
+    # Apple Development is only a fallback (its DR pins a specific cert that Xcode rotates,
+    # which silently resets every granted permission). Keep this order in sync with
+    # resolveSigningIdentity() in bin/lattices-app.ts.
+    identity="$(printf '%s\n' "$identities" | sed -n 's/^[[:space:]]*[0-9]*)[[:space:]]*\([A-F0-9]\{40\}\)[[:space:]]*"Developer ID Application:[^"]*".*/\1/p' | head -n 1)"
+    if [ -z "$identity" ]; then
+        identity="$(printf '%s\n' "$identities" | sed -n 's/^[[:space:]]*[0-9]*)[[:space:]]*\([A-F0-9]\{40\}\)[[:space:]]*"Apple Development:[^"]*".*/\1/p' | head -n 1)"
+    fi
+    printf '%s' "$identity"
+}
+
+sign_bundle() {
+    local identity sign_status=0
+    local -a ent_flags=()
+
+    rm -f "$BUNDLE_BIN".cstemp
+
+    if [ -f "$ENTITLEMENTS" ]; then
+        ent_flags=(--entitlements "$ENTITLEMENTS")
+    fi
+
+    identity="$(select_sign_identity)"
+    if [ -n "$identity" ]; then
+        dim "Signing with: $identity"
+        if ! codesign --force --options runtime --deep --sign "$identity" "${ent_flags[@]}" --identifier "$BUNDLE_ID" "$BUNDLE"; then
+            red "Signing with '$identity' failed. Falling back to ad-hoc."
+            sign_status=1
+        fi
+    else
+        sign_status=1
+    fi
+
+    if [ "$sign_status" -ne 0 ]; then
+        dim "No usable signing identity found. Using ad-hoc signature."
+        codesign --force --options runtime --deep --sign - "${ent_flags[@]}" --identifier "$BUNDLE_ID" "$BUNDLE"
+    fi
+
+    rm -f "$BUNDLE_BIN".cstemp
+}
+
+sync_bundle_copy() {
+    local destination="$1"
+
+    mkdir -p "$(dirname "$destination")"
+    rm -rf "$destination"
+    ditto "$BUNDLE" "$destination"
+    xattr -dr com.apple.quarantine "$destination" 2>/dev/null || true
+    touch "$destination" "$destination/Contents"
+}
+
+ensure_install_bundle() {
+    if [ -d "$INSTALL_BUNDLE" ]; then
+        return
+    fi
+
+    if [ -d "$BUNDLE" ]; then
+        sync_bundle_copy "$INSTALL_BUNDLE"
+        return
+    fi
+
+    cmd_build
+}
+
+clear_lattices_drag_cache() {
+    local cache_dir
+
+    for cache_dir in "$HOME"/Library/Caches/com.apple.SwiftUI.Drag-*; do
+        [ -d "$cache_dir" ] || continue
+        if [ -d "$cache_dir/Lattices.app" ]; then
+            rm -rf "$cache_dir/Lattices.app"
+            rmdir "$cache_dir" 2>/dev/null || true
+        fi
+    done
+}
+
+is_bundle_running() {
+    local bundle="$1"
+    local target="$bundle/Contents/MacOS/Lattices"
+    local pid args
+
+    while IFS= read -r pid; do
+        [ -n "$pid" ] || continue
+        args="$(ps -p "$pid" -o args= 2>/dev/null || true)"
+        case "$args" in
+            "$target"|"${target} "*) return 0 ;;
+        esac
+    done < <(pgrep -x Lattices 2>/dev/null || true)
+
+    return 1
+}
+
+is_install_bundle_running() {
+    is_bundle_running "$INSTALL_BUNDLE"
+}
+
+require_build_targets_not_running() {
+    if is_bundle_running "$BUNDLE"; then
+        red "Refusing to rebuild the repo-local app artifact while it is running."
+        dim "Rewriting or re-signing a live Mach-O can make macOS kill it later with Code Signature Invalid."
+        dim "Use \`lattices-dev restart\` to quit, rebuild, and relaunch."
+        exit 1
+    fi
+
+    if is_install_bundle_running; then
+        red "Refusing to install over the running dev app bundle."
+        dim "Rewriting or re-signing a live Mach-O can make macOS kill it later with Code Signature Invalid."
+        dim "Use \`lattices-dev restart\` or \`lattices app restart\` to quit, rebuild, and relaunch."
+        exit 1
+    fi
+}
+
+write_info_plist() {
+    mkdir -p "$BUNDLE/Contents"
+    cat > "$BUNDLE/Contents/Info.plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleIdentifier</key>
+    <string>$BUNDLE_ID</string>
+    <key>CFBundleName</key>
+    <string>Lattices</string>
+    <key>CFBundleDisplayName</key>
+    <string>Lattices</string>
+    <key>CFBundleExecutable</key>
+    <string>Lattices</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleURLTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleURLName</key>
+            <string>$BUNDLE_ID</string>
+            <key>CFBundleURLSchemes</key>
+            <array>
+                <string>lattices</string>
+            </array>
+        </dict>
+    </array>
+    <key>CFBundleVersion</key>
+    <string>$VERSION</string>
+    <key>CFBundleShortVersionString</key>
+    <string>$VERSION</string>
+    <key>LatticesBuildChannel</key>
+    <string>dev</string>
+    <key>LatticesBuildTrack</key>
+    <string>latest</string>
+    <key>LatticesBuildRevision</key>
+    <string>$GIT_REVISION</string>
+    <key>LatticesBuildTimestamp</key>
+    <string>$BUILD_TIMESTAMP</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>13.0</string>
+    <key>LSUIElement</key>
+    <true/>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Lattices uses the microphone for Hudson Voice dictation and voice commands.</string>
+    <key>NSSupportsAutomaticTermination</key>
+    <true/>
+</dict>
+</plist>
+PLIST
+}
+
+cmd_build() {
+    echo "Building dev app..."
+    require_build_targets_not_running
+    # Build features are declared in apps/mac/build.json and resolved to the
+    # HUDSONKIT_WITH_* env HudsonKit gates on (see bin/lattices-build-env.ts).
+    eval "$(bun "$ROOT/bin/lattices-build-env.ts" shell)"
+    cd "$APP_DIR" && swift build -c release
+    # Build into a repo-local dev artifact, then install to a stable app path
+    # that macOS permissions can trust across rebuilds.
+    rm -rf "$BUNDLE"
+    mkdir -p "$(dirname "$BUNDLE_BIN")" "$RESOURCES_DIR"
+    cp "$BINARY" "$BUNDLE_BIN"
+    if [ -f "$ICON" ]; then
+        cp "$ICON" "$RESOURCES_DIR/AppIcon.icns"
+    fi
+    if [ -f "$TAP_SOUND" ]; then
+        cp "$TAP_SOUND" "$RESOURCES_DIR/tap.wav"
+    fi
+    write_info_plist
+    # Re-sign so TCC permissions persist across rebuilds
+    sign_bundle
+    touch "$BUNDLE" "$BUNDLE/Contents"
+    sync_bundle_copy "$INSTALL_BUNDLE"
+    clear_lattices_drag_cache
+    green "Build complete."
+    dim "Installed: $INSTALL_BUNDLE"
+}
+
+cmd_restart() {
+    echo "Restarting Lattices..."
+    /usr/bin/osascript -e 'tell application id "dev.lattices.app.dev" to quit' >/dev/null 2>&1 || true
+    /usr/bin/osascript -e 'tell application id "dev.lattices.app" to quit' >/dev/null 2>&1 || true
+    pkill -x Lattices 2>/dev/null && sleep 1 || true
+    cmd_build
+    open "$INSTALL_BUNDLE" --args --lattices-cli-root "$ROOT" "$@"
+    green "Lattices restarted."
+}
+
+cmd_quit() {
+    /usr/bin/osascript -e 'tell application id "dev.lattices.app.dev" to quit' >/dev/null 2>&1 || true
+    /usr/bin/osascript -e 'tell application id "dev.lattices.app" to quit' >/dev/null 2>&1 || true
+    if pkill -x Lattices 2>/dev/null; then
+        green "Lattices stopped."
+    else
+        dim "Lattices is not running."
+    fi
+}
+
+cmd_launch() {
+    if is_install_bundle_running; then
+        dim "Lattices dev app is already running."
+    else
+        if pgrep -x Lattices >/dev/null 2>&1; then
+            dim "A different Lattices bundle is running. Switching to the dev permission target."
+            cmd_quit
+        fi
+        ensure_install_bundle
+        open "$INSTALL_BUNDLE" --args --lattices-cli-root "$ROOT" "$@"
+        green "Lattices launched."
+    fi
+}
+
+cmd_logs() {
+    if [ -f "$LOG_FILE" ]; then
+        tail -f "$LOG_FILE"
+    else
+        red "No log file at $LOG_FILE"
+    fi
+}
+
+cmd_log() {
+    # Show last N lines (default 30)
+    local n="${1:-30}"
+    if [ -f "$LOG_FILE" ]; then
+        tail -n "$n" "$LOG_FILE"
+    else
+        red "No log file at $LOG_FILE"
+    fi
+}
+
+cmd_clear_logs() {
+    if [ -f "$LOG_FILE" ]; then
+        > "$LOG_FILE"
+        green "Logs cleared."
+    else
+        dim "No log file to clear."
+    fi
+}
+
+cmd_link() {
+    if ! command -v bun >/dev/null 2>&1; then
+        red "bun not found. Install: curl -fsSL https://bun.sh/install | bash"
+        exit 1
+    fi
+    cd "$ROOT"
+    bun link
+    bun link @lattices/cli
+    if command -v lattices >/dev/null 2>&1; then
+        green "Linked. \`lattices\` -> $(command -v lattices)"
+    else
+        red "Linked, but \`lattices\` is not on PATH. Add bun's global bin to PATH:"
+        dim "  export PATH=\"\$HOME/.bun/bin:\$PATH\""
+    fi
+}
+
+cmd_unlink() {
+    if ! command -v bun >/dev/null 2>&1; then
+        red "bun not found."
+        exit 1
+    fi
+    bun remove -g @lattices/cli >/dev/null 2>&1 || true
+    green "Unlinked."
+}
+
+cmd_status() {
+    if pgrep -x Lattices >/dev/null 2>&1; then
+        local pid=$(pgrep -x Lattices)
+        green "Lattices running (pid $pid)"
+    else
+        dim "Lattices is not running."
+    fi
+    if [ -f "$LOG_FILE" ]; then
+        local lines=$(wc -l < "$LOG_FILE" | tr -d ' ')
+        local size=$(du -h "$LOG_FILE" | cut -f1 | tr -d ' ')
+        dim "Log: $lines lines, $size"
+    fi
+    if [ -f "$HOME/.lattices/advisor-learning.jsonl" ]; then
+        local entries=$(wc -l < "$HOME/.lattices/advisor-learning.jsonl" | tr -d ' ')
+        dim "Advisor learning: $entries entries"
+    fi
+}
+
+cmd_help() {
+    echo "lattices-dev — Lattices development commands"
+    echo ""
+    echo "  link         Symlink \`lattices\` to this checkout (bun link)"
+    echo "  unlink       Remove the bun link"
+    echo "  restart      Quit + rebuild + relaunch"
+    echo "  build        Build release binary"
+    echo "  quit         Stop the running app"
+    echo "  launch       Start the app (if not running)"
+    echo "  logs         Tail the log file (live)"
+    echo "  log [N]      Show last N log lines (default 30)"
+    echo "  clear-logs   Clear the log file"
+    echo "  status       Show running state and stats"
+    echo "  help         Show this help"
+}
+
+case "${1:-help}" in
+    link)       cmd_link ;;
+    unlink)     cmd_unlink ;;
+    restart)    cmd_restart "${@:2}" ;;
+    build)      cmd_build ;;
+    quit|stop)  cmd_quit ;;
+    launch|start) cmd_launch "${@:2}" ;;
+    logs)       cmd_logs ;;
+    log)        cmd_log "${2:-30}" ;;
+    clear-logs) cmd_clear_logs ;;
+    status)     cmd_status ;;
+    help|--help|-h) cmd_help ;;
+    *) red "Unknown command: $1"; cmd_help; exit 1 ;;
+esac