framer-code-link 0.2.0 → 0.2.1

package/src/utils/hash-tracker.ts

@@ -1,79 +0,0 @@
-/**
- * Hash tracking utilities for echo prevention
- *
- * The hash tracker prevents echo loops by remembering content hashes
- * and skipping watcher events for files we just wrote.
- */
-
-import { createHash } from "crypto"
-
-export interface HashTracker {
-  remember(filePath: string, content: string): void
-  shouldSkip(filePath: string, content: string): boolean
-  forget(filePath: string): void
-  clear(): void
-  markDelete(filePath: string): void
-  shouldSkipDelete(filePath: string): boolean
-  clearDelete(filePath: string): void
-}
-
-/**
- * Creates a hash tracker instance for echo prevention
- */
-export function createHashTracker(): HashTracker {
-  const hashes = new Map<string, string>()
-  const pendingDeletes = new Map<string, ReturnType<typeof setTimeout>>()
-
-  return {
-    remember(filePath: string, content: string): void {
-      const hash = hashContent(content)
-      hashes.set(filePath, hash)
-    },
-
-    shouldSkip(filePath: string, content: string): boolean {
-      const currentHash = hashContent(content)
-      const storedHash = hashes.get(filePath)
-      return storedHash === currentHash
-    },
-
-    forget(filePath: string): void {
-      hashes.delete(filePath)
-    },
-
-    clear(): void {
-      hashes.clear()
-    },
-
-    markDelete(filePath: string): void {
-      const existingTimer = pendingDeletes.get(filePath)
-      if (existingTimer) {
-        clearTimeout(existingTimer)
-      }
-
-      const timeout = setTimeout(() => {
-        pendingDeletes.delete(filePath)
-      }, 5000)
-
-      pendingDeletes.set(filePath, timeout)
-    },
-
-    shouldSkipDelete(filePath: string): boolean {
-      return pendingDeletes.has(filePath)
-    },
-
-    clearDelete(filePath: string): void {
-      const timeout = pendingDeletes.get(filePath)
-      if (timeout) {
-        clearTimeout(timeout)
-      }
-      pendingDeletes.delete(filePath)
-    },
-  }
-}
-
-/**
- * Computes a SHA256 hash of file content for comparison
- */
-function hashContent(content: string): string {
-  return createHash("sha256").update(content).digest("hex")
-}

package/src/utils/imports.ts

@@ -1,62 +0,0 @@
-/**
- * Utilities for parsing import statements and extracting package information.
- */
-
-export interface ImportInfo {
-  type: "npm" | "url"
-  name: string
-  raw: string
-}
-
-/**
- * Extract npm and URL-based imports from source code.
- */
-export function extractImports(code: string): ImportInfo[] {
-  const imports: ImportInfo[] = []
-  const seen = new Set<string>()
-
-  const npmRegex =
-    /import\s+(?:(?:\*\s+as\s+\w+)|(?:\w+)|(?:\{[^}]*\}))\s+from\s+['"]([^.\/][^'"]+)['"]/g
-  const urlRegex =
-    /import\s+(?:(?:\*\s+as\s+\w+)|(?:\w+)|(?:\{[^}]*\}))\s+from\s+['"]https?:\/\/[^'"]+['"]/g
-
-  let match: RegExpExecArray | null
-
-  while ((match = npmRegex.exec(code)) !== null) {
-    const pkgName = match[1]
-    const normalized = pkgName.startsWith("@")
-      ? pkgName.split("/").slice(0, 2).join("/")
-      : pkgName.split("/")[0]
-
-    if (!seen.has(normalized)) {
-      seen.add(normalized)
-      imports.push({
-        type: "npm",
-        name: normalized,
-        raw: match[0],
-      })
-    }
-  }
-
-  while ((match = urlRegex.exec(code)) !== null) {
-    const pkgName = extractPackageFromUrl(match[0])
-    if (pkgName && !seen.has(pkgName)) {
-      seen.add(pkgName)
-      imports.push({
-        type: "url",
-        name: pkgName,
-        raw: match[0],
-      })
-    }
-  }
-
-  return imports
-}
-
-/**
- * Attempt to derive an npm-style package specifier from a URL import.
- */
-export function extractPackageFromUrl(url: string): string | null {
-  const match = url.match(/\/(@?[^@\/]+(?:\/[^@\/]+)?)/)
-  return match?.[1] ?? null
-}

package/src/utils/logging.ts

@@ -1,235 +0,0 @@
-/**
- * Logging utilities for consistent, clean CLI output
- *
- * Features:
- * - Log levels (DEBUG, INFO, WARN, ERROR)
- * - Message deduplication with count suffix (x2), (x3)
- * - Reconnect cycle suppression (collapses rapid disconnect/reconnect spam)
- * - Clean prefixes (no [INFO] clutter at default level)
- * - Colored startup banner
- */
-
-import pc from "picocolors"
-
-export enum LogLevel {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-}
-
-let currentLevel = LogLevel.INFO
-
-// Deduplication state
-let lastMessage = ""
-let lastMessageCount = 0
-const CLEAR_LINE = "\u001b[2K"
-const MOVE_CURSOR_UP = "\u001b[1A"
-
-// Redraw the previous line with the updated message/count.
-function rewriteLastLine(text: string): void {
-  if (process.stdout.isTTY) {
-    process.stdout.write(`${MOVE_CURSOR_UP}\r${CLEAR_LINE}${text}\n`)
-  } else {
-    // Fallback for non-TTY (e.g., piping output) – just emit the line.
-    process.stdout.write(`${text}\n`)
-  }
-}
-
-// Reconnect suppression state
-let disconnectTimer: ReturnType<typeof setTimeout> | null = null
-let isShowingDisconnect = false
-let hadRecentDisconnect = false
-// Only show disconnect if down for 4+ seconds
-// Allows for swtiching between Canvas and Code Editor
-const DISCONNECT_DELAY_MS = 4000
-
-export function setLogLevel(level: LogLevel): void {
-  currentLevel = level
-}
-
-export function getLogLevel(): LogLevel {
-  return currentLevel
-}
-
-function dedupeMessage(message: string, count: number): void {
-  rewriteLastLine(`${message} ${pc.dim(`(x${count})`)}`)
-}
-
-/**
- * Flush any pending deduplicated message
- */
-function flushDedupe(): void {
-  if (lastMessageCount > 1) {
-    dedupeMessage(lastMessage, lastMessageCount)
-  }
-  lastMessage = ""
-  lastMessageCount = 0
-}
-
-/**
- * Log with deduplication - repeated messages within window get counted
- */
-function logWithDedupe(message: string, writer: () => void): void {
-  if (message === lastMessage) {
-    // Same message - increment count regardless of gap
-    lastMessageCount++
-    // Overwrite previous line (move cursor up, clear, rewrite)
-    dedupeMessage(message, lastMessageCount)
-    return
-  }
-
-  lastMessage = message
-  lastMessageCount = 1
-  writer()
-}
-
-/**
- * Print the startup banner - one colored line
- */
-export function banner(version: string, port: number): void {
-  console.log()
-  let message = `  ${pc.cyan(pc.bold("⚡ Code Link"))} ${pc.dim(`v${version}`)}`
-  if (currentLevel <= LogLevel.DEBUG) {
-    message += `  ${pc.dim("Port")} ${pc.yellow(port)}`
-  }
-  console.log(message)
-  console.log()
-}
-
-/**
- * Debug-level logging - only shown with --verbose flag
- */
-export function debug(message: string, ...args: unknown[]): void {
-  if (currentLevel <= LogLevel.DEBUG) {
-    console.debug(pc.dim(`[DEBUG] ${message}`), ...args)
-  }
-}
-
-/**
- * Info-level logging - shown by default, no prefix
- */
-export function info(message: string, ...args: unknown[]): void {
-  if (currentLevel <= LogLevel.INFO) {
-    const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message
-    logWithDedupe(formatted, () => console.log(formatted))
-  }
-}
-
-/**
- * Warning-level logging
- */
-export function warn(message: string, ...args: unknown[]): void {
-  if (currentLevel <= LogLevel.WARN) {
-    if (message === lastMessage) return // Skip exact duplicates silently
-    flushDedupe()
-    lastMessage = message
-    lastMessageCount = 1
-    console.warn(pc.yellow(`⚠ ${message}`), ...args)
-  }
-}
-
-/**
- * Error-level logging
- */
-export function error(message: string, ...args: unknown[]): void {
-  if (currentLevel <= LogLevel.ERROR) {
-    flushDedupe()
-    console.error(pc.red(`✗ ${message}`), ...args)
-  }
-}
-
-/**
- * Success message with checkmark
- */
-export function success(message: string, ...args: unknown[]): void {
-  if (currentLevel <= LogLevel.INFO) {
-    flushDedupe()
-    console.log(pc.green(`✓ ${message}`), ...args)
-  }
-}
-
-/**
- * File sync indicators
- */
-export function fileDown(fileName: string): void {
-  if (currentLevel <= LogLevel.INFO) {
-    const msg = `  ${pc.blue("↓")} ${fileName}`
-    logWithDedupe(msg, () => console.log(msg))
-  }
-}
-
-export function fileUp(fileName: string): void {
-  if (currentLevel <= LogLevel.INFO) {
-    const msg = `  ${pc.green("↑")} ${fileName}`
-    logWithDedupe(msg, () => console.log(msg))
-  }
-}
-
-export function fileDelete(fileName: string): void {
-  if (currentLevel <= LogLevel.INFO) {
-    const msg = `  ${pc.red("×")} ${fileName}`
-    logWithDedupe(msg, () => console.log(msg))
-  }
-}
-
-/**
- * Status message (dimmed, for "watching for changes..." etc)
- */
-export function status(message: string): void {
-  if (currentLevel <= LogLevel.INFO) {
-    flushDedupe()
-    console.log(pc.dim(`  ${message}`))
-  }
-}
-
-/**
- * Schedule a delayed disconnect message.
- * If reconnection happens before the delay, the message is cancelled.
- */
-export function scheduleDisconnectMessage(callback: () => void): void {
-  // Clear any existing timer
-  if (disconnectTimer) {
-    clearTimeout(disconnectTimer)
-  }
-
-  hadRecentDisconnect = true
-  isShowingDisconnect = false
-  disconnectTimer = setTimeout(() => {
-    isShowingDisconnect = true
-    callback()
-    disconnectTimer = null
-  }, DISCONNECT_DELAY_MS)
-}
-
-/**
- * Cancel pending disconnect message (called on reconnect)
- */
-export function cancelDisconnectMessage(): void {
-  if (disconnectTimer) {
-    clearTimeout(disconnectTimer)
-    disconnectTimer = null
-  }
-}
-
-/**
- * Check if we showed a disconnect message (need to show reconnect)
- */
-export function didShowDisconnect(): boolean {
-  return isShowingDisconnect
-}
-
-/**
- * Check if we recently saw a disconnect (even if the message was suppressed)
- */
-export function wasRecentlyDisconnected(): boolean {
-  return hadRecentDisconnect
-}
-
-/**
- * Reset disconnect state after successful reconnect
- */
-export function resetDisconnectState(): void {
-  isShowingDisconnect = false
-  hadRecentDisconnect = false
-}

package/src/utils/paths.ts

@@ -1,76 +0,0 @@
-/**
- * Path manipulation utilities
- */
-
-import path from "path"
-import { fileURLToPath } from "url"
-
-/**
- * Resolves a path relative to the project directory
- */
-export function resolveProjectPath(
-  projectDir: string,
-  relativePath: string
-): string {
-  return path.resolve(projectDir, relativePath)
-}
-
-/**
- * Gets a relative path from the project directory
- */
-export function getRelativePath(
-  projectDir: string,
-  absolutePath: string
-): string {
-  return path.relative(projectDir, absolutePath)
-}
-
-/**
- * Ensures a directory path ends with a separator
- */
-export function ensureTrailingSlash(dirPath: string): string {
-  return dirPath.endsWith(path.sep) ? dirPath : dirPath + path.sep
-}
-
-/**
- * Gets the directory name from an import.meta.url (ESM)
- */
-export function getDirname(importMetaUrl: string): string {
-  return path.dirname(fileURLToPath(importMetaUrl))
-}
-
-/**
- * Normalizes a file path by:
- * - Converting backslashes to forward slashes
- * - Resolving . and .. segments
- * - Removing duplicate slashes
- */
-export function normalizePath(filePath: string): string {
-  if (!filePath) return ""
-
-  const isAbsolute = filePath.startsWith("/")
-  const segments = filePath.replace(/\\/g, "/").split("/")
-  const stack: string[] = []
-
-  for (const segment of segments) {
-    if (!segment || segment === ".") {
-      continue
-    }
-
-    if (segment === "..") {
-      if (stack.length > 0) {
-        stack.pop()
-      }
-      continue
-    }
-
-    stack.push(segment)
-  }
-
-  const normalized = stack.join("/")
-  if (isAbsolute) {
-    return `/${normalized}`
-  }
-
-  return normalized
-}

package/src/utils/project.ts

@@ -1,120 +0,0 @@
-import fs from "fs/promises"
-import path from "path"
-import { shortProjectHash } from "@code-link/shared"
-
-interface PackageJson {
-  shortProjectHash?: string // derived short id (8 chars base58)
-  framerProjectHash?: string // full 64-char hex hash from Framer API
-  framerProjectName?: string
-  name?: string
-  version?: string
-  [key: string]: unknown
-}
-
-export function toPackageName(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .replace(/-+/g, "-")
-}
-
-export function toDirName(name: string): string {
-  return name
-    .replace(/[^a-zA-Z0-9- ]/g, "-")
-    .replace(/^[-\s]+|[-\s]+$/g, "")
-    .replace(/-+/g, "-")
-}
-
-export async function getProjectHashFromCwd(): Promise<string | null> {
-  try {
-    const packageJsonPath = path.join(process.cwd(), "package.json")
-    const content = await fs.readFile(packageJsonPath, "utf-8")
-    const pkg = JSON.parse(content) as PackageJson
-    // Return short id for port derivation
-    return pkg.shortProjectHash ?? null
-  } catch {
-    return null
-  }
-}
-
-export async function findOrCreateProjectDir(
-  projectHash: string,
-  projectName?: string,
-  explicitDir?: string
-): Promise<string> {
-  if (explicitDir) {
-    const resolved = path.resolve(explicitDir)
-    await fs.mkdir(path.join(resolved, "files"), { recursive: true })
-    return resolved
-  }
-
-  const cwd = process.cwd()
-  const existing = await findExistingProjectDir(cwd, projectHash)
-  if (existing) {
-    return existing
-  }
-
-  if (!projectName) {
-    throw new Error(
-      "Project name is required when creating a new workspace. Pass --name <project name>."
-    )
-  }
-
-  const dirName = toDirName(projectName)
-  const pkgName = toPackageName(projectName)
-  const shortId = shortProjectHash(projectHash)
-  const projectDir = path.join(cwd, dirName || shortId)
-
-  await fs.mkdir(path.join(projectDir, "files"), { recursive: true })
-  const pkg: PackageJson = {
-    name: pkgName || shortId,
-    version: "1.0.0",
-    private: true,
-    shortProjectHash: shortId,
-    framerProjectHash: projectHash,
-    framerProjectName: projectName,
-  }
-  await fs.writeFile(
-    path.join(projectDir, "package.json"),
-    JSON.stringify(pkg, null, 2)
-  )
-
-  return projectDir
-}
-
-async function findExistingProjectDir(
-  baseDir: string,
-  projectHash: string
-): Promise<string | null> {
-  const candidate = path.join(baseDir, "package.json")
-  if (await matchesProject(candidate, projectHash)) {
-    return baseDir
-  }
-
-  const entries = await fs.readdir(baseDir, { withFileTypes: true })
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const dir = path.join(baseDir, entry.name)
-    if (await matchesProject(path.join(dir, "package.json"), projectHash)) {
-      return dir
-    }
-  }
-
-  return null
-}
-
-async function matchesProject(
-  packageJsonPath: string,
-  projectHash: string
-): Promise<boolean> {
-  try {
-    const content = await fs.readFile(packageJsonPath, "utf-8")
-    const pkg = JSON.parse(content) as PackageJson
-    const inputShort = shortProjectHash(projectHash)
-    // Match on short id (handles both full hash input and short id input)
-    return pkg.shortProjectHash === inputShort
-  } catch {
-    return false
-  }
-}

package/src/utils/state-persistence.ts

@@ -1,138 +0,0 @@
-/**
- * State persistence helper
- *
- * Persists last sync timestamps along with content hashes.
- * We only trust persisted timestamps if the file content hasn't changed
- * (hash matches), because that means the file wasn't edited while CLI was offline.
- */
-
-import fs from "fs/promises"
-import path from "path"
-import { createHash } from "crypto"
-import { debug, warn } from "./logging.js"
-import { normalizePath } from "./paths.js"
-
-export interface PersistedFileState {
-  timestamp: number // Remote modified timestamp from last sync
-  contentHash: string // Hash of content when we received the sync confirmation
-}
-
-interface PersistedState {
-  version: number
-  files: Record<string, PersistedFileState>
-}
-
-const STATE_FILE_NAME = ".framer-sync-state.json"
-// Version 2: State machine rewrite - only stores hashes/timestamps for local edit detection
-// Breaking change: users must delete old .framer-sync-state.json files
-const CURRENT_VERSION = 2
-const SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json"]
-const DEFAULT_EXTENSION = ".tsx"
-
-export function normalizePersistedFileName(fileName: string): string {
-  let normalized = normalizePath(fileName.trim())
-  if (
-    !SUPPORTED_EXTENSIONS.some((ext) => normalized.toLowerCase().endsWith(ext))
-  ) {
-    normalized = `${normalized}${DEFAULT_EXTENSION}`
-  }
-  return normalized
-}
-
-/**
- * Hash file content to detect changes
- */
-export function hashFileContent(content: string): string {
-  return createHash("sha256").update(content, "utf-8").digest("hex")
-}
-
-/**
- * Load persisted state from disk
- */
-export async function loadPersistedState(
-  projectDir: string
-): Promise<Map<string, PersistedFileState>> {
-  const statePath = path.join(projectDir, STATE_FILE_NAME)
-  const result = new Map<string, PersistedFileState>()
-
-  try {
-    const data = await fs.readFile(statePath, "utf-8")
-    const parsed: PersistedState = JSON.parse(data)
-
-    if (parsed.version !== CURRENT_VERSION) {
-      warn(
-        `State file version mismatch (expected ${CURRENT_VERSION}, got ${parsed.version}). Ignoring persisted state.`
-      )
-      return result
-    }
-
-    for (const [fileName, state] of Object.entries(parsed.files)) {
-      const normalizedName = normalizePersistedFileName(fileName)
-      if (normalizedName !== fileName) {
-        debug(
-          `Normalized persisted key "${fileName}" -> "${normalizedName}" for compatibility`
-        )
-      }
-      result.set(normalizedName, state)
-    }
-
-    debug(`Loaded persisted state for ${result.size} files`)
-    return result
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      debug("No persisted state found (first run)")
-      return result
-    }
-    warn("Failed to load persisted state:", err)
-    return result
-  }
-}
-
-/**
- * Save current state to disk
- */
-export async function savePersistedState(
-  projectDir: string,
-  state: Map<string, PersistedFileState>
-): Promise<void> {
-  const statePath = path.join(projectDir, STATE_FILE_NAME)
-
-  const persistedState: PersistedState = {
-    version: CURRENT_VERSION,
-    files: Object.fromEntries(state.entries()),
-  }
-
-  try {
-    await fs.writeFile(statePath, JSON.stringify(persistedState, null, 2))
-    debug(`Saved persisted state for ${state.size} files`)
-  } catch (err) {
-    warn("Failed to save persisted state:", err)
-  }
-}
-
-/**
- * Validate persisted timestamp against current file content
- * Returns the timestamp only if the content hash matches (file unchanged)
- */
-export function validatePersistedTimestamp(
-  persistedState: PersistedFileState | undefined,
-  currentContent: string
-): number | null {
-  if (!persistedState) {
-    return null
-  }
-
-  const currentHash = hashFileContent(currentContent)
-
-  if (currentHash === persistedState.contentHash) {
-    debug(
-      `Hash matches for persisted state - trusting timestamp ${persistedState.timestamp}`
-    )
-    return persistedState.timestamp
-  }
-
-  debug(
-    "Hash mismatch for persisted state - file was edited while CLI was offline"
-  )
-  return null
-}