first commit

app/routes/_index.tsx

@@ -0,0 +1,22 @@
+import { json, type MetaFunction } from '@remix-run/cloudflare';
+import { ClientOnly } from 'remix-utils/client-only';
+import { BaseChat } from '~/components/chat/BaseChat';
+import { Chat } from '~/components/chat/Chat.client';
+import { Header } from '~/components/header/Header';
+import BackgroundRays from '~/components/ui/BackgroundRays';
+
+export const meta: MetaFunction = () => {
+  return [{ title: 'asap.it' }, { name: 'description', content: 'Talk with Bolt, an AI assistant from StackBlitz' }];
+};
+
+export const loader = () => json({});
+
+export default function Index() {
+  return (
+    <div className="flex flex-col h-full w-full bg-bolt-elements-background-depth-1">
+      <BackgroundRays />
+      <Header />
+      <ClientOnly fallback={<BaseChat />}>{() => <Chat />}</ClientOnly>
+    </div>
+  );
+}

app/routes/api.chat.ts

@@ -0,0 +1,98 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { MAX_RESPONSE_SEGMENTS, MAX_TOKENS } from '~/lib/.server/llm/constants';
+import { CONTINUE_PROMPT } from '~/lib/.server/llm/prompts';
+import { streamText, type Messages, type StreamingOptions } from '~/lib/.server/llm/stream-text';
+import SwitchableStream from '~/lib/.server/llm/switchable-stream';
+import type { IProviderSetting } from '~/types/model';
+
+export async function action(args: ActionFunctionArgs) {
+  return chatAction(args);
+}
+
+function parseCookies(cookieHeader: string) {
+  const cookies: any = {};
+
+  // Split the cookie string by semicolons and spaces
+  const items = cookieHeader.split(';').map((cookie) => cookie.trim());
+
+  items.forEach((item) => {
+    const [name, ...rest] = item.split('=');
+
+    if (name && rest) {
+      // Decode the name and value, and join value parts in case it contains '='
+      const decodedName = decodeURIComponent(name.trim());
+      const decodedValue = decodeURIComponent(rest.join('=').trim());
+      cookies[decodedName] = decodedValue;
+    }
+  });
+
+  return cookies;
+}
+
+async function chatAction({ context, request }: ActionFunctionArgs) {
+  const { messages } = await request.json<{
+    messages: Messages;
+    model: string;
+  }>();
+
+  const cookieHeader = request.headers.get('Cookie');
+
+  // Parse the cookie's value (returns an object or null if no cookie exists)
+  const apiKeys = JSON.parse(parseCookies(cookieHeader || '').apiKeys || '{}');
+  const providerSettings: Record<string, IProviderSetting> = JSON.parse(
+    parseCookies(cookieHeader || '').providers || '{}',
+  );
+
+  const stream = new SwitchableStream();
+
+  try {
+    const options: StreamingOptions = {
+      toolChoice: 'none',
+      onFinish: async ({ text: content, finishReason }) => {
+        if (finishReason !== 'length') {
+          return stream.close();
+        }
+
+        if (stream.switches >= MAX_RESPONSE_SEGMENTS) {
+          throw Error('Cannot continue message: Maximum segments reached');
+        }
+
+        const switchesLeft = MAX_RESPONSE_SEGMENTS - stream.switches;
+
+        console.log(`Reached max token limit (${MAX_TOKENS}): Continuing message (${switchesLeft} switches left)`);
+
+        messages.push({ role: 'assistant', content });
+        messages.push({ role: 'user', content: CONTINUE_PROMPT });
+
+        const result = await streamText({ messages, env: context.cloudflare.env, options, apiKeys, providerSettings });
+
+        return stream.switchSource(result.toAIStream());
+      },
+    };
+
+    const result = await streamText({ messages, env: context.cloudflare.env, options, apiKeys, providerSettings });
+
+    stream.switchSource(result.toAIStream());
+
+    return new Response(stream.readable, {
+      status: 200,
+      headers: {
+        contentType: 'text/plain; charset=utf-8',
+      },
+    });
+  } catch (error: any) {
+    console.log(error);
+
+    if (error.message?.includes('API key')) {
+      throw new Response('Invalid or missing API key', {
+        status: 401,
+        statusText: 'Unauthorized',
+      });
+    }
+
+    throw new Response(null, {
+      status: 500,
+      statusText: 'Internal Server Error',
+    });
+  }
+}

app/routes/api.enhancer.ts

@@ -0,0 +1,147 @@
+import { type ActionFunctionArgs } from '@remix-run/cloudflare';
+import { StreamingTextResponse, parseStreamPart } from 'ai';
+import { streamText } from '~/lib/.server/llm/stream-text';
+import { stripIndents } from '~/utils/stripIndent';
+import type { IProviderSetting, ProviderInfo } from '~/types/model';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export async function action(args: ActionFunctionArgs) {
+  return enhancerAction(args);
+}
+
+function parseCookies(cookieHeader: string) {
+  const cookies: any = {};
+
+  // Split the cookie string by semicolons and spaces
+  const items = cookieHeader.split(';').map((cookie) => cookie.trim());
+
+  items.forEach((item) => {
+    const [name, ...rest] = item.split('=');
+
+    if (name && rest) {
+      // Decode the name and value, and join value parts in case it contains '='
+      const decodedName = decodeURIComponent(name.trim());
+      const decodedValue = decodeURIComponent(rest.join('=').trim());
+      cookies[decodedName] = decodedValue;
+    }
+  });
+
+  return cookies;
+}
+
+async function enhancerAction({ context, request }: ActionFunctionArgs) {
+  const { message, model, provider } = await request.json<{
+    message: string;
+    model: string;
+    provider: ProviderInfo;
+    apiKeys?: Record<string, string>;
+  }>();
+
+  const { name: providerName } = provider;
+
+  // validate 'model' and 'provider' fields
+  if (!model || typeof model !== 'string') {
+    throw new Response('Invalid or missing model', {
+      status: 400,
+      statusText: 'Bad Request',
+    });
+  }
+
+  if (!providerName || typeof providerName !== 'string') {
+    throw new Response('Invalid or missing provider', {
+      status: 400,
+      statusText: 'Bad Request',
+    });
+  }
+
+  const cookieHeader = request.headers.get('Cookie');
+
+  // Parse the cookie's value (returns an object or null if no cookie exists)
+  const apiKeys = JSON.parse(parseCookies(cookieHeader || '').apiKeys || '{}');
+  const providerSettings: Record<string, IProviderSetting> = JSON.parse(
+    parseCookies(cookieHeader || '').providers || '{}',
+  );
+
+  try {
+    const result = await streamText({
+      messages: [
+        {
+          role: 'user',
+          content:
+            `[Model: ${model}]\n\n[Provider: ${providerName}]\n\n` +
+            stripIndents`
+            You are a professional prompt engineer specializing in crafting precise, effective prompts.
+          Your task is to enhance prompts by making them more specific, actionable, and effective.
+
+          I want you to improve the user prompt that is wrapped in \`<original_prompt>\` tags.
+
+          For valid prompts:
+          - Make instructions explicit and unambiguous
+          - Add relevant context and constraints
+          - Remove redundant information
+          - Maintain the core intent
+          - Ensure the prompt is self-contained
+          - Use professional language
+
+          For invalid or unclear prompts:
+          - Respond with a clear, professional guidance message
+          - Keep responses concise and actionable
+          - Maintain a helpful, constructive tone
+          - Focus on what the user should provide
+          - Use a standard template for consistency
+
+          IMPORTANT: Your response must ONLY contain the enhanced prompt text.
+          Do not include any explanations, metadata, or wrapper tags.
+
+          <original_prompt>
+            ${message}
+          </original_prompt>
+        `,
+        },
+      ],
+      env: context.cloudflare.env,
+      apiKeys,
+      providerSettings,
+    });
+
+    const transformStream = new TransformStream({
+      transform(chunk, controller) {
+        const text = decoder.decode(chunk);
+        const lines = text.split('\n').filter((line) => line.trim() !== '');
+
+        for (const line of lines) {
+          try {
+            const parsed = parseStreamPart(line);
+
+            if (parsed.type === 'text') {
+              controller.enqueue(encoder.encode(parsed.value));
+            }
+          } catch (e) {
+            // skip invalid JSON lines
+            console.warn('Failed to parse stream part:', line, e);
+          }
+        }
+      },
+    });
+
+    const transformedStream = result.toDataStream().pipeThrough(transformStream);
+
+    return new StreamingTextResponse(transformedStream);
+  } catch (error: unknown) {
+    console.log(error);
+
+    if (error instanceof Error && error.message?.includes('API key')) {
+      throw new Response('Invalid or missing API key', {
+        status: 401,
+        statusText: 'Unauthorized',
+      });
+    }
+
+    throw new Response(null, {
+      status: 500,
+      statusText: 'Internal Server Error',
+    });
+  }
+}

app/routes/api.models.ts

@@ -0,0 +1,6 @@
+import { json } from '@remix-run/cloudflare';
+import { MODEL_LIST } from '~/utils/constants';
+
+export async function loader() {
+  return json(MODEL_LIST);
+}

app/routes/chat.$id.tsx

@@ -0,0 +1,8 @@
+import { json, type LoaderFunctionArgs } from '@remix-run/cloudflare';
+import { default as IndexRoute } from './_index';
+
+export async function loader(args: LoaderFunctionArgs) {
+  return json({ id: args.params.id });
+}
+
+export default IndexRoute;

app/routes/git.tsx

@@ -0,0 +1,23 @@
+import type { LoaderFunctionArgs } from '@remix-run/cloudflare';
+import { json, type MetaFunction } from '@remix-run/cloudflare';
+import { ClientOnly } from 'remix-utils/client-only';
+import { BaseChat } from '~/components/chat/BaseChat';
+import { GitUrlImport } from '~/components/git/GitUrlImport.client';
+import { Header } from '~/components/header/Header';
+
+export const meta: MetaFunction = () => {
+  return [{ title: 'asap.it' }, { name: 'description', content: 'Talk with Bolt, an AI assistant from StackBlitz' }];
+};
+
+export async function loader(args: LoaderFunctionArgs) {
+  return json({ url: args.params.url });
+}
+
+export default function Index() {
+  return (
+    <div className="flex flex-col h-full w-full">
+      <Header />
+      <ClientOnly fallback={<BaseChat />}>{() => <GitUrlImport />}</ClientOnly>
+    </div>
+  );
+}