@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/fake-snippets-api/routes/api/ai_reviews/create.ts

@@ -1,44 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { aiReviewSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z
-    .object({
-      package_release_id: z.string().optional(),
-    })
-    .optional(),
-  jsonResponse: z.object({
-    ai_review: aiReviewSchema,
-  }),
-})(async (req, ctx) => {
-  const { package_release_id } = req.jsonBody ?? {}
-
-  if (package_release_id) {
-    const release = ctx.db.getPackageReleaseById(package_release_id)
-    if (!release) {
-      return ctx.error(404, {
-        error_code: "package_release_not_found",
-        message: "Package release not found",
-      })
-    }
-    ctx.db.updatePackageRelease({
-      ...release,
-      ai_review_requested: true,
-    })
-  }
-
-  const ai_review = ctx.db.addAiReview({
-    package_release_id: package_release_id,
-    ai_review_text: null,
-    start_processing_at: null,
-    finished_processing_at: null,
-    processing_error: null,
-    created_at: new Date().toISOString(),
-    display_status: "pending",
-  })
-
-  return ctx.json({ ai_review })
-})

package/fake-snippets-api/routes/api/ai_reviews/get.ts

@@ -1,24 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { aiReviewSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  queryParams: z.object({
-    ai_review_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    ai_review: aiReviewSchema,
-  }),
-})(async (req, ctx) => {
-  const { ai_review_id } = req.query
-  const ai_review = ctx.db.getAiReviewById(ai_review_id)
-  if (!ai_review) {
-    return ctx.error(404, {
-      error_code: "ai_review_not_found",
-      message: "AI review not found",
-    })
-  }
-  return ctx.json({ ai_review })
-})

package/fake-snippets-api/routes/api/ai_reviews/list.ts

@@ -1,14 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { aiReviewSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  jsonResponse: z.object({
-    ai_reviews: z.array(aiReviewSchema),
-  }),
-})(async (req, ctx) => {
-  const ai_reviews = ctx.db.listAiReviews()
-  return ctx.json({ ai_reviews })
-})

package/fake-snippets-api/routes/api/aistream/[...anyroute].ts

@@ -1,65 +0,0 @@
-import { ReadableStream } from "stream/web"
-
-export default async (req: Request) => {
-  const url = new URL(req.url)
-  const anthropicApiKey = process.env.ANTHROPIC_API_KEY
-
-  if (!anthropicApiKey) {
-    return new Response("Anthropic API key is not set", { status: 500 })
-  }
-
-  const anthropicUrl =
-    "https://api.anthropic.com" + url.pathname.replace(/^\/api\/ai/, "")
-
-  const headers = new Headers(req.headers)
-  headers.set("x-api-key", `${anthropicApiKey}`)
-  headers.set("Accept", "text/event-stream")
-  headers.set("Cache-Control", "no-cache")
-  headers.set("Connection", "keep-alive")
-
-  console.log("sending request to anthropic")
-  const response = await fetch(anthropicUrl, {
-    method: req.method,
-    headers: headers,
-    body: req.body,
-    // @ts-ignore
-    duplex: "half",
-  })
-
-  // Check if the response is successful
-  if (!response.ok) {
-    return new Response(
-      `Anthropic API returned an error: ${response.status} ${response.statusText}`,
-      {
-        status: response.status,
-      },
-    )
-  }
-
-  // Create a ReadableStream to process the response
-  const stream = new ReadableStream({
-    async start(controller) {
-      const reader = response.body!.getReader()
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          controller.enqueue(value)
-        }
-      } finally {
-        reader.releaseLock()
-        controller.close()
-      }
-    },
-  })
-
-  // Return a streaming response
-  return new Response(stream as any, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  })
-}

package/fake-snippets-api/routes/api/autocomplete/create_autocomplete.ts

@@ -1,16 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    prefix: z.string(),
-    suffix: z.string(),
-  }),
-  jsonResponse: z.object({
-    prediction: z.string(),
-  }),
-})(async (req, ctx) => {
-  return ctx.json({ prediction: "{/* mock autocomplete prediction */}" })
-})

package/fake-snippets-api/routes/api/bug_reports/create.ts

@@ -1,43 +0,0 @@
-import { bugReportSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-const requestSchema = z
-  .object({
-    text: z.string().optional(),
-    is_auto_deleted: z.boolean().optional(),
-    delete_at: z.string().datetime().optional(),
-  })
-  .superRefine((data, ctx) => {
-    if (data.is_auto_deleted && !data.delete_at) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "delete_at is required when is_auto_deleted is true",
-        path: ["delete_at"],
-      })
-    }
-  })
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: requestSchema,
-  jsonResponse: z.object({
-    ok: z.literal(true),
-    bug_report: bugReportSchema,
-  }),
-})(async (req, ctx) => {
-  const { text, is_auto_deleted = false, delete_at } = req.jsonBody
-
-  const bugReport = ctx.db.addBugReport({
-    reporter_account_id: ctx.auth.account_id,
-    text: text ?? null,
-    is_auto_deleted,
-    delete_at: is_auto_deleted ? delete_at : null,
-  })
-
-  return ctx.json({
-    ok: true,
-    bug_report: bugReport,
-  })
-})

package/fake-snippets-api/routes/api/bug_reports/upload_file.ts

@@ -1,113 +0,0 @@
-import { Buffer } from "node:buffer"
-import { bugReportFileResponseSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { normalizeProjectFilePathAndValidate } from "fake-snippets-api/utils/normalizeProjectFilePath"
-import { z } from "zod"
-
-const requestSchema = z
-  .object({
-    bug_report_id: z.string().uuid(),
-    file_path: z.string(),
-    content_mimetype: z.string().optional(),
-    content_text: z.string().optional(),
-    content_base64: z.string().optional(),
-  })
-  .superRefine((data, ctx) => {
-    if (data.content_text !== undefined && data.content_base64 !== undefined) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "Provide either content_text or content_base64, not both",
-        path: ["content_text"],
-      })
-    }
-  })
-
-const inferMimetype = (filePath: string, provided?: string) => {
-  if (provided) return provided
-
-  const lowerPath = filePath.toLowerCase()
-  if (lowerPath.endsWith(".ts") || lowerPath.endsWith(".tsx")) {
-    return "text/typescript"
-  }
-  if (lowerPath.endsWith(".js")) return "application/javascript"
-  if (lowerPath.endsWith(".json")) return "application/json"
-  if (lowerPath.endsWith(".md")) return "text/markdown"
-  if (lowerPath.endsWith(".html")) return "text/html"
-  if (lowerPath.endsWith(".css")) return "text/css"
-  if (lowerPath.endsWith(".txt")) return "text/plain"
-  return "application/octet-stream"
-}
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: requestSchema,
-  jsonResponse: z.object({
-    ok: z.literal(true),
-    bug_report_file: bugReportFileResponseSchema,
-  }),
-})(async (req, ctx) => {
-  const {
-    bug_report_id,
-    file_path,
-    content_mimetype,
-    content_text,
-    content_base64,
-  } = req.jsonBody
-
-  const bugReport = ctx.db.getBugReportById(bug_report_id)
-  if (!bugReport) {
-    return ctx.error(404, {
-      error_code: "bug_report_not_found",
-      message: "Bug report not found",
-    })
-  }
-
-  if (bugReport.reporter_account_id !== ctx.auth.account_id) {
-    return ctx.error(403, {
-      error_code: "bug_report_forbidden",
-      message: "You do not have access to modify this bug report",
-    })
-  }
-
-  let normalizedPath: string
-  try {
-    normalizedPath = normalizeProjectFilePathAndValidate(file_path)
-  } catch (error) {
-    return ctx.error(400, {
-      error_code: "invalid_file_path",
-      message: error instanceof Error ? error.message : "Invalid file path",
-    })
-  }
-
-  const mimeType = inferMimetype(normalizedPath, content_mimetype)
-  const hasBase64 = content_base64 !== undefined
-  const hasText = content_text !== undefined
-  const isTextUpload = hasText || !hasBase64
-  const storedText = isTextUpload ? (content_text ?? "") : null
-  const storedBytes =
-    isTextUpload || !hasBase64
-      ? null
-      : Buffer.from(content_base64 ?? "", "base64")
-
-  const bugReportFile = ctx.db.addBugReportFile({
-    bug_report_id,
-    file_path: normalizedPath,
-    content_mimetype: mimeType,
-    is_text: isTextUpload,
-    content_text: storedText,
-    content_bytes: storedBytes,
-  })
-
-  return ctx.json({
-    ok: true,
-    bug_report_file: {
-      bug_report_file_id: bugReportFile.bug_report_file_id,
-      bug_report_id: bugReportFile.bug_report_id,
-      file_path: bugReportFile.file_path,
-      content_mimetype: bugReportFile.content_mimetype,
-      is_text: bugReportFile.is_text,
-      created_at: bugReportFile.created_at,
-    },
-  })
-})

package/fake-snippets-api/routes/api/datasheets/create.ts

@@ -1,18 +0,0 @@
-import { datasheetSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    chip_name: z.string(),
-  }),
-  jsonResponse: z.object({
-    datasheet: datasheetSchema,
-  }),
-})(async (req, ctx) => {
-  const { chip_name } = req.jsonBody
-  const datasheet = ctx.db.addDatasheet({ chip_name })
-  return ctx.json({ datasheet })
-})

package/fake-snippets-api/routes/api/datasheets/get.ts

@@ -1,35 +0,0 @@
-import { datasheetSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "session",
-  queryParams: z
-    .object({
-      datasheet_id: z.string().optional(),
-      chip_name: z.string().optional(),
-    })
-    .refine((val) => val.datasheet_id || val.chip_name, {
-      message: "datasheet_id or chip_name required",
-    }),
-  jsonBody: z.any().optional(),
-  jsonResponse: z.object({
-    datasheet: datasheetSchema,
-  }),
-})(async (req, ctx) => {
-  const { datasheet_id, chip_name } = req.query
-  let datasheet
-  if (datasheet_id) {
-    datasheet = ctx.db.getDatasheetById(datasheet_id)
-  } else if (chip_name) {
-    datasheet = ctx.db.getDatasheetByChipName(chip_name)
-  }
-  if (!datasheet) {
-    return ctx.error(404, {
-      error_code: "datasheet_not_found",
-      message: "Datasheet not found",
-    })
-  }
-  return ctx.json({ datasheet })
-})

package/fake-snippets-api/routes/api/datasheets/list.ts

@@ -1,29 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "none",
-  commonParams: z.object({
-    chip_name: z.string().optional(),
-    is_popular: z.boolean().optional(),
-  }),
-  jsonResponse: z.object({
-    datasheets: z.array(
-      z.object({
-        datasheet_id: z.string().uuid(),
-        chip_name: z.string(),
-      }),
-    ),
-  }),
-})(async (req, ctx) => {
-  const { chip_name, is_popular } = req.commonParams
-  const datasheets = ctx.db
-    .listDatasheets({ chip_name, is_popular })
-    .map((ds) => ({
-      datasheet_id: ds.datasheet_id,
-      chip_name: ds.chip_name,
-    }))
-
-  return ctx.json({ datasheets })
-})

package/fake-snippets-api/routes/api/github/installations/create_new_installation_redirect.ts

@@ -1,75 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-})(async (req, ctx) => {
-  const account = ctx.db.getAccount(ctx.auth.account_id)
-
-  if (!account) {
-    return new Response("Account not found", { status: 401 })
-  }
-
-  // Get return_to_page from query params
-  const url = new URL(req.url)
-  const returnToPage = url.searchParams.get("return_to_page") || "/"
-
-  // Check if user already has an active GitHub installation
-  const existingInstallation = ctx.db.githubInstallations.find(
-    (installation) =>
-      installation.account_id === ctx.auth.account_id && installation.is_active,
-  )
-
-  if (existingInstallation) {
-    // If installation already exists, redirect back
-    return new Response("", {
-      status: 302,
-      headers: {
-        Location: returnToPage,
-      },
-    })
-  }
-
-  // Create a new GitHub installation (simulating the user completing the GitHub App installation)
-  const githubInstallationId = `fake_gh_installation_${Date.now()}`
-  const mockInstallationId = `${Date.now()}` // Mock GitHub App installation ID
-
-  const newInstallation = {
-    github_installation_id: githubInstallationId,
-    account_id: ctx.auth.account_id,
-    installation_id: mockInstallationId,
-    github_username: account.github_username,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    is_active: true,
-    access_token: `ghs_mock_token_${Date.now()}`, // Mock access token
-    access_token_expires_at: new Date(Date.now() + 3600000).toISOString(), // 1 hour from now
-  }
-
-  ctx.db.githubInstallations.push(newInstallation)
-
-  // Return HTML page that shows installation success and redirects back
-  return new Response(
-    `
-    <html>
-      <head>
-        <title>GitHub Installation Complete</title>
-        <meta http-equiv="refresh" content="3;url=${returnToPage}">
-      </head>
-      <body style="font-family: Arial, sans-serif; padding: 40px; text-align: center;">
-        <h1>✅ GitHub Installation Complete!</h1>
-        <p>Your GitHub account has been successfully connected to tscircuit.</p>
-        <p>You can now access your repositories in the package settings.</p>
-        <p>Redirecting you back in 3 seconds...</p>
-        <a href="${returnToPage}" style="color: #0066cc; text-decoration: none; font-weight: bold;">Click here if you're not redirected automatically</a>
-      </body>
-    </html>
-    `,
-    {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-      },
-    },
-  )
-})

package/fake-snippets-api/routes/api/github/repos/list_available.ts

@@ -1,91 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  jsonResponse: z.object({
-    repos: z.array(
-      z.object({
-        unscoped_name: z.string(),
-        full_name: z.string(),
-        private: z.boolean(),
-        owner: z.object({
-          login: z.string(),
-        }),
-        description: z.string().nullable(),
-        default_branch: z.string(),
-      }),
-    ),
-  }),
-})(async (_req, ctx) => {
-  const account = ctx.db.getAccount(ctx.auth.account_id)
-
-  if (!account) {
-    return ctx.error(401, {
-      error_code: "account_not_found",
-      message: "Account not found",
-    })
-  }
-
-  // Check if user has GitHub account connected
-  if (!account.github_username) {
-    return ctx.error(400, {
-      error_code: "github_not_connected",
-      message:
-        "GitHub account not connected. Please connect your GitHub account first.",
-    })
-  }
-
-  // Check if user has a GitHub installation
-  const githubInstallation = ctx.db.githubInstallations.find(
-    (installation) =>
-      installation.account_id === ctx.auth.account_id && installation.is_active,
-  )
-
-  if (!githubInstallation) {
-    // Return empty array if no GitHub installation found
-    return ctx.json({
-      repos: [],
-    })
-  }
-
-  // Mock repositories for demonstration
-  // In a real implementation, this would fetch from GitHub API using the installation access token
-  const mockRepos = [
-    {
-      unscoped_name: "my-electronics-project",
-      full_name: `${account.github_username}/my-electronics-project`,
-      owner: {
-        login: account.github_username,
-      },
-      description: "Arduino-based sensor monitoring system",
-      private: false,
-      default_branch: "main",
-    },
-    {
-      unscoped_name: "pcb-designs",
-      full_name: `${account.github_username}/pcb-designs`,
-      owner: {
-        login: account.github_username,
-      },
-      description: "Collection of PCB designs for various projects",
-      private: true,
-      default_branch: "main",
-    },
-    {
-      unscoped_name: "tscircuit-examples",
-      full_name: `${account.github_username}/tscircuit-examples`,
-      owner: {
-        login: account.github_username,
-      },
-      description: "Examples and tutorials for tscircuit",
-      private: false,
-      default_branch: "main",
-    },
-  ]
-
-  return ctx.json({
-    repos: mockRepos,
-  })
-})

package/fake-snippets-api/routes/api/github/repos/refresh.ts

@@ -1,44 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonResponse: z.object({
-    success: z.boolean(),
-    message: z.string(),
-    repos_refreshed: z.number().optional(),
-  }),
-})(async (req, ctx) => {
-  const account = ctx.db.getAccount(ctx.auth.account_id)
-
-  if (!account) {
-    return ctx.error(401, {
-      error_code: "account_not_found",
-      message: "Account not found",
-    })
-  }
-
-  // Check GitHub installation
-  const githubInstallation = ctx.db.githubInstallations.find(
-    (installation) =>
-      installation.account_id === ctx.auth.account_id && installation.is_active,
-  )
-
-  if (!githubInstallation) {
-    return ctx.error(400, {
-      error_code: "github_not_connected",
-      message: "GitHub account not connected",
-    })
-  }
-
-  // In a real implementation, this would refresh repos from GitHub API
-  // For fake API, simulate refreshing by updating the installation timestamp
-  githubInstallation.updated_at = new Date().toISOString()
-
-  return ctx.json({
-    success: true,
-    message: "GitHub repositories refreshed successfully",
-    repos_refreshed: 3, // Mock number
-  })
-})

package/fake-snippets-api/routes/api/health.ts

@@ -1,9 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  jsonResponse: z.object({ ok: z.boolean() }),
-})(async (req: any, ctx: any) => {
-  return ctx.json({ ok: true })
-})