0 ? `${100 / childrenArray.length * 0.6}%` : '0'
+ }}
+ />
+
+ {childrenArray.map((child, index) => {
+ const isLast = index === childrenArray.length - 1;
+
+ return (
+
+ {!isLast && (
+
+ )}
+ {isLast && (
+
+ )}
+
+
{child}
+
+ )
+ })}
+
+ );
+};
+
+interface ToolHeaderProps {
+ isLoading: boolean;
+ isError: boolean;
+ isExpanded: boolean;
+ label: React.ReactNode;
+ Icon: React.ElementType;
+ onExpand: (isExpanded: boolean) => void;
+ className?: string;
+}
+
+export const ToolHeader = ({ isLoading, isError, isExpanded, label, Icon, onExpand, className }: ToolHeaderProps) => {
+ return (
+
{
+ onExpand(!isExpanded)
+ }}
+ onKeyDown={(e) => {
+ if (e.key !== "Enter") {
+ return;
+ }
+ onExpand(!isExpanded);
+ }}
+ >
+ {isLoading ? (
+
+ ) : (
+
+ )}
+
{label}
+ {!isLoading && (
+
+ {isExpanded ? (
+
+ ) : (
+
+ )}
+
+ )}
+
+ )
+}
\ No newline at end of file
diff --git a/packages/web/src/features/chat/components/searchScopeIcon.tsx b/packages/web/src/features/chat/components/searchScopeIcon.tsx
new file mode 100644
index 00000000..933471f4
--- /dev/null
+++ b/packages/web/src/features/chat/components/searchScopeIcon.tsx
@@ -0,0 +1,32 @@
+import { cn, getCodeHostIcon } from "@/lib/utils";
+import { FolderIcon, LibraryBigIcon } from "lucide-react";
+import Image from "next/image";
+import { SearchScope } from "../types";
+
+interface SearchScopeIconProps {
+ searchScope: SearchScope;
+ className?: string;
+}
+
+export const SearchScopeIcon = ({ searchScope, className = "h-4 w-4" }: SearchScopeIconProps) => {
+ if (searchScope.type === 'reposet') {
+ return
;
+ } else {
+ // Render code host icon for repos
+ const codeHostIcon = searchScope.codeHostType ? getCodeHostIcon(searchScope.codeHostType) : null;
+ if (codeHostIcon) {
+ const size = className.includes('h-3') ? 12 : 16;
+ return (
+
+ );
+ } else {
+ return
;
+ }
+ }
+};
\ No newline at end of file
diff --git a/packages/web/src/features/chat/constants.ts b/packages/web/src/features/chat/constants.ts
new file mode 100644
index 00000000..c9da5694
--- /dev/null
+++ b/packages/web/src/features/chat/constants.ts
@@ -0,0 +1,31 @@
+import { SBChatMessagePart } from "./types";
+
+export const FILE_REFERENCE_PREFIX = '@file:';
+export const FILE_REFERENCE_REGEX = new RegExp(
+ // @file:{repoName::fileName:startLine-endLine}
+ `${FILE_REFERENCE_PREFIX}\\{([^:}]+)::([^:}]+)(?::(\\d+)(?:-(\\d+))?)?\\}`,
+ 'g'
+);
+
+export const ANSWER_TAG = '';
+
+export const toolNames = {
+ searchCode: 'searchCode',
+ readFiles: 'readFiles',
+ findSymbolReferences: 'findSymbolReferences',
+ findSymbolDefinitions: 'findSymbolDefinitions',
+ searchRepos: 'searchRepos',
+ listAllRepos: 'listAllRepos',
+} as const;
+
+// These part types are visible in the UI.
+export const uiVisiblePartTypes: SBChatMessagePart['type'][] = [
+ 'reasoning',
+ 'text',
+ 'tool-searchCode',
+ 'tool-readFiles',
+ 'tool-findSymbolDefinitions',
+ 'tool-findSymbolReferences',
+ 'tool-searchRepos',
+ 'tool-listAllRepos',
+] as const;
\ No newline at end of file
diff --git a/packages/web/src/features/chat/customSlateEditor.tsx b/packages/web/src/features/chat/customSlateEditor.tsx
new file mode 100644
index 00000000..4f52f11a
--- /dev/null
+++ b/packages/web/src/features/chat/customSlateEditor.tsx
@@ -0,0 +1,27 @@
+'use client';
+
+import { Slate } from "slate-react";
+import { useCustomSlateEditor } from "./useCustomSlateEditor";
+import { CustomElement } from "./types";
+
+interface CustomSlateEditorProps {
+ children: React.ReactNode;
+}
+
+const initialValue: CustomElement[] = [
+ {
+ type: 'paragraph',
+ children: [{ text: '' }],
+ },
+];
+
+export const CustomSlateEditor = ({ children }: CustomSlateEditorProps) => {
+ const editor = useCustomSlateEditor();
+
+ return
+ {children}
+ ;
+}
\ No newline at end of file
diff --git a/packages/web/src/features/chat/tools.ts b/packages/web/src/features/chat/tools.ts
new file mode 100644
index 00000000..f69c5f34
--- /dev/null
+++ b/packages/web/src/features/chat/tools.ts
@@ -0,0 +1,271 @@
+import { z } from "zod"
+import { search } from "@/features/search/searchApi"
+import { SINGLE_TENANT_ORG_DOMAIN } from "@/lib/constants"
+import { InferToolInput, InferToolOutput, InferUITool, tool, ToolUIPart } from "ai";
+import { isServiceError } from "@/lib/utils";
+import { getFileSource } from "../search/fileSourceApi";
+import { findSearchBasedSymbolDefinitions, findSearchBasedSymbolReferences } from "../codeNav/actions";
+import { FileSourceResponse } from "../search/types";
+import { addLineNumbers, buildSearchQuery } from "./utils";
+import { toolNames } from "./constants";
+import { getRepos } from "@/actions";
+import Fuse from "fuse.js";
+
+// @NOTE: When adding a new tool, follow these steps:
+// 1. Add the tool to the `toolNames` constant in `constants.ts`.
+// 2. Add the tool to the `SBChatMessageToolTypes` type in `types.ts`.
+// 3. Add the tool to the `tools` prop in `agent.ts`.
+// 4. If the tool is meant to be rendered in the UI:
+// - Add the tool to the `uiVisiblePartTypes` constant in `constants.ts`.
+// - Add the tool's component to the `DetailsCard` switch statement in `detailsCard.tsx`.
+//
+// - bk, 2025-07-25
+
+
+export const findSymbolReferencesTool = tool({
+ description: `Finds references to a symbol in the codebase.`,
+ inputSchema: z.object({
+ symbol: z.string().describe("The symbol to find references to"),
+ language: z.string().describe("The programming language of the symbol"),
+ }),
+ execute: async ({ symbol, language }) => {
+ // @todo: make revision configurable.
+ const revision = "HEAD";
+
+ const response = await findSearchBasedSymbolReferences({
+ symbolName: symbol,
+ language,
+ revisionName: "HEAD",
+ // @todo(mt): handle multi-tenancy.
+ }, SINGLE_TENANT_ORG_DOMAIN);
+
+ if (isServiceError(response)) {
+ return response;
+ }
+
+ return response.files.map((file) => ({
+ fileName: file.fileName,
+ repository: file.repository,
+ language: file.language,
+ matches: file.matches.map(({ lineContent, range }) => {
+ return addLineNumbers(lineContent, range.start.lineNumber);
+ }),
+ revision,
+ }));
+ },
+});
+
+export type FindSymbolReferencesTool = InferUITool
;
+export type FindSymbolReferencesToolInput = InferToolInput;
+export type FindSymbolReferencesToolOutput = InferToolOutput;
+export type FindSymbolReferencesToolUIPart = ToolUIPart<{ [toolNames.findSymbolReferences]: FindSymbolReferencesTool }>
+
+export const findSymbolDefinitionsTool = tool({
+ description: `Finds definitions of a symbol in the codebase.`,
+ inputSchema: z.object({
+ symbol: z.string().describe("The symbol to find definitions of"),
+ language: z.string().describe("The programming language of the symbol"),
+ }),
+ execute: async ({ symbol, language }) => {
+ // @todo: make revision configurable.
+ const revision = "HEAD";
+
+ const response = await findSearchBasedSymbolDefinitions({
+ symbolName: symbol,
+ language,
+ revisionName: revision,
+ // @todo(mt): handle multi-tenancy.
+ }, SINGLE_TENANT_ORG_DOMAIN);
+
+ if (isServiceError(response)) {
+ return response;
+ }
+
+ return response.files.map((file) => ({
+ fileName: file.fileName,
+ repository: file.repository,
+ language: file.language,
+ matches: file.matches.map(({ lineContent, range }) => {
+ return addLineNumbers(lineContent, range.start.lineNumber);
+ }),
+ revision,
+ }));
+ }
+});
+
+export type FindSymbolDefinitionsTool = InferUITool;
+export type FindSymbolDefinitionsToolInput = InferToolInput;
+export type FindSymbolDefinitionsToolOutput = InferToolOutput;
+export type FindSymbolDefinitionsToolUIPart = ToolUIPart<{ [toolNames.findSymbolDefinitions]: FindSymbolDefinitionsTool }>
+
+export const readFilesTool = tool({
+ description: `Reads the contents of multiple files at the given paths.`,
+ inputSchema: z.object({
+ paths: z.array(z.string()).describe("The paths to the files to read"),
+ repository: z.string().describe("The repository to read the files from"),
+ }),
+ execute: async ({ paths, repository }) => {
+ // @todo: make revision configurable.
+ const revision = "HEAD";
+
+ const responses = await Promise.all(paths.map(async (path) => {
+ return getFileSource({
+ fileName: path,
+ repository,
+ branch: revision,
+ // @todo(mt): handle multi-tenancy.
+ });
+ }));
+
+ if (responses.some(isServiceError)) {
+ const firstError = responses.find(isServiceError);
+ return firstError!;
+ }
+
+ return (responses as FileSourceResponse[]).map((response) => ({
+ path: response.path,
+ repository: response.repository,
+ language: response.language,
+ source: addLineNumbers(response.source),
+ revision,
+ }));
+ }
+});
+
+export type ReadFilesTool = InferUITool;
+export type ReadFilesToolInput = InferToolInput;
+export type ReadFilesToolOutput = InferToolOutput;
+export type ReadFilesToolUIPart = ToolUIPart<{ [toolNames.readFiles]: ReadFilesTool }>
+
+export const createCodeSearchTool = (selectedRepos: string[]) => tool({
+ description: `Fetches code that matches the provided regex pattern in \`query\`. This is NOT a semantic search.
+ Results are returned as an array of matching files, with the file's URL, repository, and language.`,
+ inputSchema: z.object({
+ queryRegexp: z
+ .string()
+ .describe(`The regex pattern to search for in the code.
+
+Queries consist of space-seperated regular expressions. Wrapping expressions in "" combines them. By default, a file must have at least one match for each expression to be included. Examples:
+
+\`foo\` - Match files with regex /foo/
+\`foo bar\` - Match files with regex /foo/ and /bar/
+\`"foo bar"\` - Match files with regex /foo bar/
+\`console.log\` - Match files with regex /console.log/
+
+Multiple expressions can be or'd together with or, negated with -, or grouped with (). Examples:
+\`foo or bar\` - Match files with regex /foo/ or /bar/
+\`foo -bar\` - Match files with regex /foo/ but not /bar/
+\`foo (bar or baz)\` - Match files with regex /foo/ and either /bar/ or /baz/
+`),
+ repoNamesFilterRegexp: z
+ .array(z.string())
+ .describe(`Filter results from repos that match the regex. By default all repos are searched.`)
+ .optional(),
+ languageNamesFilter: z
+ .array(z.string())
+ .describe(`Scope the search to the provided languages. The language MUST be formatted as a GitHub linguist language. Examples: Python, JavaScript, TypeScript, Java, C#, C++, PHP, Go, Rust, Ruby, Swift, Kotlin, Shell, C, Dart, HTML, CSS, PowerShell, SQL, R`)
+ .optional(),
+ fileNamesFilterRegexp: z
+ .array(z.string())
+ .describe(`Filter results from filepaths that match the regex. When this option is not specified, all files are searched.`)
+ .optional(),
+ limit: z.number().default(10).describe("Maximum number of matches to return (default: 100)"),
+ }),
+ execute: async ({ queryRegexp: _query, repoNamesFilterRegexp, languageNamesFilter, fileNamesFilterRegexp, limit }) => {
+ const query = buildSearchQuery({
+ query: _query,
+ repoNamesFilter: selectedRepos,
+ repoNamesFilterRegexp,
+ languageNamesFilter,
+ fileNamesFilterRegexp,
+ });
+
+ const response = await search({
+ query,
+ matches: limit ?? 100,
+ // @todo: we can make this configurable.
+ contextLines: 3,
+ whole: false,
+ // @todo(mt): handle multi-tenancy.
+ });
+
+ if (isServiceError(response)) {
+ return response;
+ }
+
+ return {
+ files: response.files.map((file) => ({
+ fileName: file.fileName.text,
+ repository: file.repository,
+ language: file.language,
+ matches: file.chunks.map(({ content, contentStart }) => {
+ return addLineNumbers(content, contentStart.lineNumber);
+ }),
+ // @todo: make revision configurable.
+ revision: 'HEAD',
+ })),
+ query,
+ }
+ },
+});
+
+export type SearchCodeTool = InferUITool>;
+export type SearchCodeToolInput = InferToolInput>;
+export type SearchCodeToolOutput = InferToolOutput>;
+export type SearchCodeToolUIPart = ToolUIPart<{ [toolNames.searchCode]: SearchCodeTool }>;
+
+export const searchReposTool = tool({
+ description: `Search for repositories by name using fuzzy search. This helps find repositories in the codebase when you know part of their name.`,
+ inputSchema: z.object({
+ query: z.string().describe("The search query to find repositories by name (supports fuzzy matching)"),
+ limit: z.number().default(10).describe("Maximum number of repositories to return (default: 10)")
+ }),
+ execute: async ({ query, limit }) => {
+ const reposResponse = await getRepos();
+
+ if (isServiceError(reposResponse)) {
+ return reposResponse;
+ }
+
+ // Configure Fuse.js for fuzzy searching
+ const fuse = new Fuse(reposResponse, {
+ keys: [
+ { name: 'repoName', weight: 0.7 },
+ { name: 'repoDisplayName', weight: 0.3 }
+ ],
+ threshold: 0.4, // Lower threshold = more strict matching
+ includeScore: true,
+ minMatchCharLength: 1,
+ });
+
+ const searchResults = fuse.search(query, { limit: limit ?? 10 });
+
+ searchResults.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+
+ return searchResults.map(({ item }) => item.repoName);
+ }
+});
+
+export type SearchReposTool = InferUITool;
+export type SearchReposToolInput = InferToolInput;
+export type SearchReposToolOutput = InferToolOutput;
+export type SearchReposToolUIPart = ToolUIPart<{ [toolNames.searchRepos]: SearchReposTool }>;
+
+export const listAllReposTool = tool({
+ description: `Lists all repositories in the codebase. This provides a complete overview of all available repositories.`,
+ inputSchema: z.object({}),
+ execute: async () => {
+ const reposResponse = await getRepos();
+
+ if (isServiceError(reposResponse)) {
+ return reposResponse;
+ }
+
+ return reposResponse.map((repo) => repo.repoName);
+ }
+});
+
+export type ListAllReposTool = InferUITool;
+export type ListAllReposToolInput = InferToolInput;
+export type ListAllReposToolOutput = InferToolOutput;
+export type ListAllReposToolUIPart = ToolUIPart<{ [toolNames.listAllRepos]: ListAllReposTool }>;
diff --git a/packages/web/src/features/chat/types.ts b/packages/web/src/features/chat/types.ts
new file mode 100644
index 00000000..524f14f8
--- /dev/null
+++ b/packages/web/src/features/chat/types.ts
@@ -0,0 +1,184 @@
+import { CreateUIMessage, UIMessage, UIMessagePart } from "ai";
+import { BaseEditor, Descendant } from "slate";
+import { HistoryEditor } from "slate-history";
+import { ReactEditor, RenderElementProps } from "slate-react";
+import { z } from "zod";
+import { FindSymbolDefinitionsTool, FindSymbolReferencesTool, ReadFilesTool, SearchCodeTool, SearchReposTool, ListAllReposTool } from "./tools";
+import { toolNames } from "./constants";
+import { LanguageModel } from "@sourcebot/schemas/v3/index.type";
+
+const fileSourceSchema = z.object({
+ type: z.literal('file'),
+ repo: z.string(),
+ path: z.string(),
+ name: z.string(),
+ language: z.string(),
+ revision: z.string(),
+});
+export type FileSource = z.infer;
+
+export const sourceSchema = z.discriminatedUnion('type', [
+ fileSourceSchema,
+]);
+export type Source = z.infer;
+
+const fileReferenceSchema = z.object({
+ type: z.literal('file'),
+ id: z.string(),
+ repo: z.string(),
+ path: z.string(),
+ range: z.object({
+ startLine: z.number(),
+ endLine: z.number(),
+ }).optional(),
+});
+export type FileReference = z.infer;
+
+export const referenceSchema = z.discriminatedUnion('type', [
+ fileReferenceSchema,
+]);
+export type Reference = z.infer;
+
+export const repoSearchScopeSchema = z.object({
+ type: z.literal('repo'),
+ value: z.string(),
+ name: z.string(),
+ codeHostType: z.string(),
+});
+export type RepoSearchScope = z.infer;
+
+export const repoSetSearchScopeSchema = z.object({
+ type: z.literal('reposet'),
+ value: z.string(),
+ name: z.string(),
+ repoCount: z.number(),
+});
+export type RepoSetSearchScope = z.infer;
+
+export const searchScopeSchema = z.discriminatedUnion('type', [
+ repoSearchScopeSchema,
+ repoSetSearchScopeSchema,
+]);
+export type SearchScope = z.infer;
+
+export const sbChatMessageMetadataSchema = z.object({
+ modelName: z.string().optional(),
+ totalInputTokens: z.number().optional(),
+ totalOutputTokens: z.number().optional(),
+ totalTokens: z.number().optional(),
+ totalResponseTimeMs: z.number().optional(),
+ feedback: z.array(z.object({
+ type: z.enum(['like', 'dislike']),
+ timestamp: z.string(), // ISO date string
+ userId: z.string(),
+ })).optional(),
+ selectedSearchScopes: z.array(searchScopeSchema).optional(),
+ traceId: z.string().optional(),
+});
+
+export type SBChatMessageMetadata = z.infer;
+
+export type SBChatMessageToolTypes = {
+ [toolNames.searchCode]: SearchCodeTool,
+ [toolNames.readFiles]: ReadFilesTool,
+ [toolNames.findSymbolReferences]: FindSymbolReferencesTool,
+ [toolNames.findSymbolDefinitions]: FindSymbolDefinitionsTool,
+ [toolNames.searchRepos]: SearchReposTool,
+ [toolNames.listAllRepos]: ListAllReposTool,
+}
+
+export type SBChatMessageDataParts = {
+ // The `source` data type allows us to know what sources the LLM saw
+ // during retrieval.
+ "source": Source,
+}
+
+export type SBChatMessage = UIMessage<
+ SBChatMessageMetadata,
+ SBChatMessageDataParts,
+ SBChatMessageToolTypes
+>;
+
+export type SBChatMessagePart = UIMessagePart<
+ SBChatMessageDataParts,
+ SBChatMessageToolTypes
+>;
+
+// Slate specific types //
+
+export type CustomText = { text: string; }
+
+export type ParagraphElement = {
+ type: 'paragraph'
+ align?: string
+ children: Descendant[];
+}
+
+export type FileMentionData = {
+ type: 'file';
+ repo: string;
+ path: string;
+ name: string;
+ language: string;
+ revision: string;
+}
+
+export type MentionData = FileMentionData;
+
+export type MentionElement = {
+ type: 'mention';
+ data: MentionData;
+ children: CustomText[];
+}
+
+export type CustomElement =
+ ParagraphElement |
+ MentionElement
+ ;
+
+
+export type CustomEditor =
+ BaseEditor &
+ ReactEditor &
+ HistoryEditor
+ ;
+
+export type RenderElementPropsFor = RenderElementProps & {
+ element: T
+}
+
+declare module 'slate' {
+ interface CustomTypes {
+ Editor: CustomEditor
+ Element: CustomElement
+ Text: CustomText
+ }
+}
+
+/////////////////////////
+
+// Misc //
+export const SET_CHAT_STATE_SESSION_STORAGE_KEY = 'setChatState';
+
+export type SetChatStatePayload = {
+ inputMessage: CreateUIMessage;
+ selectedSearchScopes: SearchScope[];
+}
+
+
+export type LanguageModelProvider = LanguageModel['provider'];
+
+// This is a subset of information about a configured
+// language model that we can safely send to the client.
+export type LanguageModelInfo = {
+ provider: LanguageModelProvider,
+ model: LanguageModel['model'],
+ displayName?: LanguageModel['displayName'],
+}
+
+// Additional request body data that we send along to the chat API.
+export const additionalChatRequestParamsSchema = z.object({
+ languageModelId: z.string(),
+ selectedSearchScopes: z.array(searchScopeSchema),
+});
+export type AdditionalChatRequestParams = z.infer;
\ No newline at end of file
diff --git a/packages/web/src/features/chat/useCreateNewChatThread.ts b/packages/web/src/features/chat/useCreateNewChatThread.ts
new file mode 100644
index 00000000..25c67b22
--- /dev/null
+++ b/packages/web/src/features/chat/useCreateNewChatThread.ts
@@ -0,0 +1,60 @@
+'use client';
+
+import { useCallback, useState } from "react";
+import { Descendant } from "slate";
+import { createUIMessage, getAllMentionElements } from "./utils";
+import { slateContentToString } from "./utils";
+import { useDomain } from "@/hooks/useDomain";
+import { useToast } from "@/components/hooks/use-toast";
+import { useRouter } from "next/navigation";
+import { createChat } from "./actions";
+import { isServiceError } from "@/lib/utils";
+import { createPathWithQueryParams } from "@/lib/utils";
+import { SearchScope, SET_CHAT_STATE_SESSION_STORAGE_KEY, SetChatStatePayload } from "./types";
+import { useSessionStorage } from "usehooks-ts";
+import useCaptureEvent from "@/hooks/useCaptureEvent";
+
+export const useCreateNewChatThread = () => {
+ const domain = useDomain();
+ const [isLoading, setIsLoading] = useState(false);
+ const { toast } = useToast();
+ const router = useRouter();
+ const captureEvent = useCaptureEvent();
+
+ const [, setChatState] = useSessionStorage(SET_CHAT_STATE_SESSION_STORAGE_KEY, null);
+
+
+ const createNewChatThread = useCallback(async (children: Descendant[], selectedSearchScopes: SearchScope[]) => {
+ const text = slateContentToString(children);
+ const mentions = getAllMentionElements(children);
+
+ const inputMessage = createUIMessage(text, mentions.map((mention) => mention.data), selectedSearchScopes);
+
+ setIsLoading(true);
+ const response = await createChat(domain);
+ if (isServiceError(response)) {
+ toast({
+ description: `❌ Failed to create chat. Reason: ${response.message}`
+ });
+ setIsLoading(false);
+ return;
+ }
+
+ captureEvent('wa_chat_thread_created', {});
+
+ setChatState({
+ inputMessage,
+ selectedSearchScopes,
+ });
+
+ const url = createPathWithQueryParams(`/${domain}/chat/${response.id}`);
+
+ router.push(url);
+ router.refresh();
+ }, [domain, router, toast, setChatState, captureEvent]);
+
+ return {
+ createNewChatThread,
+ isLoading,
+ };
+}
\ No newline at end of file
diff --git a/packages/web/src/features/chat/useCustomSlateEditor.ts b/packages/web/src/features/chat/useCustomSlateEditor.ts
new file mode 100644
index 00000000..20c87147
--- /dev/null
+++ b/packages/web/src/features/chat/useCustomSlateEditor.ts
@@ -0,0 +1,37 @@
+'use client';
+
+import { createEditor } from "slate";
+import { useState } from "react";
+import { withReact } from "slate-react";
+import { withHistory } from "slate-history";
+import { CustomEditor } from "./types";
+import { Element } from "slate";
+
+export const useCustomSlateEditor = () => {
+ const [editor] = useState(() =>
+ withMentions(
+ withReact(
+ withHistory(createEditor())
+ )
+ )
+ );
+ return editor;
+}
+
+const withMentions = (editor: CustomEditor) => {
+ const { isInline, isVoid, markableVoid } = editor;
+
+ editor.isInline = (element: Element) => {
+ return element.type === 'mention' ? true : isInline(element)
+ }
+
+ editor.isVoid = (element: Element) => {
+ return element.type === 'mention' ? true : isVoid(element)
+ }
+
+ editor.markableVoid = (element: Element) => {
+ return element.type === 'mention' || markableVoid(element)
+ }
+
+ return editor
+}
diff --git a/packages/web/src/features/chat/useExtractReferences.test.ts b/packages/web/src/features/chat/useExtractReferences.test.ts
new file mode 100644
index 00000000..7208aba4
--- /dev/null
+++ b/packages/web/src/features/chat/useExtractReferences.test.ts
@@ -0,0 +1,40 @@
+import { expect, test } from 'vitest'
+import { renderHook } from '@testing-library/react';
+import { useExtractReferences } from './useExtractReferences';
+import { getFileReferenceId } from './utils';
+import { TextUIPart } from 'ai';
+
+test('useExtractReferences extracts file references from text content', () => {
+ const part: TextUIPart = {
+ type: 'text',
+ text: 'The auth flow is implemented in @file:{github.com/sourcebot-dev/sourcebot::auth.ts} and uses sessions @file:{github.com/sourcebot-dev/sourcebot::auth.ts:45-60}.'
+ }
+
+ const { result } = renderHook(() => useExtractReferences(part));
+
+ expect(result.current).toHaveLength(2);
+ expect(result.current[0]).toMatchObject({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts',
+ id: getFileReferenceId({ repo: 'github.com/sourcebot-dev/sourcebot', path: 'auth.ts' }),
+ type: 'file',
+ });
+
+ expect(result.current[1]).toMatchObject({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts',
+ id: getFileReferenceId({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts',
+ range: {
+ startLine: 45,
+ endLine: 60,
+ }
+ }),
+ type: 'file',
+ range: {
+ startLine: 45,
+ endLine: 60,
+ }
+ });
+});
diff --git a/packages/web/src/features/chat/useExtractReferences.ts b/packages/web/src/features/chat/useExtractReferences.ts
new file mode 100644
index 00000000..45ef173d
--- /dev/null
+++ b/packages/web/src/features/chat/useExtractReferences.ts
@@ -0,0 +1,36 @@
+'use client';
+
+import { useMemo } from "react";
+import { FileReference } from "./types";
+import { FILE_REFERENCE_REGEX } from "./constants";
+import { createFileReference } from "./utils";
+import { TextUIPart } from "ai";
+
+export const useExtractReferences = (part?: TextUIPart) => {
+ return useMemo(() => {
+ if (!part) {
+ return [];
+ }
+
+ const references: FileReference[] = [];
+
+ const content = part.text;
+ FILE_REFERENCE_REGEX.lastIndex = 0;
+
+ let match;
+ while ((match = FILE_REFERENCE_REGEX.exec(content ?? '')) !== null && match !== null) {
+ const [_, repo, fileName, startLine, endLine] = match;
+
+ const fileReference = createFileReference({
+ repo: repo,
+ path: fileName,
+ startLine,
+ endLine,
+ });
+
+ references.push(fileReference);
+ }
+
+ return references;
+ }, [part]);
+};
diff --git a/packages/web/src/features/chat/useMessagePairs.test.ts b/packages/web/src/features/chat/useMessagePairs.test.ts
new file mode 100644
index 00000000..a4417991
--- /dev/null
+++ b/packages/web/src/features/chat/useMessagePairs.test.ts
@@ -0,0 +1,117 @@
+import { expect, test } from 'vitest'
+import { SBChatMessage } from './types';
+import { useMessagePairs } from './useMessagePairs';
+import { renderHook } from '@testing-library/react';
+
+test('useMessagePairs pairs user and assistant messages', () => {
+ const userMessage: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '0'
+ }
+
+ const assistantMessage: SBChatMessage = {
+ role: 'assistant', parts: [],
+ id: '1'
+ }
+
+ const messages: SBChatMessage[] = [
+ userMessage,
+ assistantMessage,
+ ]
+
+ const pairs = renderHook(() => useMessagePairs(messages));
+
+ expect(pairs.result.current).toEqual([
+ [userMessage, assistantMessage],
+ ]);
+
+});
+
+test('pairMessages pairs orphaned user messages with undefined', () => {
+ const userMessage1: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '0'
+ }
+
+ const userMessage2: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '1'
+ }
+
+ const assistantMessage: SBChatMessage = {
+ role: 'assistant', parts: [],
+ id: '2'
+ }
+
+ const messages: SBChatMessage[] = [
+ userMessage1,
+ userMessage2,
+ assistantMessage,
+ ]
+
+ const pairs = renderHook(() => useMessagePairs(messages));
+
+ expect(pairs.result.current).toEqual([
+ [userMessage1, undefined],
+ [userMessage2, assistantMessage],
+ ]);
+});
+
+test('pairMessages ignores orphaned assistant messages', () => {
+ const userMessage: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '0'
+ }
+
+ const assistantMessage1: SBChatMessage = {
+ role: 'assistant', parts: [],
+ id: '1'
+ }
+
+ const assistantMessage2: SBChatMessage = {
+ role: 'assistant', parts: [],
+ id: '2'
+ }
+
+ const messages: SBChatMessage[] = [
+ userMessage,
+ assistantMessage1,
+ assistantMessage2,
+ ]
+
+ const pairs = renderHook(() => useMessagePairs(messages));
+
+ expect(pairs.result.current).toEqual([
+ [userMessage, assistantMessage1],
+ ]);
+})
+
+test('pairMessages pairs the last message with undefined if it is a user message', () => {
+ const userMessage1: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '0'
+ }
+
+ const assistantMessage: SBChatMessage = {
+ role: 'assistant', parts: [],
+ id: '2'
+ }
+
+ const userMessage2: SBChatMessage = {
+ role: 'user', parts: [],
+ id: '1'
+ }
+
+ const messages: SBChatMessage[] = [
+ userMessage1,
+ assistantMessage,
+ userMessage2,
+ ]
+
+ const pairs = renderHook(() => useMessagePairs(messages));
+
+ expect(pairs.result.current).toEqual([
+ [userMessage1, assistantMessage],
+ [userMessage2, undefined],
+ ]);
+})
\ No newline at end of file
diff --git a/packages/web/src/features/chat/useMessagePairs.ts b/packages/web/src/features/chat/useMessagePairs.ts
new file mode 100644
index 00000000..36ce7097
--- /dev/null
+++ b/packages/web/src/features/chat/useMessagePairs.ts
@@ -0,0 +1,43 @@
+'use client';
+
+import { useMemo } from "react";
+import { SBChatMessage } from "./types";
+
+// Pairs user messages with the assistant's response.
+export const useMessagePairs = (messages: SBChatMessage[]): [SBChatMessage, SBChatMessage | undefined][] => {
+ return useMemo(() => {
+ const result: [SBChatMessage, SBChatMessage | undefined][] = [];
+ let pendingUserMessage: SBChatMessage | null = null;
+
+ for (const message of messages) {
+ if (message.role === 'user') {
+ // case: we have a orphaned user message.
+ // Pair it with undefined.
+ if (pendingUserMessage) {
+ result.push([pendingUserMessage, undefined]);
+ }
+
+ pendingUserMessage = message;
+ } else if (message.role === 'assistant') {
+
+ // case: we have a user <> assistant message pair.
+ // Pair them.
+ if (pendingUserMessage) {
+ result.push([pendingUserMessage, message]);
+ pendingUserMessage = null;
+ }
+
+ // case: we have a orphaned assistant message.
+ // Ignore the orphaned assistant message.
+ }
+ }
+
+ // case: the last message is a user message.
+ // Pair it with undefined.
+ if (pendingUserMessage) {
+ result.push([pendingUserMessage, undefined]);
+ }
+
+ return result;
+ }, [messages]);
+};
\ No newline at end of file
diff --git a/packages/web/src/features/chat/useSelectedLanguageModel.ts b/packages/web/src/features/chat/useSelectedLanguageModel.ts
new file mode 100644
index 00000000..7cdc79e4
--- /dev/null
+++ b/packages/web/src/features/chat/useSelectedLanguageModel.ts
@@ -0,0 +1,25 @@
+'use client';
+
+import { useLocalStorage } from "usehooks-ts";
+import { LanguageModelInfo } from "./types";
+
+type Props = {
+ initialLanguageModel?: LanguageModelInfo;
+}
+
+export const useSelectedLanguageModel = ({
+ initialLanguageModel,
+}: Props = {}) => {
+ const [selectedLanguageModel, setSelectedLanguageModel] = useLocalStorage(
+ "selectedLanguageModel",
+ initialLanguageModel,
+ {
+ initializeWithValue: false,
+ }
+ );
+
+ return {
+ selectedLanguageModel,
+ setSelectedLanguageModel,
+ };
+}
\ No newline at end of file
diff --git a/packages/web/src/features/chat/useTOCItems.ts b/packages/web/src/features/chat/useTOCItems.ts
new file mode 100644
index 00000000..44ee62b8
--- /dev/null
+++ b/packages/web/src/features/chat/useTOCItems.ts
@@ -0,0 +1,100 @@
+'use client';
+
+import { useEffect, useRef, useState } from "react";
+
+interface Props {
+ target: HTMLElement | null;
+}
+
+export interface TocItem {
+ id: string;
+ text: string;
+ level: number;
+ element: HTMLElement;
+}
+
+
+export const useExtractTOCItems = ({ target }: Props) => {
+ const [tocItems, setTocItems] = useState([]);
+ const [activeId, setActiveId] = useState('');
+ const observerRef = useRef(null);
+
+ useEffect(() => {
+ const extractHeadings = () => {
+ if (!target) return;
+
+ const headings = target.querySelectorAll('h1, h2, h3, h4, h5, h6');
+ const items: TocItem[] = [];
+
+ headings.forEach((heading) => {
+ const element = heading as HTMLElement;
+ const level = parseInt(element.tagName.charAt(1));
+ const text = element.textContent?.trim() || '';
+
+ if (text && element.id) {
+ items.push({
+ id: element.id,
+ text,
+ level,
+ element
+ });
+ }
+ });
+
+ setTocItems(items);
+ };
+
+ // Initial extraction
+ extractHeadings();
+
+ // Set up MutationObserver to watch for DOM changes
+ if (target) {
+ const observer = new MutationObserver(() => {
+ extractHeadings();
+ });
+
+ observer.observe(target, {
+ childList: true,
+ subtree: true,
+ characterData: true
+ });
+
+ return () => observer.disconnect();
+ }
+ }, [target]);
+
+ // Set up intersection observer for active heading tracking
+ useEffect(() => {
+ if (tocItems.length === 0) return;
+
+ observerRef.current = new IntersectionObserver(
+ (entries) => {
+ entries.forEach((entry) => {
+ if (entry.isIntersecting) {
+ setActiveId(entry.target.id);
+ }
+ });
+ },
+ {
+ rootMargin: '-20px 0px -80% 0px'
+ }
+ );
+
+ tocItems.forEach((item) => {
+ if (observerRef.current) {
+ observerRef.current.observe(item.element);
+ }
+ });
+
+ return () => {
+ if (observerRef.current) {
+ observerRef.current.disconnect();
+ }
+ };
+ }, [tocItems]);
+
+ return {
+ tocItems,
+ activeId
+ }
+}
\ No newline at end of file
diff --git a/packages/web/src/features/chat/utils.test.ts b/packages/web/src/features/chat/utils.test.ts
new file mode 100644
index 00000000..3ebd4e31
--- /dev/null
+++ b/packages/web/src/features/chat/utils.test.ts
@@ -0,0 +1,514 @@
+import { expect, test, vi } from 'vitest'
+import { fileReferenceToString, getAnswerPartFromAssistantMessage, groupMessageIntoSteps, repairReferences, buildSearchQuery } from './utils'
+import { FILE_REFERENCE_REGEX, ANSWER_TAG } from './constants';
+import { SBChatMessage, SBChatMessagePart } from './types';
+
+// Mock the env module
+vi.mock('@/env.mjs', () => ({
+ env: {
+ SOURCEBOT_CHAT_FILE_MAX_CHARACTERS: 4000,
+ }
+}));
+
+
+test('fileReferenceToString formats file references correctly', () => {
+ expect(fileReferenceToString({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts'
+ })).toBe('@file:{github.com/sourcebot-dev/sourcebot::auth.ts}');
+
+ expect(fileReferenceToString({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts',
+ range: {
+ startLine: 45,
+ endLine: 60,
+ }
+ })).toBe('@file:{github.com/sourcebot-dev/sourcebot::auth.ts:45-60}');
+});
+
+test('fileReferenceToString matches FILE_REFERENCE_REGEX', () => {
+ expect(FILE_REFERENCE_REGEX.test(fileReferenceToString({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts'
+ }))).toBe(true);
+
+ FILE_REFERENCE_REGEX.lastIndex = 0;
+ expect(FILE_REFERENCE_REGEX.test(fileReferenceToString({
+ repo: 'github.com/sourcebot-dev/sourcebot',
+ path: 'auth.ts',
+ range: {
+ startLine: 45,
+ endLine: 60,
+ }
+ }))).toBe(true);
+});
+
+test('groupMessageIntoSteps returns an empty array when there are no parts', () => {
+ const parts: SBChatMessagePart[] = []
+
+ const steps = groupMessageIntoSteps(parts);
+
+ expect(steps).toEqual([]);
+});
+
+test('groupMessageIntoSteps returns a single group when there is only one step-start part', () => {
+ const parts: SBChatMessagePart[] = [
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ }
+ ]
+
+ const steps = groupMessageIntoSteps(parts);
+
+ expect(steps).toEqual([
+ [
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ }
+ ]
+ ]);
+});
+
+test('groupMessageIntoSteps returns a multiple groups when there is multiple step-start parts', () => {
+ const parts: SBChatMessagePart[] = [
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ },
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Ok lets go',
+ },
+ ]
+
+ const steps = groupMessageIntoSteps(parts);
+
+ expect(steps).toEqual([
+ [
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ }
+ ],
+ [
+ {
+ type: 'step-start',
+ },
+ {
+ type: 'text',
+ text: 'Ok lets go',
+ }
+ ]
+ ]);
+});
+
+test('groupMessageIntoSteps returns a single group when there is no step-start part', () => {
+ const parts: SBChatMessagePart[] = [
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ },
+ {
+ type: 'text',
+ text: 'Ok lets go',
+ },
+ ]
+
+ const steps = groupMessageIntoSteps(parts);
+
+ expect(steps).toEqual([
+ [
+ {
+ type: 'text',
+ text: 'Hello, world!',
+ },
+ {
+ type: 'text',
+ text: 'Ok lets go',
+ }
+ ]
+ ]);
+});
+
+test('getAnswerPartFromAssistantMessage returns text part when it starts with ANSWER_TAG while not streaming', () => {
+ const message: SBChatMessage = {
+ role: 'assistant',
+ parts: [
+ {
+ type: 'text',
+ text: 'Some initial text'
+ },
+ {
+ type: 'text',
+ text: `${ANSWER_TAG}This is the answer to your question.`
+ }
+ ]
+ } as SBChatMessage;
+
+ const result = getAnswerPartFromAssistantMessage(message, false);
+
+ expect(result).toEqual({
+ type: 'text',
+ text: `${ANSWER_TAG}This is the answer to your question.`
+ });
+});
+
+test('getAnswerPartFromAssistantMessage returns text part when it starts with ANSWER_TAG while streaming', () => {
+ const message: SBChatMessage = {
+ role: 'assistant',
+ parts: [
+ {
+ type: 'text',
+ text: 'Some initial text'
+ },
+ {
+ type: 'text',
+ text: `${ANSWER_TAG}This is the answer to your question.`
+ }
+ ]
+ } as SBChatMessage;
+
+ const result = getAnswerPartFromAssistantMessage(message, true);
+
+ expect(result).toEqual({
+ type: 'text',
+ text: `${ANSWER_TAG}This is the answer to your question.`
+ });
+});
+
+test('getAnswerPartFromAssistantMessage returns last text part as fallback when not streaming and no ANSWER_TAG', () => {
+ const message: SBChatMessage = {
+ role: 'assistant',
+ parts: [
+ {
+ type: 'text',
+ text: 'First text part'
+ },
+ {
+ type: 'tool-call',
+ id: 'call-1',
+ name: 'search',
+ args: {}
+ },
+ {
+ type: 'text',
+ text: 'This is the last text part without answer tag'
+ }
+ ]
+ } as SBChatMessage;
+
+ const result = getAnswerPartFromAssistantMessage(message, false);
+
+ expect(result).toEqual({
+ type: 'text',
+ text: 'This is the last text part without answer tag'
+ });
+});
+
+test('getAnswerPartFromAssistantMessage returns undefined when streaming and no ANSWER_TAG', () => {
+ const message: SBChatMessage = {
+ role: 'assistant',
+ parts: [
+ {
+ type: 'text',
+ text: 'Some text without answer tag'
+ },
+ {
+ type: 'text',
+ text: 'Another text part'
+ }
+ ]
+ } as SBChatMessage;
+
+ const result = getAnswerPartFromAssistantMessage(message, true);
+
+ expect(result).toBeUndefined();
+});
+
+test('repairReferences fixes missing colon after @file', () => {
+ const input = 'See the function in @file{github.com/sourcebot-dev/sourcebot::auth.ts} for details.';
+ const expected = 'See the function in @file:{github.com/sourcebot-dev/sourcebot::auth.ts} for details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences fixes missing colon with range', () => {
+ const input = 'Check @file{github.com/sourcebot-dev/sourcebot::config.ts:15-20} for the configuration.';
+ const expected = 'Check @file:{github.com/sourcebot-dev/sourcebot::config.ts:15-20} for the configuration.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences fixes missing braces around filename', () => {
+ const input = 'The logic is in @file:github.com/sourcebot-dev/sourcebot::utils.js and handles validation.';
+ const expected = 'The logic is in @file:{github.com/sourcebot-dev/sourcebot::utils.js} and handles validation.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences fixes missing braces with path', () => {
+ const input = 'Look at @file:github.com/sourcebot-dev/sourcebot::src/components/Button.tsx for the component.';
+ const expected = 'Look at @file:{github.com/sourcebot-dev/sourcebot::src/components/Button.tsx} for the component.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences removes multiple ranges keeping only first', () => {
+ const input = 'See @file:{github.com/sourcebot-dev/sourcebot::service.ts:10-15,20-25,30-35} for implementation.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::service.ts:10-15} for implementation.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences fixes malformed triple number ranges', () => {
+ const input = 'Check @file:{github.com/sourcebot-dev/sourcebot::handler.ts:5-10-15} for the logic.';
+ const expected = 'Check @file:{github.com/sourcebot-dev/sourcebot::handler.ts:5-10} for the logic.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles multiple citations in same text', () => {
+ const input = 'See @file{github.com/sourcebot-dev/sourcebot::auth.ts} and @file:github.com/sourcebot-dev/sourcebot::config.js for setup details.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::auth.ts} and @file:{github.com/sourcebot-dev/sourcebot::config.js} for setup details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences leaves correctly formatted citations unchanged', () => {
+ const input = 'The function @file:{github.com/sourcebot-dev/sourcebot::utils.ts:42-50} handles validation correctly.';
+ expect(repairReferences(input)).toBe(input);
+});
+
+test('repairReferences handles edge cases with spaces and punctuation', () => {
+ const input = 'Functions like @file:github.com/sourcebot-dev/sourcebot::helper.ts, @file{github.com/sourcebot-dev/sourcebot::main.js}, and @file:{github.com/sourcebot-dev/sourcebot::app.ts:1-5,10-15} work.';
+ const expected = 'Functions like @file:{github.com/sourcebot-dev/sourcebot::helper.ts}, @file:{github.com/sourcebot-dev/sourcebot::main.js}, and @file:{github.com/sourcebot-dev/sourcebot::app.ts:1-5} work.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences returns empty string unchanged', () => {
+ expect(repairReferences('')).toBe('');
+});
+
+test('repairReferences returns text without citations unchanged', () => {
+ const input = 'This is just regular text without any file references.';
+ expect(repairReferences(input)).toBe(input);
+});
+
+test('repairReferences handles complex file paths correctly', () => {
+ const input = 'Check @file:github.com/sourcebot-dev/sourcebot::src/components/ui/Button/index.tsx for implementation.';
+ const expected = 'Check @file:{github.com/sourcebot-dev/sourcebot::src/components/ui/Button/index.tsx} for implementation.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles files with numbers and special characters', () => {
+ const input = 'See @file{github.com/sourcebot-dev/sourcebot::utils-v2.0.1.ts} and @file:github.com/sourcebot-dev/sourcebot::config_2024.json for setup.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::utils-v2.0.1.ts} and @file:{github.com/sourcebot-dev/sourcebot::config_2024.json} for setup.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles citation at end of sentence', () => {
+ const input = 'The implementation is in @file:github.com/sourcebot-dev/sourcebot::helper.ts.';
+ const expected = 'The implementation is in @file:{github.com/sourcebot-dev/sourcebot::helper.ts}.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences preserves already correct citations with ranges', () => {
+ const input = 'The function @file:{github.com/sourcebot-dev/sourcebot::utils.ts:10-20} and variable @file:{github.com/sourcebot-dev/sourcebot::config.js:5} work correctly.';
+ expect(repairReferences(input)).toBe(input);
+});
+
+test('repairReferences handles extra closing parenthesis', () => {
+ const input = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts:5-6)} for details.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts:5-6} for details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles extra colon at end of range', () => {
+ const input = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts:5-6:} for details.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts:5-6} for details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles inline code blocks around file references', () => {
+ const input = 'See `@file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts}` for details.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts} for details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('repairReferences handles malformed inline code blocks', () => {
+ const input = 'See `@file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts`} for details.';
+ const expected = 'See @file:{github.com/sourcebot-dev/sourcebot::packages/web/src/auth.ts} for details.';
+ expect(repairReferences(input)).toBe(expected);
+});
+
+test('buildSearchQuery returns base query when no filters provided', () => {
+ const result = buildSearchQuery({
+ query: 'console.log'
+ });
+
+ expect(result).toBe('console.log');
+});
+
+test('buildSearchQuery adds repoNamesFilter correctly', () => {
+ const result = buildSearchQuery({
+ query: 'function test',
+ repoNamesFilter: ['repo1', 'repo2']
+ });
+
+ expect(result).toBe('function test reposet:repo1,repo2');
+});
+
+test('buildSearchQuery adds single repoNamesFilter correctly', () => {
+ const result = buildSearchQuery({
+ query: 'function test',
+ repoNamesFilter: ['myrepo']
+ });
+
+ expect(result).toBe('function test reposet:myrepo');
+});
+
+test('buildSearchQuery ignores empty repoNamesFilter', () => {
+ const result = buildSearchQuery({
+ query: 'function test',
+ repoNamesFilter: []
+ });
+
+ expect(result).toBe('function test');
+});
+
+test('buildSearchQuery adds languageNamesFilter correctly', () => {
+ const result = buildSearchQuery({
+ query: 'class definition',
+ languageNamesFilter: ['typescript', 'javascript']
+ });
+
+ expect(result).toBe('class definition ( lang:typescript or lang:javascript )');
+});
+
+test('buildSearchQuery adds single languageNamesFilter correctly', () => {
+ const result = buildSearchQuery({
+ query: 'class definition',
+ languageNamesFilter: ['python']
+ });
+
+ expect(result).toBe('class definition ( lang:python )');
+});
+
+test('buildSearchQuery ignores empty languageNamesFilter', () => {
+ const result = buildSearchQuery({
+ query: 'class definition',
+ languageNamesFilter: []
+ });
+
+ expect(result).toBe('class definition');
+});
+
+test('buildSearchQuery adds fileNamesFilterRegexp correctly', () => {
+ const result = buildSearchQuery({
+ query: 'import statement',
+ fileNamesFilterRegexp: ['*.ts', '*.js']
+ });
+
+ expect(result).toBe('import statement ( file:*.ts or file:*.js )');
+});
+
+test('buildSearchQuery adds single fileNamesFilterRegexp correctly', () => {
+ const result = buildSearchQuery({
+ query: 'import statement',
+ fileNamesFilterRegexp: ['*.tsx']
+ });
+
+ expect(result).toBe('import statement ( file:*.tsx )');
+});
+
+test('buildSearchQuery ignores empty fileNamesFilterRegexp', () => {
+ const result = buildSearchQuery({
+ query: 'import statement',
+ fileNamesFilterRegexp: []
+ });
+
+ expect(result).toBe('import statement');
+});
+
+test('buildSearchQuery adds repoNamesFilterRegexp correctly', () => {
+ const result = buildSearchQuery({
+ query: 'bug fix',
+ repoNamesFilterRegexp: ['org/repo1', 'org/repo2']
+ });
+
+ expect(result).toBe('bug fix ( repo:org/repo1 or repo:org/repo2 )');
+});
+
+test('buildSearchQuery adds single repoNamesFilterRegexp correctly', () => {
+ const result = buildSearchQuery({
+ query: 'bug fix',
+ repoNamesFilterRegexp: ['myorg/myrepo']
+ });
+
+ expect(result).toBe('bug fix ( repo:myorg/myrepo )');
+});
+
+test('buildSearchQuery ignores empty repoNamesFilterRegexp', () => {
+ const result = buildSearchQuery({
+ query: 'bug fix',
+ repoNamesFilterRegexp: []
+ });
+
+ expect(result).toBe('bug fix');
+});
+
+test('buildSearchQuery combines multiple filters correctly', () => {
+ const result = buildSearchQuery({
+ query: 'authentication',
+ repoNamesFilter: ['backend', 'frontend'],
+ languageNamesFilter: ['typescript', 'javascript'],
+ fileNamesFilterRegexp: ['*.ts', '*.js'],
+ repoNamesFilterRegexp: ['org/auth-*']
+ });
+
+ expect(result).toBe(
+ 'authentication reposet:backend,frontend ( lang:typescript or lang:javascript ) ( file:*.ts or file:*.js ) ( repo:org/auth-* )'
+ );
+});
+
+test('buildSearchQuery handles mixed empty and non-empty filters', () => {
+ const result = buildSearchQuery({
+ query: 'error handling',
+ repoNamesFilter: [],
+ languageNamesFilter: ['python'],
+ fileNamesFilterRegexp: [],
+ repoNamesFilterRegexp: ['error/*']
+ });
+
+ expect(result).toBe('error handling ( lang:python ) ( repo:error/* )');
+});
+
+test('buildSearchQuery handles empty base query', () => {
+ const result = buildSearchQuery({
+ query: '',
+ repoNamesFilter: ['repo1'],
+ languageNamesFilter: ['typescript']
+ });
+
+ expect(result).toBe(' reposet:repo1 ( lang:typescript )');
+});
+
+test('buildSearchQuery handles query with special characters', () => {
+ const result = buildSearchQuery({
+ query: 'console.log("hello world")',
+ repoNamesFilter: ['test-repo']
+ });
+
+ expect(result).toBe('console.log("hello world") reposet:test-repo');
+});
\ No newline at end of file
diff --git a/packages/web/src/features/chat/utils.ts b/packages/web/src/features/chat/utils.ts
new file mode 100644
index 00000000..c57f3fd5
--- /dev/null
+++ b/packages/web/src/features/chat/utils.ts
@@ -0,0 +1,368 @@
+import { CreateUIMessage, TextUIPart, UIMessagePart } from "ai";
+import { Descendant, Editor, Point, Range, Transforms } from "slate";
+import { ANSWER_TAG, FILE_REFERENCE_PREFIX, FILE_REFERENCE_REGEX } from "./constants";
+import {
+ CustomEditor,
+ CustomText,
+ FileReference,
+ FileSource,
+ MentionData,
+ MentionElement,
+ ParagraphElement,
+ SBChatMessage,
+ SBChatMessagePart,
+ SBChatMessageToolTypes,
+ SearchScope,
+ Source,
+} from "./types";
+
+export const insertMention = (editor: CustomEditor, data: MentionData, target?: Range | null) => {
+ const mention: MentionElement = {
+ type: 'mention',
+ data,
+ children: [{ text: '' }],
+ }
+
+ if (target) {
+ Transforms.select(editor, target)
+ }
+
+ Transforms.insertNodes(editor, mention)
+ Transforms.move(editor)
+}
+
+// @see: https://github.com/ianstormtaylor/slate/issues/4162#issuecomment-1127062098
+export function word(
+ editor: CustomEditor,
+ location: Range,
+ options: {
+ terminator?: string[]
+ include?: boolean
+ directions?: 'both' | 'left' | 'right'
+ } = {},
+): Range | undefined {
+ const { terminator = [' '], include = false, directions = 'both' } = options
+
+ const { selection } = editor
+ if (!selection) return
+
+ // Get start and end, modify it as we move along.
+ let [start, end] = Range.edges(location)
+
+ let point: Point = start
+
+ function move(direction: 'right' | 'left'): boolean {
+ const next =
+ direction === 'right'
+ ? Editor.after(editor, point, {
+ unit: 'character',
+ })
+ : Editor.before(editor, point, { unit: 'character' })
+
+ const wordNext =
+ next &&
+ Editor.string(
+ editor,
+ direction === 'right' ? { anchor: point, focus: next } : { anchor: next, focus: point },
+ )
+
+ const last = wordNext && wordNext[direction === 'right' ? 0 : wordNext.length - 1]
+ if (next && last && !terminator.includes(last)) {
+ point = next
+
+ if (point.offset === 0) {
+ // Means we've wrapped to beginning of another block
+ return false
+ }
+ } else {
+ return false
+ }
+
+ return true
+ }
+
+ // Move point and update start & end ranges
+
+ // Move forwards
+ if (directions !== 'left') {
+ point = end
+ while (move('right'));
+ end = point
+ }
+
+ // Move backwards
+ if (directions !== 'right') {
+ point = start
+ while (move('left'));
+ start = point
+ }
+
+ if (include) {
+ return {
+ anchor: Editor.before(editor, start, { unit: 'offset' }) ?? start,
+ focus: Editor.after(editor, end, { unit: 'offset' }) ?? end,
+ }
+ }
+
+ return { anchor: start, focus: end }
+}
+
+export const isMentionElement = (element: Descendant): element is MentionElement => {
+ return 'type' in element && element.type === 'mention';
+}
+
+export const isCustomTextElement = (element: Descendant): element is CustomText => {
+ return 'text' in element && typeof element.text === 'string';
+}
+
+export const isParagraphElement = (element: Descendant): element is ParagraphElement => {
+ return 'type' in element && element.type === 'paragraph';
+}
+
+export const slateContentToString = (children: Descendant[]): string => {
+ return children.map((child) => {
+ if (isCustomTextElement(child)) {
+ return child.text;
+ }
+
+ else if (isMentionElement(child)) {
+ const { type } = child.data;
+
+ switch (type) {
+ case 'file':
+ return `${fileReferenceToString({ repo: child.data.repo, path: child.data.path })} `;
+ }
+ }
+
+ else if (isParagraphElement(child)) {
+ return `${slateContentToString(child.children)}\n`;
+ }
+
+ else {
+ return "";
+ }
+ }).join("");
+}
+
+export const getAllMentionElements = (children: Descendant[]): MentionElement[] => {
+ return children.flatMap((child) => {
+ if (isCustomTextElement(child)) {
+ return [];
+ }
+
+ if (isMentionElement(child)) {
+ return [child];
+ }
+
+ return getAllMentionElements(child.children);
+ });
+}
+
+// @see: https://stackoverflow.com/a/74102147
+export const resetEditor = (editor: CustomEditor) => {
+ const point = { path: [0, 0], offset: 0 }
+ editor.selection = { anchor: point, focus: point };
+ editor.history = { redos: [], undos: [] };
+ editor.children = [{
+ type: "paragraph",
+ children: [{ text: "" }]
+ }];
+}
+
+export const addLineNumbers = (source: string, lineOffset = 1) => {
+ return source.split('\n').map((line, index) => `${index + lineOffset}:${line}`).join('\n');
+}
+
+export const createUIMessage = (text: string, mentions: MentionData[], selectedSearchScopes: SearchScope[]): CreateUIMessage => {
+ // Converts applicable mentions into sources.
+ const sources: Source[] = mentions
+ .map((mention) => {
+ if (mention.type === 'file') {
+ const fileSource: FileSource = {
+ type: 'file',
+ path: mention.path,
+ repo: mention.repo,
+ name: mention.name,
+ language: mention.language,
+ revision: mention.revision,
+ }
+ return fileSource;
+ }
+
+ return undefined;
+ })
+ .filter((source) => source !== undefined);
+
+ return {
+ role: 'user',
+ parts: [
+ {
+ type: 'text',
+ text,
+ },
+ ...sources.map((data) => ({
+ type: 'data-source',
+ data,
+ })) as UIMessagePart<{ source: Source }, SBChatMessageToolTypes>[],
+ ],
+ metadata: {
+ selectedSearchScopes,
+ },
+ }
+}
+
+export const getFileReferenceId = ({ repo, path, range }: Omit) => {
+ return `file-reference-${repo}::${path}${range ? `-${range.startLine}-${range.endLine}` : ''}`;
+}
+
+export const fileReferenceToString = ({ repo, path, range }: Omit) => {
+ return `${FILE_REFERENCE_PREFIX}{${repo}::${path}${range ? `:${range.startLine}-${range.endLine}` : ''}}`;
+}
+
+export const createFileReference = ({ repo, path, startLine, endLine }: { repo: string, path: string, startLine?: string, endLine?: string }): FileReference => {
+ const range = startLine && endLine ? {
+ startLine: parseInt(startLine),
+ endLine: parseInt(endLine),
+ } : startLine ? {
+ startLine: parseInt(startLine),
+ endLine: parseInt(startLine),
+ } : undefined;
+
+ return {
+ type: 'file',
+ id: getFileReferenceId({ repo, path, range }),
+ repo,
+ path,
+ range,
+ }
+}
+
+/**
+ * Converts LLM text that includes references (e.g., @file:...) into a portable
+ * Markdown format. Practically, this means converting references into Markdown
+ * links and removing the answer tag.
+ */
+export const convertLLMOutputToPortableMarkdown = (text: string): string => {
+ return text
+ .replace(ANSWER_TAG, '')
+ .replace(FILE_REFERENCE_REGEX, (_, _repo, fileName, startLine, endLine) => {
+ const displayName = fileName.split('/').pop() || fileName;
+
+ let linkText = displayName;
+ if (startLine) {
+ if (endLine && startLine !== endLine) {
+ linkText += `:${startLine}-${endLine}`;
+ } else {
+ linkText += `:${startLine}`;
+ }
+ }
+
+ return `[${linkText}](${fileName})`;
+ })
+ .trim();
+}
+
+// Groups message parts into groups based on step-start delimiters.
+export const groupMessageIntoSteps = (parts: SBChatMessagePart[]) => {
+ if (!parts || parts.length === 0) {
+ return [];
+ }
+
+ const steps: SBChatMessagePart[][] = [];
+ let currentStep: SBChatMessagePart[] = [];
+
+ for (let i = 0; i < parts.length; i++) {
+ const part = parts[i];
+
+ if (part.type === 'step-start') {
+ if (currentStep.length > 0) {
+ steps.push([...currentStep]);
+ }
+ currentStep = [part];
+ } else {
+ currentStep.push(part);
+ }
+ }
+
+ if (currentStep.length > 0) {
+ steps.push(currentStep);
+ }
+
+ return steps;
+}
+
+// LLMs like to not follow instructions... this takes care of some common mistakes they tend to make.
+export const repairReferences = (text: string): string => {
+ return text
+ // Fix missing colon: @file{...} -> @file:{...}
+ .replace(/@file\{([^}]+)\}/g, '@file:{$1}')
+ // Fix missing braces: @file:filename -> @file:{filename}
+ .replace(/@file:([^\s{]\S*?)(\s|[,;!?](?:\s|$)|\.(?:\s|$)|$)/g, '@file:{$1}$2')
+ // Fix multiple ranges: keep only first range
+ .replace(/@file:\{(.+?):(\d+-\d+),[\d,-]+\}/g, '@file:{$1:$2}')
+ // Fix malformed ranges
+ .replace(/@file:\{(.+?):(\d+)-(\d+)-(\d+)\}/g, '@file:{$1:$2-$3}')
+ // Fix extra closing parenthesis: @file:{...)} -> @file:{...}
+ .replace(/@file:\{([^}]+)\)\}/g, '@file:{$1}')
+ // Fix extra colon at end: @file:{...range:} -> @file:{...range}
+ .replace(/@file:\{(.+?):(\d+(?:-\d+)?):?\}/g, '@file:{$1:$2}')
+ // Fix inline code blocks around file references: `@file:{...}` -> @file:{...}
+ .replace(/`(@file:\{[^}]+\})`/g, '$1')
+ // Fix malformed inline code blocks: `@file:{...`} -> @file:{...}
+ .replace(/`(@file:\{[^`]+)`\}/g, '$1}');
+};
+
+// Attempts to find the part of the assistant's message
+// that contains the answer.
+export const getAnswerPartFromAssistantMessage = (message: SBChatMessage, isStreaming: boolean): TextUIPart | undefined => {
+ const lastTextPart = message.parts
+ .findLast((part) => part.type === 'text')
+
+ if (lastTextPart?.text.startsWith(ANSWER_TAG)) {
+ return lastTextPart;
+ }
+
+ // If the agent did not include the answer tag, then fallback to using the last text part.
+ // Only do this when we are no longer streaming since the agent may still be thinking.
+ if (!isStreaming && lastTextPart) {
+ return lastTextPart;
+ }
+
+ return undefined;
+}
+
+export const buildSearchQuery = (options: {
+ query: string,
+ repoNamesFilter?: string[],
+ repoNamesFilterRegexp?: string[],
+ languageNamesFilter?: string[],
+ fileNamesFilterRegexp?: string[],
+}) => {
+ const {
+ query: _query,
+ repoNamesFilter,
+ repoNamesFilterRegexp,
+ languageNamesFilter,
+ fileNamesFilterRegexp,
+ } = options;
+
+ let query = `${_query}`;
+
+ if (repoNamesFilter && repoNamesFilter.length > 0) {
+ query += ` reposet:${repoNamesFilter.join(',')}`;
+ }
+
+ if (languageNamesFilter && languageNamesFilter.length > 0) {
+ query += ` ( lang:${languageNamesFilter.join(' or lang:')} )`;
+ }
+
+ if (fileNamesFilterRegexp && fileNamesFilterRegexp.length > 0) {
+ query += ` ( file:${fileNamesFilterRegexp.join(' or file:')} )`;
+ }
+
+ if (repoNamesFilterRegexp && repoNamesFilterRegexp.length > 0) {
+ query += ` ( repo:${repoNamesFilterRegexp.join(' or repo:')} )`;
+ }
+
+ return query;
+}
\ No newline at end of file
diff --git a/packages/web/src/features/codeNav/actions.ts b/packages/web/src/features/codeNav/actions.ts
index f342de6e..b55cfa30 100644
--- a/packages/web/src/features/codeNav/actions.ts
+++ b/packages/web/src/features/codeNav/actions.ts
@@ -34,7 +34,7 @@ export const findSearchBasedSymbolReferences = async (
query,
matches: MAX_REFERENCE_COUNT,
contextLines: 0,
- }, domain);
+ });
if (isServiceError(searchResult)) {
return searchResult;
@@ -67,7 +67,7 @@ export const findSearchBasedSymbolDefinitions = async (
query,
matches: MAX_REFERENCE_COUNT,
contextLines: 0,
- }, domain);
+ });
if (isServiceError(searchResult)) {
return searchResult;
diff --git a/packages/web/src/features/fileTree/actions.ts b/packages/web/src/features/fileTree/actions.ts
index 001a6d10..003b82b2 100644
--- a/packages/web/src/features/fileTree/actions.ts
+++ b/packages/web/src/features/fileTree/actions.ts
@@ -1,13 +1,13 @@
'use server';
-import { sew, withAuth, withOrgMembership } from '@/actions';
+import { sew } from '@/actions';
import { env } from '@/env.mjs';
-import { OrgRole, Repo } from '@sourcebot/db';
-import { prisma } from '@/prisma';
import { notFound, unexpectedError } from '@/lib/serviceError';
-import { simpleGit } from 'simple-git';
-import path from 'path';
+import { withOptionalAuthV2 } from '@/withAuthV2';
+import { Repo } from '@sourcebot/db';
import { createLogger } from '@sourcebot/logger';
+import path from 'path';
+import { simpleGit } from 'simple-git';
const logger = createLogger('file-tree');
@@ -25,188 +25,182 @@ export type FileTreeNode = FileTreeItem & {
* Returns the tree of files (blobs) and directories (trees) for a given repository,
* at a given revision.
*/
-export const getTree = async (params: { repoName: string, revisionName: string }, domain: string) => sew(() =>
- withAuth((session) =>
- withOrgMembership(session, domain, async ({ org }) => {
- const { repoName, revisionName } = params;
- const repo = await prisma.repo.findFirst({
- where: {
- name: repoName,
- orgId: org.id,
- },
- });
+export const getTree = async (params: { repoName: string, revisionName: string }) => sew(() =>
+ withOptionalAuthV2(async ({ org, prisma }) => {
+ const { repoName, revisionName } = params;
+ const repo = await prisma.repo.findFirst({
+ where: {
+ name: repoName,
+ orgId: org.id,
+ },
+ });
- if (!repo) {
- return notFound();
- }
+ if (!repo) {
+ return notFound();
+ }
- const { path: repoPath } = getRepoPath(repo);
+ const { path: repoPath } = getRepoPath(repo);
- const git = simpleGit().cwd(repoPath);
+ const git = simpleGit().cwd(repoPath);
- let result: string;
- try {
- result = await git.raw([
- 'ls-tree',
- revisionName,
- // recursive
- '-r',
- // include trees when recursing
- '-t',
- // format as output as {type},{path}
- '--format=%(objecttype),%(path)',
- ]);
- } catch (error) {
- logger.error('git ls-tree failed.', { error });
- return unexpectedError('git ls-tree command failed.');
- }
+ let result: string;
+ try {
+ result = await git.raw([
+ 'ls-tree',
+ revisionName,
+ // recursive
+ '-r',
+ // include trees when recursing
+ '-t',
+ // format as output as {type},{path}
+ '--format=%(objecttype),%(path)',
+ ]);
+ } catch (error) {
+ logger.error('git ls-tree failed.', { error });
+ return unexpectedError('git ls-tree command failed.');
+ }
- const lines = result.split('\n').filter(line => line.trim());
-
- const flatList = lines.map(line => {
- const [type, path] = line.split(',');
- return {
- type,
- path,
- }
- });
-
- const tree = buildFileTree(flatList);
+ const lines = result.split('\n').filter(line => line.trim());
+ const flatList = lines.map(line => {
+ const [type, path] = line.split(',');
return {
- tree,
+ type,
+ path,
}
+ });
- }, /* minRequiredRole = */ OrgRole.GUEST), /* allowAnonymousAccess = */ true)
-);
+ const tree = buildFileTree(flatList);
+
+ return {
+ tree,
+ }
+
+ }));
/**
* Returns the contents of a folder at a given path in a given repository,
* at a given revision.
*/
-export const getFolderContents = async (params: { repoName: string, revisionName: string, path: string }, domain: string) => sew(() =>
- withAuth((session) =>
- withOrgMembership(session, domain, async ({ org }) => {
- const { repoName, revisionName, path } = params;
- const repo = await prisma.repo.findFirst({
- where: {
- name: repoName,
- orgId: org.id,
- },
- });
+export const getFolderContents = async (params: { repoName: string, revisionName: string, path: string }) => sew(() =>
+ withOptionalAuthV2(async ({ org, prisma }) => {
+ const { repoName, revisionName, path } = params;
+ const repo = await prisma.repo.findFirst({
+ where: {
+ name: repoName,
+ orgId: org.id,
+ },
+ });
- if (!repo) {
- return notFound();
+ if (!repo) {
+ return notFound();
+ }
+
+ const { path: repoPath } = getRepoPath(repo);
+
+ // @note: we don't allow directory traversal
+ // or null bytes in the path.
+ if (path.includes('..') || path.includes('\0')) {
+ return notFound();
+ }
+
+ // Normalize the path by...
+ let normalizedPath = path;
+
+ // ... adding a trailing slash if it doesn't have one.
+ // This is important since ls-tree won't return the contents
+ // of a directory if it doesn't have a trailing slash.
+ if (!normalizedPath.endsWith('/')) {
+ normalizedPath = `${normalizedPath}/`;
+ }
+
+ // ... removing any leading slashes. This is needed since
+ // the path is relative to the repository's root, so we
+ // need a relative path.
+ if (normalizedPath.startsWith('/')) {
+ normalizedPath = normalizedPath.slice(1);
+ }
+
+ const git = simpleGit().cwd(repoPath);
+
+ let result: string;
+ try {
+ result = await git.raw([
+ 'ls-tree',
+ revisionName,
+ // format as output as {type},{path}
+ '--format=%(objecttype),%(path)',
+ ...(normalizedPath.length === 0 ? [] : [normalizedPath]),
+ ]);
+ } catch (error) {
+ logger.error('git ls-tree failed.', { error });
+ return unexpectedError('git ls-tree command failed.');
+ }
+
+ const lines = result.split('\n').filter(line => line.trim());
+
+ const contents: FileTreeItem[] = lines.map(line => {
+ const [type, path] = line.split(',');
+ const name = path.split('/').pop() ?? '';
+
+ return {
+ type,
+ path,
+ name,
}
+ });
- const { path: repoPath } = getRepoPath(repo);
+ return contents;
+ }));
- // @note: we don't allow directory traversal
- // or null bytes in the path.
- if (path.includes('..') || path.includes('\0')) {
- return notFound();
+export const getFiles = async (params: { repoName: string, revisionName: string }) => sew(() =>
+ withOptionalAuthV2(async ({ org, prisma }) => {
+ const { repoName, revisionName } = params;
+
+ const repo = await prisma.repo.findFirst({
+ where: {
+ name: repoName,
+ orgId: org.id,
+ },
+ });
+
+ if (!repo) {
+ return notFound();
+ }
+
+ const { path: repoPath } = getRepoPath(repo);
+
+ const git = simpleGit().cwd(repoPath);
+
+ let result: string;
+ try {
+ result = await git.raw([
+ 'ls-tree',
+ revisionName,
+ // recursive
+ '-r',
+ // only return the names of the files
+ '--name-only',
+ ]);
+ } catch (error) {
+ logger.error('git ls-tree failed.', { error });
+ return unexpectedError('git ls-tree command failed.');
+ }
+
+ const paths = result.split('\n').filter(line => line.trim());
+
+ const files: FileTreeItem[] = paths.map(path => {
+ const name = path.split('/').pop() ?? '';
+ return {
+ type: 'blob',
+ path,
+ name,
}
+ });
- // Normalize the path by...
- let normalizedPath = path;
+ return files;
- // ... adding a trailing slash if it doesn't have one.
- // This is important since ls-tree won't return the contents
- // of a directory if it doesn't have a trailing slash.
- if (!normalizedPath.endsWith('/')) {
- normalizedPath = `${normalizedPath}/`;
- }
-
- // ... removing any leading slashes. This is needed since
- // the path is relative to the repository's root, so we
- // need a relative path.
- if (normalizedPath.startsWith('/')) {
- normalizedPath = normalizedPath.slice(1);
- }
-
- const git = simpleGit().cwd(repoPath);
-
- let result: string;
- try {
- result = await git.raw([
- 'ls-tree',
- revisionName,
- // format as output as {type},{path}
- '--format=%(objecttype),%(path)',
- ...(normalizedPath.length === 0 ? [] : [normalizedPath]),
- ]);
- } catch (error) {
- logger.error('git ls-tree failed.', { error });
- return unexpectedError('git ls-tree command failed.');
- }
-
- const lines = result.split('\n').filter(line => line.trim());
-
- const contents: FileTreeItem[] = lines.map(line => {
- const [type, path] = line.split(',');
- const name = path.split('/').pop() ?? '';
-
- return {
- type,
- path,
- name,
- }
- });
-
- return contents;
- }, /* minRequiredRole = */ OrgRole.GUEST), /* allowAnonymousAccess = */ true)
-);
-
-export const getFiles = async (params: { repoName: string, revisionName: string }, domain: string) => sew(() =>
- withAuth((session) =>
- withOrgMembership(session, domain, async ({ org }) => {
- const { repoName, revisionName } = params;
-
- const repo = await prisma.repo.findFirst({
- where: {
- name: repoName,
- orgId: org.id,
- },
- });
-
- if (!repo) {
- return notFound();
- }
-
- const { path: repoPath } = getRepoPath(repo);
-
- const git = simpleGit().cwd(repoPath);
-
- let result: string;
- try {
- result = await git.raw([
- 'ls-tree',
- revisionName,
- // recursive
- '-r',
- // only return the names of the files
- '--name-only',
- ]);
- } catch (error) {
- logger.error('git ls-tree failed.', { error });
- return unexpectedError('git ls-tree command failed.');
- }
-
- const paths = result.split('\n').filter(line => line.trim());
-
- const files: FileTreeItem[] = paths.map(path => {
- const name = path.split('/').pop() ?? '';
- return {
- type: 'blob',
- path,
- name,
- }
- });
-
- return files;
-
- }, /* minRequiredRole = */ OrgRole.GUEST), /* allowAnonymousAccess = */ true)
-);
+ }));
const buildFileTree = (flatList: { type: string, path: string }[]): FileTreeNode => {
const root: FileTreeNode = {
diff --git a/packages/web/src/features/fileTree/components/fileTreeItemComponent.tsx b/packages/web/src/features/fileTree/components/fileTreeItemComponent.tsx
index 8fec32bf..17fc1ed3 100644
--- a/packages/web/src/features/fileTree/components/fileTreeItemComponent.tsx
+++ b/packages/web/src/features/fileTree/components/fileTreeItemComponent.tsx
@@ -6,6 +6,7 @@ import clsx from "clsx";
import scrollIntoView from 'scroll-into-view-if-needed';
import { ChevronDownIcon, ChevronRightIcon } from "@radix-ui/react-icons";
import { FileTreeItemIcon } from "./fileTreeItemIcon";
+import Link from "next/link";
export const FileTreeItemComponent = ({
node,
@@ -13,7 +14,9 @@ export const FileTreeItemComponent = ({
depth,
isCollapsed = false,
isCollapseChevronVisible = true,
+ href,
onClick,
+ onNavigate,
parentRef,
}: {
node: FileTreeItem,
@@ -21,10 +24,12 @@ export const FileTreeItemComponent = ({
depth: number,
isCollapsed?: boolean,
isCollapseChevronVisible?: boolean,
- onClick: () => void,
- parentRef: React.RefObject,
+ href: string,
+ onClick?: (e: React.MouseEvent) => void,
+ onNavigate?: (e: { preventDefault: () => void }) => void,
+ parentRef: React.RefObject,
}) => {
- const ref = useRef(null);
+ const ref = useRef(null);
useEffect(() => {
if (isActive && ref.current) {
@@ -51,20 +56,16 @@ export const FileTreeItemComponent = ({
}, [isActive, parentRef]);
return (
- {
- if (e.key === 'Enter') {
- e.preventDefault();
- onClick();
- }
- }}
onClick={onClick}
+ onNavigate={onNavigate}
>
{node.name}
-
+
)
}
diff --git a/packages/web/src/features/fileTree/components/fileTreeItemIcon.tsx b/packages/web/src/features/fileTree/components/fileTreeItemIcon.tsx
index 1d481e3d..e685899a 100644
--- a/packages/web/src/features/fileTree/components/fileTreeItemIcon.tsx
+++ b/packages/web/src/features/fileTree/components/fileTreeItemIcon.tsx
@@ -2,9 +2,8 @@
import { FileTreeItem } from "../actions";
import { useMemo } from "react";
-import { getIconForFile, getIconForFolder } from "vscode-icons-js";
-import { Icon } from '@iconify/react';
-import { cn } from "@/lib/utils";
+import { VscodeFolderIcon } from "@/app/components/vscodeFolderIcon";
+import { VscodeFileIcon } from "@/app/components/vscodeFileIcon";
interface FileTreeItemIconProps {
item: FileTreeItem;
@@ -12,23 +11,13 @@ interface FileTreeItemIconProps {
}
export const FileTreeItemIcon = ({ item, className }: FileTreeItemIconProps) => {
- const iconName = useMemo(() => {
+ const ItemIcon = useMemo(() => {
if (item.type === 'tree') {
- const icon = getIconForFolder(item.name);
- if (icon) {
- const iconName = `vscode-icons:${icon.substring(0, icon.indexOf('.')).replaceAll('_', '-')}`;
- return iconName;
- }
- } else if (item.type === 'blob') {
- const icon = getIconForFile(item.name);
- if (icon) {
- const iconName = `vscode-icons:${icon.substring(0, icon.indexOf('.')).replaceAll('_', '-')}`;
- return iconName;
- }
+ return
+ } else {
+ return
}
+ }, [item.name, item.type, className]);
- return "vscode-icons:file-type-unknown";
- }, [item.name, item.type]);
-
- return
;
+ return ItemIcon;
}
\ No newline at end of file
diff --git a/packages/web/src/features/fileTree/components/fileTreePanel.tsx b/packages/web/src/features/fileTree/components/fileTreePanel.tsx
index fffabeba..a7579628 100644
--- a/packages/web/src/features/fileTree/components/fileTreePanel.tsx
+++ b/packages/web/src/features/fileTree/components/fileTreePanel.tsx
@@ -3,7 +3,6 @@
import { getTree } from "../actions";
import { useQuery } from "@tanstack/react-query";
import { unwrapServiceError } from "@/lib/utils";
-import { useDomain } from "@/hooks/useDomain";
import { ResizablePanel } from "@/components/ui/resizable";
import { Skeleton } from "@/components/ui/skeleton";
import { useBrowseState } from "@/app/[domain]/browse/hooks/useBrowseState";
@@ -41,17 +40,16 @@ export const FileTreePanel = ({ order }: FileTreePanelProps) => {
updateBrowseState,
} = useBrowseState();
- const domain = useDomain();
const { repoName, revisionName, path } = useBrowseParams();
const fileTreePanelRef = useRef
(null);
const { data, isPending, isError } = useQuery({
- queryKey: ['tree', repoName, revisionName, domain],
+ queryKey: ['tree', repoName, revisionName],
queryFn: () => unwrapServiceError(
getTree({
repoName,
revisionName: revisionName ?? 'HEAD',
- }, domain)
+ })
),
});
diff --git a/packages/web/src/features/fileTree/components/pureFileTreePanel.tsx b/packages/web/src/features/fileTree/components/pureFileTreePanel.tsx
index bc7347fb..88c1ab2f 100644
--- a/packages/web/src/features/fileTree/components/pureFileTreePanel.tsx
+++ b/packages/web/src/features/fileTree/components/pureFileTreePanel.tsx
@@ -4,9 +4,9 @@ import { FileTreeNode as RawFileTreeNode } from "../actions";
import { ScrollArea, ScrollBar } from "@/components/ui/scroll-area";
import React, { useCallback, useMemo, useState, useEffect, useRef } from "react";
import { FileTreeItemComponent } from "./fileTreeItemComponent";
-import { useBrowseNavigation } from "@/app/[domain]/browse/hooks/useBrowseNavigation";
+import { getBrowsePath } from "@/app/[domain]/browse/hooks/useBrowseNavigation";
import { useBrowseParams } from "@/app/[domain]/browse/hooks/useBrowseParams";
-
+import { useDomain } from "@/hooks/useDomain";
export type FileTreeNode = Omit & {
isCollapsed: boolean;
@@ -41,8 +41,8 @@ interface PureFileTreePanelProps {
export const PureFileTreePanel = ({ tree: _tree, path }: PureFileTreePanelProps) => {
const [tree, setTree] = useState(buildCollapsibleTree(_tree));
const scrollAreaRef = useRef(null);
- const { navigateToPath } = useBrowseNavigation();
const { repoName, revisionName } = useBrowseParams();
+ const domain = useDomain();
// @note: When `_tree` changes, it indicates that a new tree has been loaded.
// In that case, we need to rebuild the collapsible tree.
@@ -72,21 +72,6 @@ export const PureFileTreePanel = ({ tree: _tree, path }: PureFileTreePanelProps)
}
}, [path, setIsCollapsed]);
- const onNodeClicked = useCallback((node: FileTreeNode) => {
- if (node.type === 'tree') {
- setIsCollapsed(node.path, !node.isCollapsed);
- }
- else if (node.type === 'blob') {
- navigateToPath({
- repoName: repoName,
- revisionName: revisionName,
- path: node.path,
- pathType: 'blob',
- });
-
- }
- }, [setIsCollapsed, navigateToPath, repoName, revisionName]);
-
const renderTree = useCallback((nodes: FileTreeNode, depth = 0): React.ReactNode => {
return (
<>
@@ -94,13 +79,35 @@ export const PureFileTreePanel = ({ tree: _tree, path }: PureFileTreePanelProps)
return (
onNodeClicked(node)}
+ // Only collapse the tree when a regular click happens.
+ // (i.e., not ctrl/cmd click).
+ onClick={(e) => {
+ const isMetaOrCtrlKey = e.metaKey || e.ctrlKey;
+ if (node.type === 'tree' && !isMetaOrCtrlKey) {
+ setIsCollapsed(node.path, !node.isCollapsed);
+ }
+ }}
+ // @note: onNavigate _won't_ be called when the user ctrl/cmd clicks on a tree node.
+ // So when a regular click happens, we want to prevent the navigation from happening
+ // and instead collapse the tree.
+ onNavigate={(e) => {
+ if (node.type === 'tree') {
+ e.preventDefault();
+ }
+ }}
parentRef={scrollAreaRef}
/>
{node.children.length > 0 && !node.isCollapsed && renderTree(node, depth + 1)}
@@ -109,7 +116,7 @@ export const PureFileTreePanel = ({ tree: _tree, path }: PureFileTreePanelProps)
})}
);
- }, [path, onNodeClicked]);
+ }, [path]);
const renderedTree = useMemo(() => renderTree(tree), [tree, renderTree]);
diff --git a/packages/web/src/features/search/fileSourceApi.ts b/packages/web/src/features/search/fileSourceApi.ts
index e1fd756b..249abb42 100644
--- a/packages/web/src/features/search/fileSourceApi.ts
+++ b/packages/web/src/features/search/fileSourceApi.ts
@@ -1,52 +1,62 @@
'use server';
import escapeStringRegexp from "escape-string-regexp";
-import { fileNotFound, ServiceError } from "../../lib/serviceError";
+import { fileNotFound, ServiceError, unexpectedError } from "../../lib/serviceError";
import { FileSourceRequest, FileSourceResponse } from "./types";
import { isServiceError } from "../../lib/utils";
import { search } from "./searchApi";
-import { sew, withAuth, withOrgMembership } from "@/actions";
-import { OrgRole } from "@sourcebot/db";
+import { sew } from "@/actions";
+import { withOptionalAuthV2 } from "@/withAuthV2";
// @todo (bkellam) : We should really be using `git show :` to fetch file contents here.
// This will allow us to support permalinks to files at a specific revision that may not be indexed
// by zoekt.
-export const getFileSource = async ({ fileName, repository, branch }: FileSourceRequest, domain: string, apiKey: string | undefined = undefined): Promise => sew(() =>
- withAuth((userId, _apiKeyHash) =>
- withOrgMembership(userId, domain, async () => {
- const escapedFileName = escapeStringRegexp(fileName);
- const escapedRepository = escapeStringRegexp(repository);
+export const getFileSource = async ({ fileName, repository, branch }: FileSourceRequest): Promise => sew(() =>
+ withOptionalAuthV2(async () => {
+ const escapedFileName = escapeStringRegexp(fileName);
+ const escapedRepository = escapeStringRegexp(repository);
- let query = `file:${escapedFileName} repo:^${escapedRepository}$`;
- if (branch) {
- query = query.concat(` branch:${branch}`);
- }
+ let query = `file:${escapedFileName} repo:^${escapedRepository}$`;
+ if (branch) {
+ query = query.concat(` branch:${branch}`);
+ }
- const searchResponse = await search({
- query,
- matches: 1,
- whole: true,
- }, domain, apiKey);
+ const searchResponse = await search({
+ query,
+ matches: 1,
+ whole: true,
+ });
- if (isServiceError(searchResponse)) {
- return searchResponse;
- }
+ if (isServiceError(searchResponse)) {
+ return searchResponse;
+ }
- const files = searchResponse.files;
+ const files = searchResponse.files;
- if (!files || files.length === 0) {
- return fileNotFound(fileName, repository);
- }
+ if (!files || files.length === 0) {
+ return fileNotFound(fileName, repository);
+ }
- const file = files[0];
- const source = file.content ?? '';
- const language = file.language;
-
- return {
- source,
- language,
- webUrl: file.webUrl,
- } satisfies FileSourceResponse;
+ const file = files[0];
+ const source = file.content ?? '';
+ const language = file.language;
- }, /* minRequiredRole = */ OrgRole.GUEST), /* allowAnonymousAccess = */ true, apiKey ? { apiKey, domain } : undefined)
-);
+ const repoInfo = searchResponse.repositoryInfo.find((repo) => repo.id === file.repositoryId);
+ if (!repoInfo) {
+ // This should never happen.
+ return unexpectedError("Repository info not found");
+ }
+
+ return {
+ source,
+ language,
+ path: fileName,
+ repository,
+ repositoryCodeHostType: repoInfo.codeHostType,
+ repositoryDisplayName: repoInfo.displayName,
+ repositoryWebUrl: repoInfo.webUrl,
+ branch,
+ webUrl: file.webUrl,
+ } satisfies FileSourceResponse;
+
+ }));
diff --git a/packages/web/src/features/search/listReposApi.ts b/packages/web/src/features/search/listReposApi.ts
deleted file mode 100644
index 90a685bd..00000000
--- a/packages/web/src/features/search/listReposApi.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { OrgRole } from "@sourcebot/db";
-import { invalidZoektResponse, ServiceError } from "../../lib/serviceError";
-import { ListRepositoriesResponse } from "./types";
-import { zoektFetch } from "./zoektClient";
-import { zoektListRepositoriesResponseSchema } from "./zoektSchema";
-import { sew, withAuth, withOrgMembership } from "@/actions";
-
-export const listRepositories = async (domain: string, apiKey: string | undefined = undefined): Promise => sew(() =>
- withAuth((userId, _apiKeyHash) =>
- withOrgMembership(userId, domain, async ({ org }) => {
- const body = JSON.stringify({
- opts: {
- Field: 0,
- }
- });
-
- let header: Record = {};
- header = {
- "X-Tenant-ID": org.id.toString()
- };
-
- const listResponse = await zoektFetch({
- path: "/api/list",
- body,
- header,
- method: "POST",
- cache: "no-store",
- });
-
- if (!listResponse.ok) {
- return invalidZoektResponse(listResponse);
- }
-
- const listBody = await listResponse.json();
-
- const parser = zoektListRepositoriesResponseSchema.transform(({ List }) => ({
- repos: List.Repos.map((repo) => ({
- name: repo.Repository.Name,
- webUrl: repo.Repository.URL.length > 0 ? repo.Repository.URL : undefined,
- branches: repo.Repository.Branches?.map((branch) => branch.Name) ?? [],
- rawConfig: repo.Repository.RawConfig ?? undefined,
- }))
- } satisfies ListRepositoriesResponse));
-
- const result = parser.parse(listBody);
-
- return result;
- }, /* minRequiredRole = */ OrgRole.GUEST), /* allowAnonymousAccess = */ true, apiKey ? { apiKey, domain } : undefined)
-);
diff --git a/packages/web/src/features/search/schemas.ts b/packages/web/src/features/search/schemas.ts
index 1c99d885..18dfd8d4 100644
--- a/packages/web/src/features/search/schemas.ts
+++ b/packages/web/src/features/search/schemas.ts
@@ -94,17 +94,6 @@ export const searchResponseSchema = z.object({
isBranchFilteringEnabled: z.boolean(),
});
-export const repositorySchema = z.object({
- name: z.string(),
- branches: z.array(z.string()),
- webUrl: z.string().optional(),
- rawConfig: z.record(z.string(), z.string()).optional(),
-});
-
-export const listRepositoriesResponseSchema = z.object({
- repos: z.array(repositorySchema),
-});
-
export const fileSourceRequestSchema = z.object({
fileName: z.string(),
repository: z.string(),
@@ -114,5 +103,11 @@ export const fileSourceRequestSchema = z.object({
export const fileSourceResponseSchema = z.object({
source: z.string(),
language: z.string(),
+ path: z.string(),
+ repository: z.string(),
+ repositoryCodeHostType: z.string(),
+ repositoryDisplayName: z.string().optional(),
+ repositoryWebUrl: z.string().optional(),
+ branch: z.string().optional(),
webUrl: z.string().optional(),
});
\ No newline at end of file
diff --git a/packages/web/src/features/search/searchApi.ts b/packages/web/src/features/search/searchApi.ts
index 05a913f2..60d04dec 100644
--- a/packages/web/src/features/search/searchApi.ts
+++ b/packages/web/src/features/search/searchApi.ts
@@ -1,16 +1,17 @@
+'use server';
+
import { env } from "@/env.mjs";
import { invalidZoektResponse, ServiceError } from "../../lib/serviceError";
import { isServiceError } from "../../lib/utils";
import { zoektFetch } from "./zoektClient";
-import { prisma } from "@/prisma";
import { ErrorCode } from "../../lib/errorCodes";
import { StatusCodes } from "http-status-codes";
import { zoektSearchResponseSchema } from "./zoektSchema";
import { SearchRequest, SearchResponse, SourceRange } from "./types";
-import { OrgRole, Repo } from "@sourcebot/db";
-import * as Sentry from "@sentry/nextjs";
-import { sew, withAuth, withOrgMembership } from "@/actions";
+import { PrismaClient, Repo } from "@sourcebot/db";
+import { sew } from "@/actions";
import { base64Decode } from "@sourcebot/shared";
+import { withOptionalAuthV2 } from "@/withAuthV2";
// List of supported query prefixes in zoekt.
// @see : https://github.com/sourcebot-dev/zoekt/blob/main/query/parse.go#L417
@@ -35,7 +36,7 @@ enum zoektPrefixes {
reposet = "reposet:",
}
-const transformZoektQuery = async (query: string, orgId: number): Promise