@test328932/test328933 1.0.0

package/src/runtime/llm-worker.js

@@ -0,0 +1,7 @@
+import { WebWorkerMLCEngineHandler } from '@mlc-ai/web-llm'
+
+const handler = new WebWorkerMLCEngineHandler()
+
+self.onmessage = (msg) => {
+  handler.onmessage(msg)
+}

package/src/save-file.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+function handleSaveRequest(req, res, filePath) {
+  if (req.method !== 'POST') {
+    res.statusCode = 405
+    res.end('Method not allowed')
+    return
+  }
+
+  let body = ''
+  req.on('data', chunk => { body += chunk })
+  req.on('end', () => {
+    try {
+      const items = JSON.parse(body)
+      fs.writeFileSync(filePath, JSON.stringify(items, null, 2))
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify({ ok: true }))
+    } catch (e) {
+      res.statusCode = 400
+      res.end(JSON.stringify({ error: e.message }))
+    }
+  })
+}
+
+export default function saveFilePlugin() {
+  let rootDir = ''
+
+  return {
+    name: 'vite-plugin-save-file',
+    configResolved(config) {
+      rootDir = path.resolve(config.root, 'public')
+    },
+    configureServer(server) {
+      server.middlewares.use('/__save-list-items', (req, res) => {
+        if (!fs.existsSync(rootDir)) fs.mkdirSync(rootDir, { recursive: true })
+        handleSaveRequest(req, res, path.join(rootDir, 'listitems.json'))
+      })
+
+      server.middlewares.use('/__save-api-objects', (req, res) => {
+        if (!fs.existsSync(rootDir)) fs.mkdirSync(rootDir, { recursive: true })
+        handleSaveRequest(req, res, path.join(rootDir, 'apiobjects.json'))
+      })
+    },
+  }
+}

package/src/source-compressor.js

@@ -0,0 +1,352 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { parse } from '@babel/parser'
+import traverse from '@babel/traverse'
+import generate from '@babel/generator'
+import * as t from '@babel/types'
+
+const traverseAst = traverse.default ?? traverse
+const generateCode = generate.default ?? generate
+
+const SOURCE_EXTENSIONS = new Set(['.tsx', '.ts', '.jsx', '.js'])
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'public'])
+const SKIP_PATTERNS = [/\.test\./, /\.spec\./, /\.d\.ts$/, /\.config\./]
+
+const TAILWIND_RE = /^[a-z][\w-]*(?:\s+[a-z][\w-/[\]:]*){2,}$/
+const MAX_STRING_LENGTH = 100
+
+// --- File collection ---
+
+function collectSourceFiles(dir, root = dir) {
+  const results = []
+  let entries
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return results
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue
+
+    const abs = path.join(dir, entry.name)
+    const rel = path.relative(root, abs).split(path.sep).join('/')
+
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name)) {
+        results.push(...collectSourceFiles(abs, root))
+      }
+      continue
+    }
+
+    const ext = path.extname(entry.name)
+    if (!SOURCE_EXTENSIONS.has(ext)) continue
+    if (SKIP_PATTERNS.some(p => p.test(entry.name))) continue
+
+    results.push({ abs, rel })
+  }
+
+  return results.sort((a, b) => a.rel.localeCompare(b.rel))
+}
+
+// --- AST transforms ---
+
+function isJSXFile(filename) {
+  return /\.[jt]sx$/.test(filename)
+}
+
+function parseCode(code, filename) {
+  return parse(code, {
+    sourceType: 'module',
+    plugins: [
+      'jsx',
+      ...(filename.endsWith('.ts') || filename.endsWith('.tsx') ? ['typescript'] : []),
+      'decorators-legacy',
+      'classProperties',
+      'optionalChaining',
+      'nullishCoalescingOperator',
+    ],
+  })
+}
+
+function compressFile(code, filename) {
+  let ast
+  try {
+    ast = parseCode(code, filename)
+  } catch {
+    // If we can't parse it, return the raw code truncated
+    return `// [parse error — raw source]\n${code.slice(0, 500)}`
+  }
+
+  traverseAst(ast, {
+    // 1. Strip import paths — keep bindings only
+    ImportDeclaration(nodePath) {
+      // import { X, Y } from 'some/long/path' → import { X, Y }
+      // Keep the source for relative imports (they show project structure)
+      const src = nodePath.node.source.value
+      if (!src.startsWith('.') && !src.startsWith('/')) {
+        // External package — shorten to just the package name
+        const parts = src.split('/')
+        const pkgName = src.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+        nodePath.node.source.value = pkgName
+      }
+    },
+
+    // 2. Strip Tailwind className values + strip large inline style objects
+    JSXAttribute(nodePath) {
+      const attrName = nodePath.node.name.name
+
+      if (attrName === 'className') {
+        const value = nodePath.node.value
+        if (t.isStringLiteral(value) && TAILWIND_RE.test(value.value)) {
+          value.value = '[tw]'
+          return
+        }
+        if (t.isJSXExpressionContainer(value)) {
+          const expr = value.expression
+          if (t.isTemplateLiteral(expr)) {
+            const hasTw = expr.quasis.some(q => TAILWIND_RE.test(q.value.raw.trim()))
+            if (hasTw) {
+              nodePath.node.value = t.stringLiteral('[tw]')
+            }
+          }
+          if (t.isCallExpression(expr)) {
+            const callee = expr.callee
+            const name = t.isIdentifier(callee) ? callee.name : null
+            if (name === 'cn' || name === 'clsx' || name === 'cva' || name === 'twMerge') {
+              nodePath.node.value = t.stringLiteral('[tw]')
+            }
+          }
+        }
+        return
+      }
+
+      if (attrName === 'style') {
+        const value = nodePath.node.value
+        if (!t.isJSXExpressionContainer(value)) return
+        const expr = value.expression
+        if (t.isObjectExpression(expr) && expr.properties.length > 2) {
+          value.expression = t.identifier('styles')
+        }
+      }
+    },
+
+    // 3. Collapse SVG elements
+    JSXElement(nodePath) {
+      const opening = nodePath.node.openingElement
+      if (t.isJSXIdentifier(opening.name) && opening.name.name === 'svg') {
+        nodePath.replaceWith(
+          t.jsxElement(
+            t.jsxOpeningElement(t.jsxIdentifier('svg'), [], true),
+            null,
+            [],
+            true,
+          ),
+        )
+        nodePath.skip()
+      }
+    },
+
+    // 4. Truncate long string literals
+    StringLiteral(nodePath) {
+      if (nodePath.node.value.length > MAX_STRING_LENGTH) {
+        if (t.isImportDeclaration(nodePath.parent)) return
+        nodePath.node.value = nodePath.node.value.slice(0, MAX_STRING_LENGTH) + '...'
+      }
+    },
+
+    TemplateLiteral(nodePath) {
+      for (const quasi of nodePath.node.quasis) {
+        if (quasi.value.raw.length > MAX_STRING_LENGTH) {
+          const truncated = quasi.value.raw.slice(0, MAX_STRING_LENGTH) + '...'
+          quasi.value = { raw: truncated, cooked: truncated }
+        }
+      }
+    },
+
+    // 6. Strip comments
+    enter(nodePath) {
+      const node = nodePath.node
+      if (node.leadingComments) node.leadingComments = []
+      if (node.trailingComments) node.trailingComments = []
+      if (node.innerComments) node.innerComments = []
+    },
+
+    // 7. Strip type annotations (keep simple ones, remove complex generics)
+    TSTypeAnnotation(nodePath) {
+      const annotation = nodePath.node.typeAnnotation
+      // Keep simple types like : string, : number, : boolean
+      if (t.isTSStringKeyword(annotation)) return
+      if (t.isTSNumberKeyword(annotation)) return
+      if (t.isTSBooleanKeyword(annotation)) return
+      // Remove complex types
+      if (t.isTSUnionType(annotation) || t.isTSIntersectionType(annotation) ||
+          t.isTSTypeLiteral(annotation) || t.isTSMappedType(annotation) ||
+          t.isTSConditionalType(annotation)) {
+        nodePath.remove()
+      }
+    },
+
+    // Remove type-only exports and interfaces
+    TSInterfaceDeclaration(nodePath) {
+      nodePath.remove()
+    },
+    TSTypeAliasDeclaration(nodePath) {
+      nodePath.remove()
+    },
+  })
+
+  const { code: output } = generateCode(ast, {
+    retainLines: false,
+    compact: false,
+    concise: true,
+    comments: false,
+  })
+
+  return output
+}
+
+// --- Repeated JSX siblings collapse ---
+
+function collapseRepeatedJSX(code) {
+  // Post-process: detect consecutive identical JSX tags and collapse
+  // This is simpler as a text transform after generation
+  const lines = code.split('\n')
+  const result = []
+  let repeatTag = null
+  let repeatCount = 0
+
+  for (const line of lines) {
+    const tagMatch = line.match(/^\s*<(\w+)\s/)
+    if (tagMatch && tagMatch[1] === repeatTag) {
+      repeatCount++
+      continue
+    }
+
+    if (repeatCount > 0) {
+      result.push(`{/* ×${repeatCount} more <${repeatTag}/> */}`)
+      repeatCount = 0
+    }
+
+    repeatTag = tagMatch ? tagMatch[1] : null
+    result.push(line)
+  }
+
+  if (repeatCount > 0) {
+    result.push(`{/* ×${repeatCount} more <${repeatTag}/> */}`)
+  }
+
+  return result.join('\n')
+}
+
+// --- Main build ---
+
+function buildCompressedSource(srcDir) {
+  const files = collectSourceFiles(srcDir)
+  const parts = []
+
+  for (const file of files) {
+    let code
+    try {
+      code = fs.readFileSync(file.abs, 'utf8')
+    } catch {
+      continue
+    }
+
+    if (!code.trim()) continue
+
+    const compressed = compressFile(code, file.rel)
+    const collapsed = collapseRepeatedJSX(compressed)
+
+    parts.push(`--- ${file.rel} ---\n${collapsed}`)
+  }
+
+  return parts.join('\n\n')
+}
+
+// --- Vite plugin ---
+
+function sendJson(res, statusCode, body) {
+  res.statusCode = statusCode
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify(body))
+}
+
+export default function sourceCompressorPlugin() {
+  let srcDir = ''
+  let cached = null
+
+  function invalidate() {
+    cached = null
+  }
+
+  function getCompressed() {
+    if (cached === null) {
+      cached = buildCompressedSource(srcDir)
+    }
+    return cached
+  }
+
+  return {
+    name: 'vite-plugin-source-compressor',
+    apply: 'serve',
+
+    configResolved(config) {
+      srcDir = path.resolve(config.root, 'src')
+    },
+
+    configureServer(server) {
+      console.log('[source-compressor] plugin loaded, srcDir:', srcDir)
+
+      // HMR channel — Vite 6 uses server.hot, older uses server.ws
+      const hmr = server.hot ?? server.ws
+
+      const handleChange = (filePath) => {
+        if (!filePath.startsWith(srcDir)) return
+        const ext = path.extname(filePath)
+        if (!SOURCE_EXTENSIONS.has(ext)) return
+        invalidate()
+        console.log('[source-compressor] invalidated, file changed:', path.relative(srcDir, filePath))
+
+        hmr.send({
+          type: 'custom',
+          event: 'source-compressed:update',
+          data: { timestamp: Date.now() },
+        })
+      }
+
+      server.watcher.on('change', handleChange)
+      server.watcher.on('add', handleChange)
+      server.watcher.on('unlink', handleChange)
+
+      // Build initial cache eagerly
+      try {
+        getCompressed()
+        console.log('[source-compressor] initial build done,', cached.length, 'chars')
+      } catch (e) {
+        console.error('[source-compressor] initial build failed:', e.message)
+      }
+
+      server.middlewares.use('/__source/compressed', (req, res) => {
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { error: 'Method not allowed' })
+          return
+        }
+
+        try {
+          const compressed = getCompressed()
+          sendJson(res, 200, {
+            content: compressed,
+            charCount: compressed.length,
+            timestamp: Date.now(),
+          })
+        } catch (error) {
+          console.error('[source-compressor] error:', error)
+          sendJson(res, 500, {
+            error: error instanceof Error ? error.message : 'Compression failed',
+          })
+        }
+      })
+    },
+  }
+}

package/src/source-explorer.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const BLOCKED_DIRS = new Set(['node_modules', 'dist'])
+
+function isBlockedPathSegment(segment) {
+  return BLOCKED_DIRS.has(segment) || /^\.env($|\.)/.test(segment)
+}
+
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join('/')
+}
+
+function listSourceTree(rootDir, currentDir = rootDir) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true })
+  const visibleEntries = entries
+    .filter(entry => !isBlockedPathSegment(entry.name))
+    .sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) return -1
+      if (!a.isDirectory() && b.isDirectory()) return 1
+      return a.name.localeCompare(b.name)
+    })
+
+  return visibleEntries.map(entry => {
+    const absolutePath = path.join(currentDir, entry.name)
+    const relativePath = toPosixPath(path.relative(rootDir, absolutePath))
+
+    if (entry.isDirectory()) {
+      return {
+        name: entry.name,
+        path: relativePath,
+        type: 'dir',
+        children: listSourceTree(rootDir, absolutePath),
+      }
+    }
+
+    return {
+      name: entry.name,
+      path: relativePath,
+      type: 'file',
+    }
+  })
+}
+
+function sendJson(res, statusCode, body) {
+  res.statusCode = statusCode
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify(body))
+}
+
+function isSafeSourcePath(relativePath) {
+  if (!relativePath || relativePath.includes('\0')) return false
+  if (path.isAbsolute(relativePath)) return false
+
+  const normalized = path.posix.normalize(relativePath.replace(/\\/g, '/'))
+  if (normalized === '..' || normalized.startsWith('../')) return false
+
+  const segments = normalized.split('/').filter(Boolean)
+  if (segments.some(isBlockedPathSegment)) return false
+
+  return true
+}
+
+export default function sourceExplorerPlugin() {
+  return {
+    name: 'vite-plugin-source-explorer',
+    apply: 'serve',
+    configureServer(server) {
+      const sourceRoot = path.resolve(process.cwd(), 'src')
+
+      server.middlewares.use('/__source/tree', (req, res) => {
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { error: 'Method not allowed' })
+          return
+        }
+
+        try {
+          const tree = listSourceTree(sourceRoot)
+          sendJson(res, 200, tree)
+        } catch (error) {
+          sendJson(res, 500, {
+            error: error instanceof Error ? error.message : 'Failed to read source tree',
+          })
+        }
+      })
+
+      server.middlewares.use('/__source/file', (req, res) => {
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { error: 'Method not allowed' })
+          return
+        }
+
+        const requestUrl = new URL(req.url ?? '/', 'http://localhost')
+        const requestedPath = requestUrl.searchParams.get('path') ?? ''
+
+        if (!isSafeSourcePath(requestedPath)) {
+          sendJson(res, 400, { error: 'Invalid or blocked path' })
+          return
+        }
+
+        const normalizedPath = path.posix.normalize(requestedPath.replace(/\\/g, '/'))
+        const absolutePath = path.resolve(sourceRoot, normalizedPath)
+        const safeRootPrefix = `${sourceRoot}${path.sep}`
+        if (absolutePath !== sourceRoot && !absolutePath.startsWith(safeRootPrefix)) {
+          sendJson(res, 403, { error: 'Path is outside source root' })
+          return
+        }
+
+        try {
+          const stats = fs.statSync(absolutePath)
+          if (!stats.isFile()) {
+            sendJson(res, 400, { error: 'Path must point to a file' })
+            return
+          }
+
+          const content = fs.readFileSync(absolutePath, 'utf8')
+          sendJson(res, 200, {
+            path: toPosixPath(path.relative(sourceRoot, absolutePath)),
+            content,
+          })
+        } catch (error) {
+          sendJson(res, 404, {
+            error: error instanceof Error ? error.message : 'File not found',
+          })
+        }
+      })
+    },
+  }
+}