@tscircuit/cli 0.0.393 → 0.1.1

package/lib/cli-config/TypedConfigStore.ts

@@ -0,0 +1,50 @@
+export interface TypedConfigstore<T extends Record<string, any>> {
+  /**
+   * Get the path to the config file. Can be used to show the user
+   * where it is, or better, open it for them.
+   */
+  path: string
+
+  /**
+   * Get all items as an object or replace the current config with an object.
+   */
+  all: any
+
+  /**
+   * Get the item count
+   */
+  size: number
+
+  /**
+   * Get an item
+   * @param key The string key to get
+   * @return The contents of the config from key $key
+   */
+  get(key: keyof T): any
+
+  /**
+   * Set an item
+   * @param key The string key
+   * @param val The value to set
+   */
+  set<K extends keyof T>(key: K, val: T[K]): void
+
+  /**
+   * Determines if a key is present in the config
+   * @param key The string key to test for
+   * @return True if the key is present
+   */
+  has(key: keyof T): boolean
+
+  /**
+   * Delete an item.
+   * @param key The key to delete
+   */
+  delete(key: keyof T): void
+
+  /**
+   * Clear the config.
+   * Equivalent to <code>Configstore.all = {};</code>
+   */
+  clear(): void
+}

package/lib/cli-config/index.ts

@@ -0,0 +1,16 @@
+import Configstore from "configstore"
+import type { TypedConfigstore } from "./TypedConfigStore"
+
+export interface CliConfig {
+  sessionToken?: string
+  githubUsername?: string
+  registryApiUrl?: string
+}
+
+export const cliConfig: TypedConfigstore<CliConfig> = new Configstore(
+  "tscircuit",
+)
+
+export const getRegistryApiUrl = (): string => {
+  return cliConfig.get("registryApiUrl") ?? "https://registry-api.tscircuit.com"
+}

package/lib/dependency-analysis/DependencyAnalyzer.ts

@@ -0,0 +1,129 @@
+import * as ts from "typescript"
+import * as path from "path"
+import * as fs from "fs"
+
+interface DependencyAnalyzerOptions {
+  baseDir: string
+  includeNodeModules?: boolean
+  includeCssModules?: boolean
+}
+
+class DependencyAnalyzer {
+  private readonly baseDir: string
+  private readonly includeNodeModules: boolean
+  private readonly includeCssModules: boolean
+  private readonly cache: Map<string, Set<string>> = new Map()
+
+  constructor(options: DependencyAnalyzerOptions) {
+    this.baseDir = options.baseDir
+    this.includeNodeModules = options.includeNodeModules ?? false
+    this.includeCssModules = options.includeCssModules ?? true
+  }
+
+  public analyze(filePath: string): Set<string> {
+    if (this.cache.has(filePath)) {
+      return this.cache.get(filePath)!
+    }
+
+    const dependencies = new Set<string>()
+    const sourceFile = this.createSourceFile(filePath)
+
+    if (!sourceFile) {
+      return dependencies
+    }
+
+    this.visitNode(sourceFile, dependencies)
+    this.cache.set(filePath, dependencies)
+
+    return dependencies
+  }
+
+  private createSourceFile(filePath: string): ts.SourceFile | null {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8")
+      return ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true,
+      )
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error)
+      return null
+    }
+  }
+
+  private visitNode(node: ts.Node, dependencies: Set<string>): void {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const importPath = moduleSpecifier.text
+        this.addDependency(importPath, dependencies)
+      }
+    }
+
+    // Check for dynamic imports
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      const argument = node.arguments[0]
+      if (argument && ts.isStringLiteral(argument)) {
+        this.addDependency(argument.text, dependencies)
+      }
+    }
+
+    ts.forEachChild(node, (child) => this.visitNode(child, dependencies))
+  }
+
+  private addDependency(importPath: string, dependencies: Set<string>): void {
+    // Skip node_modules unless explicitly included
+    if (!this.includeNodeModules && importPath.startsWith("node_modules")) {
+      return
+    }
+
+    // Handle CSS modules if enabled
+    if (this.includeCssModules && importPath.endsWith(".css")) {
+      const resolvedPath = this.resolvePath(importPath)
+      if (resolvedPath) {
+        dependencies.add(resolvedPath)
+      }
+      return
+    }
+
+    // Resolve relative imports
+    if (importPath.startsWith(".")) {
+      const resolvedPath = this.resolvePath(importPath)
+      if (resolvedPath) {
+        dependencies.add(resolvedPath)
+      }
+    }
+  }
+
+  private resolvePath(importPath: string): string | null {
+    try {
+      const extensions = [".tsx", ".ts", ".jsx", ".js", ".css"]
+      const resolvedPath = path.resolve(this.baseDir, importPath)
+
+      // Try exact path first
+      if (fs.existsSync(resolvedPath)) {
+        return resolvedPath
+      }
+
+      // Try with extensions
+      for (const ext of extensions) {
+        const pathWithExt = resolvedPath + ext
+        if (fs.existsSync(pathWithExt)) {
+          return pathWithExt
+        }
+      }
+
+      return null
+    } catch (error) {
+      console.error(`Error resolving path ${importPath}:`, error)
+      return null
+    }
+  }
+}
+
+export { DependencyAnalyzer, type DependencyAnalyzerOptions }

package/lib/dependency-analysis/getLocalFileDependencies.ts

@@ -0,0 +1,101 @@
+import * as ts from "typescript"
+import * as path from "path"
+import * as fs from "fs"
+
+function getLocalFileDependencies(pathToTsxFile: string): string[] {
+  // Ensure absolute path
+  const absolutePath = path.resolve(pathToTsxFile)
+  const baseDir = path.dirname(absolutePath)
+
+  // Read and parse the file
+  const content = fs.readFileSync(absolutePath, "utf-8")
+  const sourceFile = ts.createSourceFile(
+    absolutePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+  )
+
+  const dependencies = new Set<string>()
+
+  // Recursively visit nodes to find imports
+  function visit(node: ts.Node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const importPath = moduleSpecifier.text
+        // Only process local imports (starting with . or ..)
+        if (importPath.startsWith(".")) {
+          resolveAndAddDependency(importPath)
+        }
+      }
+    }
+
+    // Handle dynamic imports
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      const argument = node.arguments[0]
+      if (argument && ts.isStringLiteral(argument)) {
+        const importPath = argument.text
+        if (importPath.startsWith(".")) {
+          resolveAndAddDependency(importPath)
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit)
+  }
+
+  // Helper to resolve and add dependency paths
+  function resolveAndAddDependency(importPath: string) {
+    const extensions = [
+      ".tsx",
+      ".ts",
+      ".jsx",
+      ".js",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+    ]
+    let resolvedPath = path.resolve(baseDir, importPath)
+
+    // Check if path exists as-is
+    if (fs.existsSync(resolvedPath)) {
+      dependencies.add(resolvedPath)
+      return
+    }
+
+    // Try with extensions
+    for (const ext of extensions) {
+      const pathWithExt = resolvedPath + ext
+      if (fs.existsSync(pathWithExt)) {
+        dependencies.add(pathWithExt)
+        return
+      }
+    }
+
+    // Check for index files in directories
+    if (
+      fs.existsSync(resolvedPath) &&
+      fs.statSync(resolvedPath).isDirectory()
+    ) {
+      for (const ext of extensions) {
+        const indexPath = path.join(resolvedPath, `index${ext}`)
+        if (fs.existsSync(indexPath)) {
+          dependencies.add(indexPath)
+          return
+        }
+      }
+    }
+  }
+
+  // Start the traversal
+  visit(sourceFile)
+
+  return Array.from(dependencies)
+}
+
+export { getLocalFileDependencies }

package/lib/dependency-analysis/installNodeModuleTypes.ts

@@ -0,0 +1,74 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import * as ts from "typescript"
+
+interface SnippetApiResponse {
+  snippet: {
+    dts: string
+  }
+}
+
+export async function installTypes(snippetPath: string) {
+  const content = fs.readFileSync(snippetPath, "utf-8")
+  const sourceFile = ts.createSourceFile(
+    snippetPath,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+  )
+
+  const imports: string[] = []
+
+  function visit(node: ts.Node) {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const importPath = moduleSpecifier.text
+        if (importPath.startsWith("@tsci/")) {
+          imports.push(importPath)
+        }
+      }
+    }
+    ts.forEachChild(node, visit)
+  }
+
+  visit(sourceFile)
+
+  let projectRoot = path.dirname(snippetPath)
+  while (projectRoot !== path.parse(projectRoot).root) {
+    if (fs.existsSync(path.join(projectRoot, "package.json"))) {
+      break
+    }
+    projectRoot = path.dirname(projectRoot)
+  }
+
+  for (const importPath of imports) {
+    const [owner, name] = importPath.replace("@tsci/", "").split(".")
+    try {
+      const response = await fetch(
+        `https://registry-api.tscircuit.com/snippets/get?owner_name=${owner}&unscoped_name=${name}`,
+      )
+
+      if (!response.ok) {
+        console.warn(`Failed to fetch types for ${importPath}`)
+        continue
+      }
+
+      const data: SnippetApiResponse = await response.json()
+
+      if (data.snippet.dts) {
+        const packageDir = path.join(
+          projectRoot,
+          "node_modules",
+          "@tsci",
+          `${owner}.${name}`,
+        )
+        fs.mkdirSync(packageDir, { recursive: true })
+
+        fs.writeFileSync(path.join(packageDir, "index.d.ts"), data.snippet.dts)
+      }
+    } catch (error) {
+      console.warn(`Error fetching types for ${importPath}:`, error)
+    }
+  }
+}

package/lib/index.ts

@@ -0,0 +1,2 @@
+export { createServer } from "./server/createServer"
+export { getLocalFileDependencies } from "./dependency-analysis/getLocalFileDependencies"

package/lib/project-config/index.ts

@@ -0,0 +1,5 @@
+import { cosmiconfigSync } from "cosmiconfig"
+
+const explorer = cosmiconfigSync("tscircuit", {})
+
+export const projectConfigSearchResult = explorer.search()

package/lib/registry-api/endpoint-types.ts

@@ -0,0 +1,20 @@
+export interface EndpointResponse {
+  "sessions/login_page/create": {
+    login_page: {
+      login_page_id: string
+      login_page_auth_token: string
+      url: string
+    }
+  }
+  "sessions/login_page/get": {
+    login_page: {
+      was_login_successful: boolean
+      is_expired: boolean
+    }
+  }
+  "sessions/login_page/exchange_for_cli_session": {
+    session: {
+      token: string
+    }
+  }
+}

package/lib/registry-api/get-ky.ts

@@ -0,0 +1,30 @@
+import { getRegistryApiUrl } from "lib/cli-config"
+import ky, { type AfterResponseHook } from "ky"
+
+const prettyResponseErrorHook: AfterResponseHook = async (
+  _request,
+  _options,
+  response,
+) => {
+  if (!response.ok) {
+    try {
+      const errorData = await response.json()
+      throw new Error(
+        `FAIL [${response.status}]: ${_request.method} ${
+          new URL(_request.url).pathname
+        } \n\n ${JSON.stringify(errorData, null, 2)}`,
+      )
+    } catch (e) {
+      //ignore, allow the error to be thrown
+    }
+  }
+}
+
+export const getKy = () => {
+  return ky.create({
+    prefixUrl: getRegistryApiUrl(),
+    hooks: {
+      afterResponse: [prettyResponseErrorHook],
+    },
+  })
+}

package/lib/server/EventsWatcher.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from "events"
+
+interface Event {
+  event_id: string
+  created_at: string
+  event_type: string
+  [key: string]: any
+}
+
+interface EventsResponse {
+  event_list: Event[]
+}
+
+export class EventsWatcher extends EventEmitter {
+  private lastPollTime: string
+  private pollInterval: number
+  private baseUrl: string
+  private polling = false
+  private timeoutId?: NodeJS.Timeout
+
+  constructor(baseUrl = "http://localhost:3000", pollInterval = 1000) {
+    super()
+    this.baseUrl = baseUrl
+    this.pollInterval = pollInterval
+    this.lastPollTime = new Date().toISOString()
+  }
+
+  async start() {
+    if (this.polling) return
+    this.polling = true
+    await this.poll()
+  }
+
+  stop() {
+    this.polling = false
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId)
+    }
+  }
+
+  private async poll() {
+    if (!this.polling) return
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/events/list?since=${encodeURIComponent(this.lastPollTime)}`,
+      )
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`)
+      }
+
+      const data: EventsResponse = await response.json()
+
+      // Update last poll time to latest event or current time
+      const latestEvent = data.event_list[data.event_list.length - 1]
+      this.lastPollTime = latestEvent
+        ? latestEvent.created_at
+        : new Date().toISOString()
+
+      // Emit events in chronological order
+      data.event_list.forEach((event) => {
+        this.emit(event.event_type, event)
+        this.emit("*", event)
+      })
+    } catch (error) {
+      this.emit("error", error)
+    }
+    // Schedule next poll
+    this.timeoutId = globalThis.setTimeout(
+      () => this.poll(),
+      this.pollInterval,
+    ) as unknown as NodeJS.Timeout
+  }
+}

package/lib/server/createServer.ts

@@ -0,0 +1,62 @@
+import * as http from "node:http"
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { getNodeHandler } from "winterspec/adapters/node"
+// @ts-ignore
+import winterspecBundle from "@tscircuit/file-server/dist/bundle.js"
+import { getIndex } from "../site/getIndex"
+
+export const createServer = async (port: number = 3000) => {
+  const fileServerHandler = getNodeHandler(winterspecBundle as any, {})
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url!, `http://${req.headers.host}`)
+
+    if (url.pathname === "/standalone.min.js") {
+      const standaloneFilePath =
+        process.env.RUNFRAME_STANDALONE_FILE_PATH ||
+        path.resolve(
+          process.cwd(),
+          "node_modules",
+          "@tscircuit/runframe/dist/standalone.min.js",
+        )
+
+      try {
+        const content = fs.readFileSync(standaloneFilePath, "utf8")
+        res.writeHead(200, {
+          "Content-Type": "application/javascript; charset=utf-8",
+        })
+        res.end(content)
+        return
+      } catch (error) {
+        console.error("Error serving standalone.min.js:", error)
+        res.writeHead(404)
+        res.end("File not found")
+        return
+      }
+    }
+
+    if (url.pathname === "/") {
+      const html = await getIndex()
+      res.writeHead(200, { "Content-Type": "text/html" })
+      res.end(html)
+      return
+    }
+
+    if (url.pathname.startsWith("/api/")) {
+      req.url = req.url!.replace("/api/", "/")
+      fileServerHandler(req, res)
+      return
+    }
+
+    res.writeHead(404)
+    res.end("Not found")
+  })
+
+  return new Promise<void>((resolve) => {
+    server.listen(port, () => {
+      console.log(`Server running at http://localhost:${port}`)
+      resolve()
+    })
+  })
+}

package/lib/site/getIndex.ts

@@ -0,0 +1,18 @@
+import pkg from "../../package.json"
+
+export const getIndex = async () => {
+  return `<html>
+    <head>
+    </head>
+    <body>
+      <script src="https://cdn.tailwindcss.com"></script>
+      <div id="root">loading...</div>
+      <script>
+      globalThis.process = { env: { NODE_ENV: "production" } }
+      </script>
+      <script src="/standalone.min.js"></script>
+    </body>
+  </html>`
+}
+
+// <script src="https://cdn.jsdelivr.net/npm/@tscircuit/runframe@${pkg.dependencies["@tscircuit/runframe"].replace(/^[^0-9]+/, "")}/dist/standalone.min.js"></script>