Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Extract project/workspace related functionality to Effect services (#1524)

Julius Marminge2d03847ccd53
diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
index e66a214fb..9340b9460 100644
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -68,6 +68,7 @@ import {
type TestProviderAdapterHarness,
} from "./TestProviderAdapter.integration.ts";
import { deriveServerPaths, ServerConfig } from "../src/config.ts";
+import { WorkspaceEntriesLive } from "../src/workspace/Layers/WorkspaceEntries.ts";
function runGit(cwd: string, args: ReadonlyArray<string>) {
return execFileSync("git", args, {
@@ -317,6 +318,12 @@ export const makeOrchestrationIntegrationHarness = (
);
const checkpointReactorLayer = CheckpointReactorLive.pipe(
Layer.provideMerge(runtimeServicesLayer),
+ Layer.provideMerge(
+ WorkspaceEntriesLive.pipe(
+ Layer.provideMerge(gitCoreLayer),
+ Layer.provide(NodeServices.layer),
+ ),
+ ),
);
const orchestrationReactorLayer = OrchestrationReactorLive.pipe(
Layer.provideMerge(runtimeIngestionLayer),
diff --git a/apps/server/src/git/Layers/GitCore.test.ts b/apps/server/src/git/Layers/GitCore.test.ts
index 547a69e7e..135834f89 100644
--- a/apps/server/src/git/Layers/GitCore.test.ts
+++ b/apps/server/src/git/Layers/GitCore.test.ts
@@ -138,6 +138,13 @@ function buildLargeText(lineCount = 20_000): string {
.concat("\n");
}
+function splitNullSeparatedPaths(input: string): string[] {
+ return input
+ .split("\0")
+ .map((value) => value.trim())
+ .filter((value) => value.length > 0);
+}
+
// ── Tests ──
it.layer(TestLayer)("git integration", (it) => {
@@ -181,6 +188,55 @@ it.layer(TestLayer)("git integration", (it) => {
);
});
+ describe("workspace helpers", () => {
+ it.effect("filterIgnoredPaths chunks large path lists and preserves kept paths", () =>
+ Effect.gen(function* () {
+ const cwd = "/virtual/repo";
+ const relativePaths = Array.from({ length: 340 }, (_, index) => {
+ const prefix = index % 3 === 0 ? "ignored" : "kept";
+ return `${prefix}/segment-${String(index).padStart(4, "0")}/${"x".repeat(900)}.ts`;
+ });
+ const expectedPaths = relativePaths.filter(
+ (relativePath) => !relativePath.startsWith("ignored/"),
+ );
+
+ const seenChunks: string[][] = [];
+ const core = yield* makeIsolatedGitCore((input) => {
+ if (input.args.join(" ") !== "check-ignore --no-index -z --stdin") {
+ return Effect.fail(
+ new GitCommandError({
+ operation: input.operation,
+ command: `git ${input.args.join(" ")}`,
+ cwd: input.cwd,
+ detail: "unexpected git command in chunking test",
+ }),
+ );
+ }
+
+ const chunkPaths = splitNullSeparatedPaths(input.stdin ?? "");
+ seenChunks.push(chunkPaths);
+ const ignoredPaths = chunkPaths.filter((relativePath) =>
+ relativePath.startsWith("ignored/"),
+ );
+
+ return Effect.succeed({
+ code: ignoredPaths.length > 0 ? 0 : 1,
+ stdout: ignoredPaths.length > 0 ? `${ignoredPaths.join("\0")}\0` : "",
+ stderr: "",
+ stdoutTruncated: false,
+ stderrTruncated: false,
+ });
+ });
+
+ const result = yield* core.filterIgnoredPaths(cwd, relativePaths);
+
+ expect(seenChunks.length).toBeGreaterThan(1);
+ expect(seenChunks.flat()).toEqual(relativePaths);
+ expect(result).toEqual(expectedPaths);
+ }),
+ );
+ });
+
// ── listGitBranches ──
describe("listGitBranches", () => {
@@ -457,12 +513,18 @@ it.layer(TestLayer)("git integration", (it) => {
yield* (yield* GitCore).checkoutBranch({ cwd: source, branch: featureBranch });
const core = yield* GitCore;
yield* Effect.promise(() =>
- vi.waitFor(async () => {
- const details = await runPromise(core.statusDetails(source));
- expect(details.branch).toBe(featureBranch);
- expect(details.aheadCount).toBe(0);
- expect(details.behindCount).toBe(1);
- }),
+ vi.waitFor(
+ async () => {
+ const details = await runPromise(core.statusDetails(source));
+ expect(details.branch).toBe(featureBranch);
+ expect(details.aheadCount).toBe(0);
+ expect(details.behindCount).toBe(1);
+ },
+ {
+ timeout: 10_000,
+ interval: 100,
+ },
+ ),
);
}),
);
@@ -541,7 +603,13 @@ it.layer(TestLayer)("git integration", (it) => {
const core = yield* makeIsolatedGitCore((input) => {
if (input.args[0] === "fetch") {
fetchArgs = [...input.args];
- return Effect.succeed({ code: 0, stdout: "", stderr: "" });
+ return Effect.succeed({
+ code: 0,
+ stdout: "",
+ stderr: "",
+ stdoutTruncated: false,
+ stderrTruncated: false,
+ });
}
return realGitCore.execute(input);
});
@@ -594,7 +662,13 @@ it.layer(TestLayer)("git integration", (it) => {
if (input.args[0] === "fetch") {
fetchStarted = true;
return Effect.promise(() =>
- waitForReleasePromise.then(() => ({ code: 0, stdout: "", stderr: "" })),
+ waitForReleasePromise.then(() => ({
+ code: 0,
+ stdout: "",
+ stderr: "",
+ stdoutTruncated: false,
+ stderrTruncated: false,
+ })),
);
}
return realGitCore.execute(input);
diff --git a/apps/server/src/git/Layers/GitCore.ts b/apps/server/src/git/Layers/GitCore.ts
index 64ed40950..81d6cbb54 100644
--- a/apps/server/src/git/Layers/GitCore.ts
+++ b/apps/server/src/git/Layers/GitCore.ts
@@ -37,6 +37,8 @@ const PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES = 49_000;
const RANGE_COMMIT_SUMMARY_MAX_OUTPUT_BYTES = 19_000;
const RANGE_DIFF_SUMMARY_MAX_OUTPUT_BYTES = 19_000;
const RANGE_DIFF_PATCH_MAX_OUTPUT_BYTES = 59_000;
+const WORKSPACE_FILES_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+const GIT_CHECK_IGNORE_MAX_STDIN_BYTES = 256 * 1024;
const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2_048;
@@ -55,6 +57,7 @@ class StatusUpstreamRefreshCacheKey extends Data.Class<{
}> {}
interface ExecuteGitOptions {
+ stdin?: string | undefined;
timeoutMs?: number | undefined;
allowNonZeroExit?: boolean | undefined;
fallbackErrorMessage?: string | undefined;
@@ -96,6 +99,47 @@ function parseNumstatEntries(
return entries;
}
+function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
+ const parts = input.split("\0");
+ if (parts.length === 0) return [];
+
+ if (truncated && parts[parts.length - 1]?.length) {
+ parts.pop();
+ }
+
+ return parts.filter((value) => value.length > 0);
+}
+
+function chunkPathsForGitCheckIgnore(relativePaths: readonly string[]): string[][] {
+ const chunks: string[][] = [];
+ let chunk: string[] = [];
+ let chunkBytes = 0;
+
+ for (const relativePath of relativePaths) {
+ const relativePathBytes = Buffer.byteLength(relativePath) + 1;
+ if (chunk.length > 0 && chunkBytes + relativePathBytes > GIT_CHECK_IGNORE_MAX_STDIN_BYTES) {
+ chunks.push(chunk);
+ chunk = [];
+ chunkBytes = 0;
+ }
+
+ chunk.push(relativePath);
+ chunkBytes += relativePathBytes;
+
+ if (chunkBytes >= GIT_CHECK_IGNORE_MAX_STDIN_BYTES) {
+ chunks.push(chunk);
+ chunk = [];
+ chunkBytes = 0;
+ }
+ }
+
+ if (chunk.length > 0) {
+ chunks.push(chunk);
+ }
+
+ return chunks;
+}
+
function parsePorcelainPath(line: string): string | null {
if (line.startsWith("? ") || line.startsWith("! ")) {
const simple = line.slice(2).trim();
@@ -445,7 +489,7 @@ const collectOutput = Effect.fn("collectOutput")(function* <E>(
maxOutputBytes: number,
truncateOutputAtMaxBytes: boolean,
onLine: ((line: string) => Effect.Effect<void, never>) | undefined,
-): Effect.fn.Return<string, GitCommandError> {
+): Effect.fn.Return<{ readonly text: string; readonly truncated: boolean }, GitCommandError> {
const decoder = new TextDecoder();
let bytes = 0;
let text = "";
@@ -507,7 +551,10 @@ const collectOutput = Effect.fn("collectOutput")(function* <E>(
text += remainder;
lineBuffer += remainder;
yield* emitCompleteLines(true);
- return truncated ? `${text}${OUTPUT_TRUNCATED_MARKER}` : text;
+ return {
+ text,
+ truncated,
+ };
});
export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
@@ -571,13 +618,18 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
Effect.map((value) => Number(value)),
Effect.mapError(toGitCommandError(commandInput, "failed to report exit code.")),
),
+ input.stdin === undefined
+ ? Effect.void
+ : Stream.run(Stream.encodeText(Stream.make(input.stdin)), child.stdin).pipe(
+ Effect.mapError(toGitCommandError(commandInput, "failed to write stdin.")),
+ ),
],
{ concurrency: "unbounded" },
- );
+ ).pipe(Effect.map(([stdout, stderr, exitCode]) => [stdout, stderr, exitCode] as const));
yield* trace2Monitor.flush;
if (!input.allowNonZeroExit && exitCode !== 0) {
- const trimmedStderr = stderr.trim();
+ const trimmedStderr = stderr.text.trim();
return yield* new GitCommandError({
operation: commandInput.operation,
command: quoteGitCommand(commandInput.args),
@@ -589,7 +641,13 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
});
}
- return { code: exitCode, stdout, stderr } satisfies ExecuteGitResult;
+ return {
+ code: exitCode,
+ stdout: stdout.text,
+ stderr: stderr.text,
+ stdoutTruncated: stdout.truncated,
+ stderrTruncated: stderr.truncated,
+ } satisfies ExecuteGitResult;
});
return yield* runGitCommand().pipe(
@@ -618,11 +676,12 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
cwd: string,
args: readonly string[],
options: ExecuteGitOptions = {},
- ): Effect.Effect<{ code: number; stdout: string; stderr: string }, GitCommandError> =>
+ ): Effect.Effect<ExecuteGitResult, GitCommandError> =>
execute({
operation,
cwd,
args,
+ ...(options.stdin !== undefined ? { stdin: options.stdin } : {}),
allowNonZeroExit: true,
...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
@@ -679,7 +738,11 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
args: readonly string[],
options: ExecuteGitOptions = {},
): Effect.Effect<string, GitCommandError> =>
- executeGit(operation, cwd, args, options).pipe(Effect.map((result) => result.stdout));
+ executeGit(operation, cwd, args, options).pipe(
+ Effect.map((result) =>
+ result.stdoutTruncated ? `${result.stdout}${OUTPUT_TRUNCATED_MARKER}` : result.stdout,
+ ),
+ );
const branchExists = (cwd: string, branch: string): Effect.Effect<boolean, GitCommandError> =>
executeGit(
@@ -1416,6 +1479,86 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
Effect.map((trimmed) => (trimmed.length > 0 ? trimmed : null)),
);
+ const isInsideWorkTree: GitCoreShape["isInsideWorkTree"] = (cwd) =>
+ executeGit("GitCore.isInsideWorkTree", cwd, ["rev-parse", "--is-inside-work-tree"], {
+ allowNonZeroExit: true,
+ timeoutMs: 5_000,
+ maxOutputBytes: 4_096,
+ }).pipe(Effect.map((result) => result.code === 0 && result.stdout.trim() === "true"));
+
+ const listWorkspaceFiles: GitCoreShape["listWorkspaceFiles"] = (cwd) =>
+ executeGit(
+ "GitCore.listWorkspaceFiles",
+ cwd,
+ ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
+ {
+ allowNonZeroExit: true,
+ timeoutMs: 20_000,
+ maxOutputBytes: WORKSPACE_FILES_MAX_OUTPUT_BYTES,
+ truncateOutputAtMaxBytes: true,
+ },
+ ).pipe(
+ Effect.flatMap((result) =>
+ result.code === 0
+ ? Effect.succeed({
+ paths: splitNullSeparatedPaths(result.stdout, result.stdoutTruncated),
+ truncated: result.stdoutTruncated,
+ })
+ : Effect.fail(
+ createGitCommandError(
+ "GitCore.listWorkspaceFiles",
+ cwd,
+ ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
+ result.stderr.trim().length > 0 ? result.stderr.trim() : "git ls-files failed",
+ ),
+ ),
+ ),
+ );
+
+ const filterIgnoredPaths: GitCoreShape["filterIgnoredPaths"] = (cwd, relativePaths) =>
+ Effect.gen(function* () {
+ if (relativePaths.length === 0) {
+ return relativePaths;
+ }
+
+ const ignoredPaths = new Set<string>();
+ const chunks = chunkPathsForGitCheckIgnore(relativePaths);
+
+ for (const chunk of chunks) {
+ const result = yield* executeGit(
+ "GitCore.filterIgnoredPaths",
+ cwd,
+ ["check-ignore", "--no-index", "-z", "--stdin"],
+ {
+ stdin: `${chunk.join("\0")}\0`,
+ allowNonZeroExit: true,
+ timeoutMs: 20_000,
+ maxOutputBytes: WORKSPACE_FILES_MAX_OUTPUT_BYTES,
+ truncateOutputAtMaxBytes: true,
+ },
+ );
+
+ if (result.code !== 0 && result.code !== 1) {
+ return yield* createGitCommandError(
+ "GitCore.filterIgnoredPaths",
+ cwd,
+ ["check-ignore", "--no-index", "-z", "--stdin"],
+ result.stderr.trim().length > 0 ? result.stderr.trim() : "git check-ignore failed",
+ );
+ }
+
+ for (const ignoredPath of splitNullSeparatedPaths(result.stdout, result.stdoutTruncated)) {
+ ignoredPaths.add(ignoredPath);
+ }
+ }
+
+ if (ignoredPaths.size === 0) {
+ return relativePaths;
+ }
+
+ return relativePaths.filter((relativePath) => !ignoredPaths.has(relativePath));
+ });
+
const listBranches: GitCoreShape["listBranches"] = Effect.fn("listBranches")(function* (input) {
const branchRecencyPromise = readBranchRecency(input.cwd).pipe(
Effect.catch(() => Effect.succeed(new Map<string, number>())),
@@ -1834,6 +1977,9 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
pullCurrentBranch,
readRangeContext,
readConfigValue,
+ isInsideWorkTree,
+ listWorkspaceFiles,
+ filterIgnoredPaths,
listBranches,
createWorktree,
fetchPullRequestBranch,
diff --git a/apps/server/src/git/Services/GitCore.ts b/apps/server/src/git/Services/GitCore.ts
index f1a4e065c..3c30f1712 100644
--- a/apps/server/src/git/Services/GitCore.ts
+++ b/apps/server/src/git/Services/GitCore.ts
@@ -28,6 +28,7 @@ export interface ExecuteGitInput {
readonly operation: string;
readonly cwd: string;
readonly args: ReadonlyArray<string>;
+ readonly stdin?: string;
readonly env?: NodeJS.ProcessEnv;
readonly allowNonZeroExit?: boolean;
readonly timeoutMs?: number;
@@ -40,6 +41,8 @@ export interface ExecuteGitResult {
readonly code: number;
readonly stdout: string;
readonly stderr: string;
+ readonly stdoutTruncated: boolean;
+ readonly stderrTruncated: boolean;
}
export interface GitStatusDetails extends Omit<GitStatusResult, "pr"> {
@@ -93,6 +96,11 @@ export interface GitRangeContext {
diffPatch: string;
}
+export interface GitListWorkspaceFilesResult {
+ readonly paths: ReadonlyArray<string>;
+ readonly truncated: boolean;
+}
+
export interface GitRenameBranchInput {
cwd: string;
oldBranch: string;
@@ -190,6 +198,26 @@ export interface GitCoreShape {
key: string,
) => Effect.Effect<string | null, GitCommandError>;
+ /**
+ * Determine whether the provided cwd is inside a git work tree.
+ */
+ readonly isInsideWorkTree: (cwd: string) => Effect.Effect<boolean, GitCommandError>;
+
+ /**
+ * List tracked and untracked workspace file paths relative to cwd.
+ */
+ readonly listWorkspaceFiles: (
+ cwd: string,
+ ) => Effect.Effect<GitListWorkspaceFilesResult, GitCommandError>;
+
+ /**
+ * Remove gitignored paths from a relative path list.
+ */
+ readonly filterIgnoredPaths: (
+ cwd: string,
+ relativePaths: ReadonlyArray<string>,
+ ) => Effect.Effect<ReadonlyArray<string>, GitCommandError>;
+
/**
* List local + remote branches and branch metadata.
*/
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
index 075f62f88..7c201af37 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
@@ -38,6 +38,7 @@ import {
} from "../../provider/Services/ProviderService.ts";
import { checkpointRefForThreadTurn } from "../../checkpointing/Utils.ts";
import { ServerConfig } from "../../config.ts";
+import { WorkspaceEntriesLive } from "../../workspace/Layers/WorkspaceEntries.ts";
const asProjectId = (value: string): ProjectId => ProjectId.makeUnsafe(value);
const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
@@ -261,7 +262,9 @@ describe("CheckpointReactor", () => {
Layer.provideMerge(orchestrationLayer),
Layer.provideMerge(RuntimeReceiptBusLive),
Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
- Layer.provideMerge(CheckpointStoreLive.pipe(Layer.provide(GitCoreLive))),
+ Layer.provideMerge(CheckpointStoreLive),
+ Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(GitCoreLive),
Layer.provideMerge(ServerConfigLayer),
Layer.provideMerge(NodeServices.layer),
);
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.ts
index 561626b8d..28609cecb 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.ts
@@ -16,7 +16,6 @@ import {
checkpointRefForThreadTurn,
resolveThreadWorkspaceCwd,
} from "../../checkpointing/Utils.ts";
-import { clearWorkspaceIndexCache } from "../../workspaceEntries.ts";
import { CheckpointStore } from "../../checkpointing/Services/CheckpointStore.ts";
import { ProviderService } from "../../provider/Services/ProviderService.ts";
import { CheckpointReactor, type CheckpointReactorShape } from "../Services/CheckpointReactor.ts";
@@ -25,6 +24,7 @@ import { RuntimeReceiptBus } from "../Services/RuntimeReceiptBus.ts";
import { CheckpointStoreError } from "../../checkpointing/Errors.ts";
import { OrchestrationDispatchError } from "../Errors.ts";
import { isGitRepository } from "../../git/Utils.ts";
+import { WorkspaceEntries } from "../../workspace/Services/WorkspaceEntries.ts";
type ReactorInput =
| {
@@ -68,6 +68,7 @@ const make = Effect.gen(function* () {
const providerService = yield* ProviderService;
const checkpointStore = yield* CheckpointStore;
const receiptBus = yield* RuntimeReceiptBus;
+ const workspaceEntries = yield* WorkspaceEntries;
const appendRevertFailureActivity = (input: {
readonly threadId: ThreadId;
@@ -226,7 +227,7 @@ const make = Effect.gen(function* () {
// Invalidate the workspace entry cache so the @-mention file picker
// reflects files created or deleted during this turn.
- clearWorkspaceIndexCache(input.cwd);
+ yield* workspaceEntries.invalidate(input.cwd);
const files = yield* checkpointStore
.diffCheckpoints({
@@ -642,7 +643,7 @@ const make = Effect.gen(function* () {
// Invalidate the workspace entry cache so the @-mention file picker
// reflects the reverted filesystem state.
- clearWorkspaceIndexCache(sessionRuntime.value.cwd);
+ yield* workspaceEntries.invalidate(sessionRuntime.value.cwd);
const rolledBackTurns = Math.max(0, currentTurnCount - event.payload.turnCount);
if (rolledBackTurns > 0) {
diff --git a/apps/server/src/project/Layers/ProjectFaviconResolver.test.ts b/apps/server/src/project/Layers/ProjectFaviconResolver.test.ts
new file mode 100644
index 000000000..29b30739b
--- /dev/null
+++ b/apps/server/src/project/Layers/ProjectFaviconResolver.test.ts
@@ -0,0 +1,74 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it, describe, expect } from "@effect/vitest";
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import { ProjectFaviconResolver } from "../Services/ProjectFaviconResolver.ts";
+import { ProjectFaviconResolverLive } from "./ProjectFaviconResolver.ts";
+
+const TestLayer = Layer.empty.pipe(
+ Layer.provideMerge(ProjectFaviconResolverLive),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+const makeTempDir = Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ return yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3code-project-favicon-",
+ });
+});
+
+const writeTextFile = Effect.fn("writeTextFile")(function* (
+ cwd: string,
+ relativePath: string,
+ contents: string,
+) {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const absolutePath = path.join(cwd, relativePath);
+ yield* fileSystem
+ .makeDirectory(path.dirname(absolutePath), { recursive: true })
+ .pipe(Effect.orDie);
+ yield* fileSystem.writeFileString(absolutePath, contents).pipe(Effect.orDie);
+});
+
+it.layer(TestLayer)("ProjectFaviconResolverLive", (it) => {
+ describe("resolvePath", () => {
+ it.effect("prefers well-known favicon files", () =>
+ Effect.gen(function* () {
+ const resolver = yield* ProjectFaviconResolver;
+ const cwd = yield* makeTempDir;
+ yield* writeTextFile(cwd, "favicon.svg", "<svg>favicon</svg>");
+
+ const resolved = yield* resolver.resolvePath(cwd);
+
+ expect(resolved).not.toBeNull();
+ expect(resolved).toContain("favicon.svg");
+ }),
+ );
+
+ it.effect("resolves icon hrefs from project source files", () =>
+ Effect.gen(function* () {
+ const resolver = yield* ProjectFaviconResolver;
+ const cwd = yield* makeTempDir;
+ yield* writeTextFile(cwd, "index.html", '<link rel="icon" href="/brand/logo.svg">');
+ yield* writeTextFile(cwd, "public/brand/logo.svg", "<svg>brand</svg>");
+
+ const resolved = yield* resolver.resolvePath(cwd);
+
+ expect(resolved).not.toBeNull();
+ expect(resolved).toContain("public/brand/logo.svg");
+ }),
+ );
+
+ it.effect("returns null when no icon is present", () =>
+ Effect.gen(function* () {
+ const resolver = yield* ProjectFaviconResolver;
+ const cwd = yield* makeTempDir;
+
+ const resolved = yield* resolver.resolvePath(cwd);
+
+ expect(resolved).toBeNull();
+ }),
+ );
+ });
+});
diff --git a/apps/server/src/project/Layers/ProjectFaviconResolver.ts b/apps/server/src/project/Layers/ProjectFaviconResolver.ts
new file mode 100644
index 000000000..3004a7a45
--- /dev/null
+++ b/apps/server/src/project/Layers/ProjectFaviconResolver.ts
@@ -0,0 +1,129 @@
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import {
+ ProjectFaviconResolver,
+ type ProjectFaviconResolverShape,
+} from "../Services/ProjectFaviconResolver.ts";
+
+// Well-known favicon paths checked in order.
+const FAVICON_CANDIDATES = [
+ "favicon.svg",
+ "favicon.ico",
+ "favicon.png",
+ "public/favicon.svg",
+ "public/favicon.ico",
+ "public/favicon.png",
+ "app/favicon.ico",
+ "app/favicon.png",
+ "app/icon.svg",
+ "app/icon.png",
+ "app/icon.ico",
+ "src/favicon.ico",
+ "src/favicon.svg",
+ "src/app/favicon.ico",
+ "src/app/icon.svg",
+ "src/app/icon.png",
+ "assets/icon.svg",
+ "assets/icon.png",
+ "assets/logo.svg",
+ "assets/logo.png",
+] as const;
+
+// Files that may contain a <link rel="icon"> or icon metadata declaration.
+const ICON_SOURCE_FILES = [
+ "index.html",
+ "public/index.html",
+ "app/routes/__root.tsx",
+ "src/routes/__root.tsx",
+ "app/root.tsx",
+ "src/root.tsx",
+ "src/index.html",
+] as const;
+
+// Matches <link ...> tags or object-like icon metadata where rel/href can appear in any order.
+const LINK_ICON_HTML_RE =
+ /<link\b(?=[^>]*\brel=["'](?:icon|shortcut icon)["'])(?=[^>]*\bhref=["']([^"'?]+))[^>]*>/i;
+const LINK_ICON_OBJ_RE =
+ /(?=[^}]*\brel\s*:\s*["'](?:icon|shortcut icon)["'])(?=[^}]*\bhref\s*:\s*["']([^"'?]+))[^}]*/i;
+
+function extractIconHref(source: string): string | null {
+ const htmlMatch = source.match(LINK_ICON_HTML_RE);
+ if (htmlMatch?.[1]) return htmlMatch[1];
+ const objMatch = source.match(LINK_ICON_OBJ_RE);
+ if (objMatch?.[1]) return objMatch[1];
+ return null;
+}
+
+export const makeProjectFaviconResolver = Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+
+ const resolveIconHref = (projectCwd: string, href: string): string[] => {
+ const clean = href.replace(/^\//, "");
+ return [path.join(projectCwd, "public", clean), path.join(projectCwd, clean)];
+ };
+
+ const isPathWithinProject = (projectCwd: string, candidatePath: string): boolean => {
+ const relative = path.relative(path.resolve(projectCwd), path.resolve(candidatePath));
+ return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+ };
+
+ const findExistingFile = Effect.fn("ProjectFaviconResolver.findExistingFile")(function* (
+ projectCwd: string,
+ candidates: ReadonlyArray<string>,
+ ): Effect.fn.Return<string | null> {
+ for (const candidate of candidates) {
+ if (!isPathWithinProject(projectCwd, candidate)) {
+ continue;
+ }
+ const stats = yield* fileSystem
+ .stat(candidate)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (stats?.type === "File") {
+ return candidate;
+ }
+ }
+ return null;
+ });
+
+ const resolvePath: ProjectFaviconResolverShape["resolvePath"] = Effect.fn(
+ "ProjectFaviconResolver.resolvePath",
+ )(function* (cwd: string): Effect.fn.Return<string | null> {
+ for (const candidate of FAVICON_CANDIDATES) {
+ const resolved = path.join(cwd, candidate);
+ const existing = yield* findExistingFile(cwd, [resolved]);
+ if (existing) {
+ return existing;
+ }
+ }
+
+ for (const sourceFile of ICON_SOURCE_FILES) {
+ const sourcePath = path.join(cwd, sourceFile);
+ const source = yield* fileSystem
+ .readFileString(sourcePath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!source) {
+ continue;
+ }
+ const href = extractIconHref(source);
+ if (!href) {
+ continue;
+ }
+ const existing = yield* findExistingFile(cwd, resolveIconHref(cwd, href));
+ if (existing) {
+ return existing;
+ }
+ }
+
+ return null;
+ });
+
+ return {
+ resolvePath,
+ } satisfies ProjectFaviconResolverShape;
+});
+
+export const ProjectFaviconResolverLive = Layer.effect(
+ ProjectFaviconResolver,
+ makeProjectFaviconResolver,
+);
diff --git a/apps/server/src/project/Services/ProjectFaviconResolver.ts b/apps/server/src/project/Services/ProjectFaviconResolver.ts
new file mode 100644
index 000000000..f6a8e22c0
--- /dev/null
+++ b/apps/server/src/project/Services/ProjectFaviconResolver.ts
@@ -0,0 +1,30 @@
+/**
+ * ProjectFaviconResolver - Effect service contract for project icon discovery.
+ *
+ * Resolves a representative favicon or app icon file for a workspace by
+ * checking common file locations and project source metadata.
+ *
+ * @module ProjectFaviconResolver
+ */
+import { ServiceMap } from "effect";
+import type { Effect } from "effect";
+
+/**
+ * ProjectFaviconResolverShape - Service API for project favicon lookup.
+ */
+export interface ProjectFaviconResolverShape {
+ /**
+ * Resolve a favicon or icon file path for the provided workspace root.
+ *
+ * Returns `null` when no candidate icon file can be found.
+ */
+ readonly resolvePath: (cwd: string) => Effect.Effect<string | null>;
+}
+
+/**
+ * ProjectFaviconResolver - Service tag for project favicon resolution.
+ */
+export class ProjectFaviconResolver extends ServiceMap.Service<
+ ProjectFaviconResolver,
+ ProjectFaviconResolverShape
+>()("t3/project/Services/ProjectFaviconResolver") {}
diff --git a/apps/server/src/projectFaviconRoute.test.ts b/apps/server/src/projectFaviconRoute.test.ts
index a346e513e..99b61aedc 100644
--- a/apps/server/src/projectFaviconRoute.test.ts
+++ b/apps/server/src/projectFaviconRoute.test.ts
@@ -3,7 +3,11 @@ import http from "node:http";
import os from "node:os";
import path from "node:path";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect } from "effect";
import { afterEach, describe, expect, it } from "vitest";
+
+import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
import { tryHandleProjectFaviconRequest } from "./projectFaviconRoute";
interface HttpResponse {
@@ -23,11 +27,25 @@ function makeTempDir(prefix: string): string {
async function withRouteServer(run: (baseUrl: string) => Promise<void>): Promise<void> {
const server = http.createServer((req, res) => {
const url = new URL(req.url ?? "/", "http://127.0.0.1");
- if (tryHandleProjectFaviconRequest(url, res)) {
- return;
- }
- res.writeHead(404, { "Content-Type": "text/plain" });
- res.end("Not Found");
+ void Effect.runPromise(
+ tryHandleProjectFaviconRequest(url, res).pipe(
+ Effect.provide(ProjectFaviconResolverLive),
+ Effect.provide(NodeServices.layer),
+ Effect.flatMap((handled) =>
+ handled
+ ? Effect.void
+ : Effect.sync(() => {
+ res.writeHead(404, { "Content-Type": "text/plain" });
+ res.end("Not Found");
+ }),
+ ),
+ ),
+ ).catch(() => {
+ if (!res.headersSent) {
+ res.writeHead(500, { "Content-Type": "text/plain" });
+ res.end("Internal Server Error");
+ }
+ });
});
await new Promise<void>((resolve, reject) => {
diff --git a/apps/server/src/projectFaviconRoute.ts b/apps/server/src/projectFaviconRoute.ts
index cf234ad89..56a9fc903 100644
--- a/apps/server/src/projectFaviconRoute.ts
+++ b/apps/server/src/projectFaviconRoute.ts
@@ -1,6 +1,8 @@
-import fs from "node:fs";
import http from "node:http";
import path from "node:path";
+import { Effect, FileSystem } from "effect";
+
+import { ProjectFaviconResolver } from "./project/Services/ProjectFaviconResolver.ts";
const FAVICON_MIME_TYPES: Record<string, string> = {
".png": "image/png",
@@ -11,161 +13,64 @@ const FAVICON_MIME_TYPES: Record<string, string> = {
const FALLBACK_FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none" stroke="#6b728080" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" data-fallback="project-favicon"><path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-8l-2-2H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2Z"/></svg>`;
-// Well-known favicon paths checked in order.
-const FAVICON_CANDIDATES = [
- "favicon.svg",
- "favicon.ico",
- "favicon.png",
- "public/favicon.svg",
- "public/favicon.ico",
- "public/favicon.png",
- "app/favicon.ico",
- "app/favicon.png",
- "app/icon.svg",
- "app/icon.png",
- "app/icon.ico",
- "src/favicon.ico",
- "src/favicon.svg",
- "src/app/favicon.ico",
- "src/app/icon.svg",
- "src/app/icon.png",
- "assets/icon.svg",
- "assets/icon.png",
- "assets/logo.svg",
- "assets/logo.png",
-];
-
-// Files that may contain a <link rel="icon"> or icon metadata declaration.
-const ICON_SOURCE_FILES = [
- "index.html",
- "public/index.html",
- "app/routes/__root.tsx",
- "src/routes/__root.tsx",
- "app/root.tsx",
- "src/root.tsx",
- "src/index.html",
-];
-
-// Matches <link ...> tags or object-like icon metadata where rel/href can appear in any order.
-const LINK_ICON_HTML_RE =
- /<link\b(?=[^>]*\brel=["'](?:icon|shortcut icon)["'])(?=[^>]*\bhref=["']([^"'?]+))[^>]*>/i;
-const LINK_ICON_OBJ_RE =
- /(?=[^}]*\brel\s*:\s*["'](?:icon|shortcut icon)["'])(?=[^}]*\bhref\s*:\s*["']([^"'?]+))[^}]*/i;
-
-function extractIconHref(source: string): string | null {
- const htmlMatch = source.match(LINK_ICON_HTML_RE);
- if (htmlMatch?.[1]) return htmlMatch[1];
- const objMatch = source.match(LINK_ICON_OBJ_RE);
- if (objMatch?.[1]) return objMatch[1];
- return null;
-}
-
-function resolveIconHref(projectCwd: string, href: string): string[] {
- const clean = href.replace(/^\//, "");
- return [path.join(projectCwd, "public", clean), path.join(projectCwd, clean)];
-}
-
-function isPathWithinProject(projectCwd: string, candidatePath: string): boolean {
- const relative = path.relative(path.resolve(projectCwd), path.resolve(candidatePath));
- return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-
-function serveFaviconFile(filePath: string, res: http.ServerResponse): void {
- const ext = path.extname(filePath).toLowerCase();
- const contentType = FAVICON_MIME_TYPES[ext] ?? "application/octet-stream";
- fs.readFile(filePath, (readErr, data) => {
- if (readErr) {
- res.writeHead(500, { "Content-Type": "text/plain" });
- res.end("Read error");
- return;
+export const tryHandleProjectFaviconRequest = Effect.fn("tryHandleProjectFaviconRequest")(
+ function* (
+ url: URL,
+ res: http.ServerResponse,
+ ): Effect.fn.Return<boolean, never, ProjectFaviconResolver | FileSystem.FileSystem> {
+ const respond = (
+ statusCode: number,
+ headers: Record<string, string>,
+ body: string | Uint8Array,
+ ) => {
+ res.writeHead(statusCode, headers);
+ res.end(body);
+ };
+
+ if (url.pathname !== "/api/project-favicon") {
+ return false;
}
- res.writeHead(200, {
- "Content-Type": contentType,
- "Cache-Control": "public, max-age=3600",
- });
- res.end(data);
- });
-}
-function serveFallbackFavicon(res: http.ServerResponse): void {
- res.writeHead(200, {
- "Content-Type": "image/svg+xml",
- "Cache-Control": "public, max-age=3600",
- });
- res.end(FALLBACK_FAVICON_SVG);
-}
-
-export function tryHandleProjectFaviconRequest(url: URL, res: http.ServerResponse): boolean {
- if (url.pathname !== "/api/project-favicon") {
- return false;
- }
-
- const projectCwd = url.searchParams.get("cwd");
- if (!projectCwd) {
- res.writeHead(400, { "Content-Type": "text/plain" });
- res.end("Missing cwd parameter");
- return true;
- }
-
- const tryResolvedPaths = (paths: string[], index: number, onExhausted: () => void): void => {
- if (index >= paths.length) {
- onExhausted();
- return;
+ const projectCwd = url.searchParams.get("cwd");
+ if (!projectCwd) {
+ respond(400, { "Content-Type": "text/plain" }, "Missing cwd parameter");
+ return true;
}
- const candidate = paths[index]!;
- if (!isPathWithinProject(projectCwd, candidate)) {
- tryResolvedPaths(paths, index + 1, onExhausted);
- return;
- }
- fs.stat(candidate, (err, stats) => {
- if (err || !stats?.isFile()) {
- tryResolvedPaths(paths, index + 1, onExhausted);
- return;
- }
- serveFaviconFile(candidate, res);
- });
- };
- const trySourceFiles = (index: number): void => {
- if (index >= ICON_SOURCE_FILES.length) {
- serveFallbackFavicon(res);
- return;
+ const fileSystem = yield* FileSystem.FileSystem;
+ const faviconResolver = yield* ProjectFaviconResolver;
+ const resolvedPath = yield* faviconResolver.resolvePath(projectCwd);
+
+ if (!resolvedPath) {
+ respond(
+ 200,
+ {
+ "Content-Type": "image/svg+xml",
+ "Cache-Control": "public, max-age=3600",
+ },
+ FALLBACK_FAVICON_SVG,
+ );
+ return true;
}
- const sourceFile = path.join(projectCwd, ICON_SOURCE_FILES[index]!);
- fs.readFile(sourceFile, "utf8", (err, content) => {
- if (err) {
- trySourceFiles(index + 1);
- return;
- }
- const href = extractIconHref(content);
- if (!href) {
- trySourceFiles(index + 1);
- return;
- }
- const candidates = resolveIconHref(projectCwd, href);
- tryResolvedPaths(candidates, 0, () => trySourceFiles(index + 1));
- });
- };
- const tryCandidates = (index: number): void => {
- if (index >= FAVICON_CANDIDATES.length) {
- trySourceFiles(0);
- return;
- }
- const candidate = path.join(projectCwd, FAVICON_CANDIDATES[index]!);
- if (!isPathWithinProject(projectCwd, candidate)) {
- tryCandidates(index + 1);
- return;
+ const data = yield* fileSystem
+ .readFile(resolvedPath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!data) {
+ respond(500, { "Content-Type": "text/plain" }, "Read error");
+ return true;
}
- fs.stat(candidate, (err, stats) => {
- if (err || !stats?.isFile()) {
- tryCandidates(index + 1);
- return;
- }
- serveFaviconFile(candidate, res);
- });
- };
- tryCandidates(0);
- return true;
-}
+ const ext = path.extname(resolvedPath).toLowerCase();
+ const contentType = FAVICON_MIME_TYPES[ext] ?? "application/octet-stream";
+ respond(
+ 200,
+ {
+ "Content-Type": contentType,
+ "Cache-Control": "public, max-age=3600",
+ },
+ data,
+ );
+ return true;
+ },
+);
diff --git a/apps/server/src/serverLayers.ts b/apps/server/src/serverLayers.ts
index a8c1a13f7..f745d553a 100644
--- a/apps/server/src/serverLayers.ts
+++ b/apps/server/src/serverLayers.ts
@@ -34,6 +34,10 @@ import { GitHubCliLive } from "./git/Layers/GitHubCli";
import { RoutingTextGenerationLive } from "./git/Layers/RoutingTextGeneration";
import { PtyAdapter } from "./terminal/Services/PTY";
import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
+import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
+import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries.ts";
+import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem.ts";
+import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths.ts";
type RuntimePtyAdapterLoader = {
layer: Layer.Layer<PtyAdapter, never, FileSystem.FileSystem | Path.Path>;
@@ -91,7 +95,8 @@ export function makeServerProviderLayer(): Layer.Layer<
export function makeServerRuntimeServicesLayer() {
const textGenerationLayer = RoutingTextGenerationLive;
- const checkpointStoreLayer = CheckpointStoreLive.pipe(Layer.provide(GitCoreLive));
+ const gitCoreLayer = GitCoreLive;
+ const checkpointStoreLayer = CheckpointStoreLive;
const orchestrationLayer = OrchestrationEngineLive.pipe(
Layer.provide(OrchestrationProjectionPipelineLive),
@@ -116,11 +121,11 @@ export function makeServerRuntimeServicesLayer() {
);
const providerCommandReactorLayer = ProviderCommandReactorLive.pipe(
Layer.provideMerge(runtimeServicesLayer),
- Layer.provideMerge(GitCoreLive),
Layer.provideMerge(textGenerationLayer),
);
const checkpointReactorLayer = CheckpointReactorLive.pipe(
Layer.provideMerge(runtimeServicesLayer),
+ Layer.provideMerge(WorkspaceEntriesLive),
);
const orchestrationReactorLayer = OrchestrationReactorLive.pipe(
Layer.provideMerge(runtimeIngestionLayer),
@@ -131,16 +136,26 @@ export function makeServerRuntimeServicesLayer() {
const terminalLayer = TerminalManagerLive.pipe(Layer.provide(makeRuntimePtyAdapterLayer()));
const gitManagerLayer = GitManagerLive.pipe(
- Layer.provideMerge(GitCoreLive),
Layer.provideMerge(GitHubCliLive),
Layer.provideMerge(textGenerationLayer),
);
+ const workspacePathsLayer = WorkspacePathsLive;
+ const workspaceEntriesLayer = WorkspaceEntriesLive;
+ const workspaceFileSystemLayer = WorkspaceFileSystemLive.pipe(
+ Layer.provide(workspacePathsLayer),
+ Layer.provide(workspaceEntriesLayer),
+ );
+ const projectFaviconResolverLayer = ProjectFaviconResolverLive;
+
return Layer.mergeAll(
orchestrationReactorLayer,
- GitCoreLive,
+ workspacePathsLayer,
+ workspaceEntriesLayer,
+ workspaceFileSystemLayer,
+ projectFaviconResolverLayer,
gitManagerLayer,
terminalLayer,
KeybindingsLive,
- ).pipe(Layer.provideMerge(NodeServices.layer));
+ ).pipe(Layer.provideMerge(gitCoreLayer), Layer.provideMerge(NodeServices.layer));
}
diff --git a/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts b/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts
new file mode 100644
index 000000000..1d1eb4f0e
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspaceEntries.test.ts
@@ -0,0 +1,264 @@
+import fsPromises from "node:fs/promises";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it, afterEach, describe, expect, vi } from "@effect/vitest";
+import { Effect, FileSystem, Layer, Path, PlatformError } from "effect";
+
+import { ServerConfig } from "../../config.ts";
+import { GitCoreLive } from "../../git/Layers/GitCore.ts";
+import { GitCore } from "../../git/Services/GitCore.ts";
+import { WorkspaceEntries } from "../Services/WorkspaceEntries.ts";
+import { WorkspaceEntriesLive } from "./WorkspaceEntries.ts";
+
+const TestLayer = Layer.empty.pipe(
+ Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(GitCoreLive),
+ Layer.provide(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3-workspace-entries-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+const makeTempDir = Effect.fn(function* (opts?: { prefix?: string; git?: boolean }) {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const gitCore = yield* GitCore;
+ const dir = yield* fileSystem.makeTempDirectoryScoped({
+ prefix: opts?.prefix ?? "t3code-workspace-entries-",
+ });
+ if (opts?.git) {
+ yield* gitCore.initRepo({ cwd: dir });
+ }
+ return dir;
+});
+
+function writeTextFile(
+ cwd: string,
+ relativePath: string,
+ contents = "",
+): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> {
+ return Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const absolutePath = path.join(cwd, relativePath);
+ yield* fileSystem.makeDirectory(path.dirname(absolutePath), { recursive: true });
+ yield* fileSystem.writeFileString(absolutePath, contents);
+ });
+}
+
+const git = (cwd: string, args: ReadonlyArray<string>, env?: NodeJS.ProcessEnv) =>
+ Effect.gen(function* () {
+ const gitCore = yield* GitCore;
+ const result = yield* gitCore.execute({
+ operation: "WorkspaceEntries.test.git",
+ cwd,
+ args,
+ ...(env ? { env } : {}),
+ timeoutMs: 10_000,
+ });
+ return result.stdout.trim();
+ });
+
+const searchWorkspaceEntries = (input: { cwd: string; query: string; limit: number }) =>
+ Effect.gen(function* () {
+ const workspaceEntries = yield* WorkspaceEntries;
+ return yield* workspaceEntries.search(input);
+ });
+
+it.layer(TestLayer)("WorkspaceEntriesLive", (it) => {
+ afterEach(() => {
+ vi.restoreAllMocks();
+ });
+
+ describe("search", () => {
+ it.effect("returns files and directories relative to cwd", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir();
+ yield* writeTextFile(cwd, "src/components/Composer.tsx");
+ yield* writeTextFile(cwd, "src/index.ts");
+ yield* writeTextFile(cwd, "README.md");
+ yield* writeTextFile(cwd, ".git/HEAD");
+ yield* writeTextFile(cwd, "node_modules/pkg/index.js");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+ const paths = result.entries.map((entry) => entry.path);
+
+ expect(paths).toContain("src");
+ expect(paths).toContain("src/components");
+ expect(paths).toContain("src/components/Composer.tsx");
+ expect(paths).toContain("README.md");
+ expect(paths.some((entryPath) => entryPath.startsWith(".git"))).toBe(false);
+ expect(paths.some((entryPath) => entryPath.startsWith("node_modules"))).toBe(false);
+ expect(result.truncated).toBe(false);
+ }),
+ );
+
+ it.effect("filters and ranks entries by query", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-query-" });
+ yield* writeTextFile(cwd, "src/components/Composer.tsx");
+ yield* writeTextFile(cwd, "src/components/composePrompt.ts");
+ yield* writeTextFile(cwd, "docs/composition.md");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "compo", limit: 5 });
+
+ expect(result.entries.length).toBeGreaterThan(0);
+ expect(result.entries.some((entry) => entry.path === "src/components")).toBe(true);
+ expect(result.entries.every((entry) => entry.path.toLowerCase().includes("compo"))).toBe(
+ true,
+ );
+ }),
+ );
+
+ it.effect("supports fuzzy subsequence queries for composer path search", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-fuzzy-query-" });
+ yield* writeTextFile(cwd, "src/components/Composer.tsx");
+ yield* writeTextFile(cwd, "src/components/composePrompt.ts");
+ yield* writeTextFile(cwd, "docs/composition.md");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "cmp", limit: 10 });
+ const paths = result.entries.map((entry) => entry.path);
+
+ expect(result.entries.length).toBeGreaterThan(0);
+ expect(paths).toContain("src/components");
+ expect(paths).toContain("src/components/Composer.tsx");
+ }),
+ );
+
+ it.effect("tracks truncation without sorting every fuzzy match", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-fuzzy-limit-" });
+ yield* writeTextFile(cwd, "src/components/Composer.tsx");
+ yield* writeTextFile(cwd, "src/components/composePrompt.ts");
+ yield* writeTextFile(cwd, "docs/composition.md");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "cmp", limit: 1 });
+
+ expect(result.entries).toHaveLength(1);
+ expect(result.truncated).toBe(true);
+ }),
+ );
+
+ it.effect("excludes gitignored paths for git repositories", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-gitignore-", git: true });
+ yield* writeTextFile(cwd, ".gitignore", ".convex/\nconvex/\nignored.txt\n");
+ yield* writeTextFile(cwd, "src/keep.ts", "export {};");
+ yield* writeTextFile(cwd, "ignored.txt", "ignore me");
+ yield* writeTextFile(cwd, ".convex/local-storage/data.json", "{}");
+ yield* writeTextFile(cwd, "convex/UOoS-l/convex_local_storage/modules/data.json", "{}");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+ const paths = result.entries.map((entry) => entry.path);
+
+ expect(paths).toContain("src");
+ expect(paths).toContain("src/keep.ts");
+ expect(paths).not.toContain("ignored.txt");
+ expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
+ expect(paths.some((entryPath) => entryPath.startsWith("convex/"))).toBe(false);
+ }),
+ );
+
+ it.effect("excludes tracked paths that match ignore rules", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({
+ prefix: "t3code-workspace-tracked-gitignore-",
+ git: true,
+ });
+ yield* writeTextFile(cwd, ".convex/local-storage/data.json", "{}");
+ yield* writeTextFile(cwd, "src/keep.ts", "export {};");
+ yield* git(cwd, ["add", ".convex/local-storage/data.json", "src/keep.ts"]);
+ yield* writeTextFile(cwd, ".gitignore", ".convex/\n");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+ const paths = result.entries.map((entry) => entry.path);
+
+ expect(paths).toContain("src");
+ expect(paths).toContain("src/keep.ts");
+ expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
+ }),
+ );
+
+ it.effect("excludes .convex in non-git workspaces", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-non-git-convex-" });
+ yield* writeTextFile(cwd, ".convex/local-storage/data.json", "{}");
+ yield* writeTextFile(cwd, "src/keep.ts", "export {};");
+
+ const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+ const paths = result.entries.map((entry) => entry.path);
+
+ expect(paths).toContain("src");
+ expect(paths).toContain("src/keep.ts");
+ expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
+ }),
+ );
+
+ it.effect("deduplicates concurrent index builds for the same cwd", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-concurrent-build-" });
+ yield* writeTextFile(cwd, "src/components/Composer.tsx");
+
+ let rootReadCount = 0;
+ const originalReaddir = fsPromises.readdir.bind(fsPromises);
+ vi.spyOn(fsPromises, "readdir").mockImplementation((async (
+ ...args: Parameters<typeof fsPromises.readdir>
+ ) => {
+ if (args[0] === cwd) {
+ rootReadCount += 1;
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ }
+ return originalReaddir(...args);
+ }) as typeof fsPromises.readdir);
+
+ yield* Effect.all(
+ [
+ searchWorkspaceEntries({ cwd, query: "", limit: 100 }),
+ searchWorkspaceEntries({ cwd, query: "comp", limit: 100 }),
+ searchWorkspaceEntries({ cwd, query: "src", limit: 100 }),
+ ],
+ { concurrency: "unbounded" },
+ );
+
+ expect(rootReadCount).toBe(1);
+ }),
+ );
+
+ it.effect("limits concurrent directory reads while walking the filesystem", () =>
+ Effect.gen(function* () {
+ const cwd = yield* makeTempDir({ prefix: "t3code-workspace-read-concurrency-" });
+ yield* Effect.forEach(
+ Array.from({ length: 80 }, (_, index) => index),
+ (index) => writeTextFile(cwd, `group-${index}/entry-${index}.ts`, "export {};"),
+ { discard: true },
+ );
+
+ let activeReads = 0;
+ let peakReads = 0;
+ const originalReaddir = fsPromises.readdir.bind(fsPromises);
+ vi.spyOn(fsPromises, "readdir").mockImplementation((async (
+ ...args: Parameters<typeof fsPromises.readdir>
+ ) => {
+ const target = args[0];
+ if (typeof target === "string" && target.startsWith(cwd)) {
+ activeReads += 1;
+ peakReads = Math.max(peakReads, activeReads);
+ await new Promise((resolve) => setTimeout(resolve, 4));
+ try {
+ return await originalReaddir(...args);
+ } finally {
+ activeReads -= 1;
+ }
+ }
+ return originalReaddir(...args);
+ }) as typeof fsPromises.readdir);
+
+ yield* searchWorkspaceEntries({ cwd, query: "", limit: 200 });
+
+ expect(peakReads).toBeLessThanOrEqual(32);
+ }),
+ );
+ });
+});
diff --git a/apps/server/src/workspace/Layers/WorkspaceEntries.ts b/apps/server/src/workspace/Layers/WorkspaceEntries.ts
new file mode 100644
index 000000000..c64960593
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspaceEntries.ts
@@ -0,0 +1,478 @@
+import fsPromises from "node:fs/promises";
+import type { Dirent } from "node:fs";
+
+import { Cache, Duration, Effect, Exit, Layer, Option, Path } from "effect";
+
+import { type ProjectEntry } from "@t3tools/contracts";
+
+import { GitCore } from "../../git/Services/GitCore.ts";
+import {
+ WorkspaceEntries,
+ WorkspaceEntriesError,
+ type WorkspaceEntriesShape,
+} from "../Services/WorkspaceEntries.ts";
+
+const WORKSPACE_CACHE_TTL_MS = 15_000;
+const WORKSPACE_CACHE_MAX_KEYS = 4;
+const WORKSPACE_INDEX_MAX_ENTRIES = 25_000;
+const WORKSPACE_SCAN_READDIR_CONCURRENCY = 32;
+const IGNORED_DIRECTORY_NAMES = new Set([
+ ".git",
+ ".convex",
+ "node_modules",
+ ".next",
+ ".turbo",
+ "dist",
+ "build",
+ "out",
+ ".cache",
+]);
+
+interface WorkspaceIndex {
+ scannedAt: number;
+ entries: SearchableWorkspaceEntry[];
+ truncated: boolean;
+}
+
+interface SearchableWorkspaceEntry extends ProjectEntry {
+ normalizedPath: string;
+ normalizedName: string;
+}
+
+interface RankedWorkspaceEntry {
+ entry: SearchableWorkspaceEntry;
+ score: number;
+}
+
+function toPosixPath(input: string): string {
+ return input.replaceAll("\\", "/");
+}
+
+function parentPathOf(input: string): string | undefined {
+ const separatorIndex = input.lastIndexOf("/");
+ if (separatorIndex === -1) {
+ return undefined;
+ }
+ return input.slice(0, separatorIndex);
+}
+
+function basenameOf(input: string): string {
+ const separatorIndex = input.lastIndexOf("/");
+ if (separatorIndex === -1) {
+ return input;
+ }
+ return input.slice(separatorIndex + 1);
+}
+
+function toSearchableWorkspaceEntry(entry: ProjectEntry): SearchableWorkspaceEntry {
+ const normalizedPath = entry.path.toLowerCase();
+ return {
+ ...entry,
+ normalizedPath,
+ normalizedName: basenameOf(normalizedPath),
+ };
+}
+
+function normalizeQuery(input: string): string {
+ return input
+ .trim()
+ .replace(/^[@./]+/, "")
+ .toLowerCase();
+}
+
+function scoreSubsequenceMatch(value: string, query: string): number | null {
+ if (!query) return 0;
+
+ let queryIndex = 0;
+ let firstMatchIndex = -1;
+ let previousMatchIndex = -1;
+ let gapPenalty = 0;
+
+ for (let valueIndex = 0; valueIndex < value.length; valueIndex += 1) {
+ if (value[valueIndex] !== query[queryIndex]) {
+ continue;
+ }
+
+ if (firstMatchIndex === -1) {
+ firstMatchIndex = valueIndex;
+ }
+ if (previousMatchIndex !== -1) {
+ gapPenalty += valueIndex - previousMatchIndex - 1;
+ }
+
+ previousMatchIndex = valueIndex;
+ queryIndex += 1;
+ if (queryIndex === query.length) {
+ const spanPenalty = valueIndex - firstMatchIndex + 1 - query.length;
+ const lengthPenalty = Math.min(64, value.length - query.length);
+ return firstMatchIndex * 2 + gapPenalty * 3 + spanPenalty + lengthPenalty;
+ }
+ }
+
+ return null;
+}
+
+function scoreEntry(entry: SearchableWorkspaceEntry, query: string): number | null {
+ if (!query) {
+ return entry.kind === "directory" ? 0 : 1;
+ }
+
+ const { normalizedPath, normalizedName } = entry;
+
+ if (normalizedName === query) return 0;
+ if (normalizedPath === query) return 1;
+ if (normalizedName.startsWith(query)) return 2;
+ if (normalizedPath.startsWith(query)) return 3;
+ if (normalizedPath.includes(`/${query}`)) return 4;
+ if (normalizedName.includes(query)) return 5;
+ if (normalizedPath.includes(query)) return 6;
+
+ const nameFuzzyScore = scoreSubsequenceMatch(normalizedName, query);
+ if (nameFuzzyScore !== null) {
+ return 100 + nameFuzzyScore;
+ }
+
+ const pathFuzzyScore = scoreSubsequenceMatch(normalizedPath, query);
+ if (pathFuzzyScore !== null) {
+ return 200 + pathFuzzyScore;
+ }
+
+ return null;
+}
+
+function compareRankedWorkspaceEntries(
+ left: RankedWorkspaceEntry,
+ right: RankedWorkspaceEntry,
+): number {
+ const scoreDelta = left.score - right.score;
+ if (scoreDelta !== 0) return scoreDelta;
+ return left.entry.path.localeCompare(right.entry.path);
+}
+
+function findInsertionIndex(
+ rankedEntries: RankedWorkspaceEntry[],
+ candidate: RankedWorkspaceEntry,
+): number {
+ let low = 0;
+ let high = rankedEntries.length;
+
+ while (low < high) {
+ const middle = low + Math.floor((high - low) / 2);
+ const current = rankedEntries[middle];
+ if (!current) {
+ break;
+ }
+
+ if (compareRankedWorkspaceEntries(candidate, current) < 0) {
+ high = middle;
+ } else {
+ low = middle + 1;
+ }
+ }
+
+ return low;
+}
+
+function insertRankedEntry(
+ rankedEntries: RankedWorkspaceEntry[],
+ candidate: RankedWorkspaceEntry,
+ limit: number,
+): void {
+ if (limit <= 0) {
+ return;
+ }
+
+ const insertionIndex = findInsertionIndex(rankedEntries, candidate);
+ if (rankedEntries.length < limit) {
+ rankedEntries.splice(insertionIndex, 0, candidate);
+ return;
+ }
+
+ if (insertionIndex >= limit) {
+ return;
+ }
+
+ rankedEntries.splice(insertionIndex, 0, candidate);
+ rankedEntries.pop();
+}
+
+function isPathInIgnoredDirectory(relativePath: string): boolean {
+ const firstSegment = relativePath.split("/")[0];
+ if (!firstSegment) return false;
+ return IGNORED_DIRECTORY_NAMES.has(firstSegment);
+}
+
+function directoryAncestorsOf(relativePath: string): string[] {
+ const segments = relativePath.split("/").filter((segment) => segment.length > 0);
+ if (segments.length <= 1) return [];
+
+ const directories: string[] = [];
+ for (let index = 1; index < segments.length; index += 1) {
+ directories.push(segments.slice(0, index).join("/"));
+ }
+ return directories;
+}
+
+const processErrorDetail = (cause: unknown): string =>
+ cause instanceof Error ? cause.message : String(cause);
+
+export const makeWorkspaceEntries = Effect.gen(function* () {
+ const path = yield* Path.Path;
+ const gitOption = yield* Effect.serviceOption(GitCore);
+
+ const isInsideGitWorkTree = (cwd: string): Effect.Effect<boolean> =>
+ Option.match(gitOption, {
+ onSome: (git) => git.isInsideWorkTree(cwd).pipe(Effect.catch(() => Effect.succeed(false))),
+ onNone: () => Effect.succeed(false),
+ });
+
+ const filterGitIgnoredPaths = (
+ cwd: string,
+ relativePaths: string[],
+ ): Effect.Effect<string[], never> =>
+ Option.match(gitOption, {
+ onSome: (git) =>
+ git.filterIgnoredPaths(cwd, relativePaths).pipe(
+ Effect.map((paths) => [...paths]),
+ Effect.catch(() => Effect.succeed(relativePaths)),
+ ),
+ onNone: () => Effect.succeed(relativePaths),
+ });
+
+ const buildWorkspaceIndexFromGit = Effect.fn("WorkspaceEntries.buildWorkspaceIndexFromGit")(
+ function* (cwd: string) {
+ if (Option.isNone(gitOption)) {
+ return null;
+ }
+ if (!(yield* isInsideGitWorkTree(cwd))) {
+ return null;
+ }
+
+ const listedFiles = yield* gitOption.value
+ .listWorkspaceFiles(cwd)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+
+ if (!listedFiles) {
+ return null;
+ }
+
+ const listedPaths = [...listedFiles.paths]
+ .map((entry) => toPosixPath(entry))
+ .filter((entry) => entry.length > 0 && !isPathInIgnoredDirectory(entry));
+ const filePaths = yield* filterGitIgnoredPaths(cwd, listedPaths);
+
+ const directorySet = new Set<string>();
+ for (const filePath of filePaths) {
+ for (const directoryPath of directoryAncestorsOf(filePath)) {
+ if (!isPathInIgnoredDirectory(directoryPath)) {
+ directorySet.add(directoryPath);
+ }
+ }
+ }
+
+ const directoryEntries = [...directorySet]
+ .toSorted((left, right) => left.localeCompare(right))
+ .map(
+ (directoryPath): ProjectEntry => ({
+ path: directoryPath,
+ kind: "directory",
+ parentPath: parentPathOf(directoryPath),
+ }),
+ )
+ .map(toSearchableWorkspaceEntry);
+ const fileEntries = [...new Set(filePaths)]
+ .toSorted((left, right) => left.localeCompare(right))
+ .map(
+ (filePath): ProjectEntry => ({
+ path: filePath,
+ kind: "file",
+ parentPath: parentPathOf(filePath),
+ }),
+ )
+ .map(toSearchableWorkspaceEntry);
+
+ const entries = [...directoryEntries, ...fileEntries];
+ return {
+ scannedAt: Date.now(),
+ entries: entries.slice(0, WORKSPACE_INDEX_MAX_ENTRIES),
+ truncated: listedFiles.truncated || entries.length > WORKSPACE_INDEX_MAX_ENTRIES,
+ };
+ },
+ );
+
+ const readDirectoryEntries = Effect.fn("WorkspaceEntries.readDirectoryEntries")(function* (
+ cwd: string,
+ relativeDir: string,
+ ): Effect.fn.Return<
+ { readonly relativeDir: string; readonly dirents: Dirent[] | null },
+ WorkspaceEntriesError
+ > {
+ return yield* Effect.tryPromise({
+ try: async () => {
+ const absoluteDir = relativeDir ? path.join(cwd, relativeDir) : cwd;
+ const dirents = await fsPromises.readdir(absoluteDir, { withFileTypes: true });
+ return { relativeDir, dirents };
+ },
+ catch: (cause) =>
+ new WorkspaceEntriesError({
+ cwd,
+ operation: "workspaceEntries.readDirectoryEntries",
+ detail: processErrorDetail(cause),
+ cause,
+ }),
+ }).pipe(
+ Effect.catchIf(
+ () => relativeDir.length > 0,
+ () => Effect.succeed({ relativeDir, dirents: null }),
+ ),
+ );
+ });
+
+ const buildWorkspaceIndexFromFilesystem = Effect.fn(
+ "WorkspaceEntries.buildWorkspaceIndexFromFilesystem",
+ )(function* (cwd: string): Effect.fn.Return<WorkspaceIndex, WorkspaceEntriesError> {
+ const shouldFilterWithGitIgnore = yield* isInsideGitWorkTree(cwd);
+
+ let pendingDirectories: string[] = [""];
+ const entries: SearchableWorkspaceEntry[] = [];
+ let truncated = false;
+
+ while (pendingDirectories.length > 0 && !truncated) {
+ const currentDirectories = pendingDirectories;
+ pendingDirectories = [];
+
+ const directoryEntries = yield* Effect.forEach(
+ currentDirectories,
+ (relativeDir) => readDirectoryEntries(cwd, relativeDir),
+ { concurrency: WORKSPACE_SCAN_READDIR_CONCURRENCY },
+ );
+
+ const candidateEntriesByDirectory = directoryEntries.map((directoryEntry) => {
+ const { relativeDir, dirents } = directoryEntry;
+ if (!dirents) return [] as Array<{ dirent: Dirent; relativePath: string }>;
+
+ dirents.sort((left, right) => left.name.localeCompare(right.name));
+ const candidates: Array<{ dirent: Dirent; relativePath: string }> = [];
+ for (const dirent of dirents) {
+ if (!dirent.name || dirent.name === "." || dirent.name === "..") {
+ continue;
+ }
+ if (dirent.isDirectory() && IGNORED_DIRECTORY_NAMES.has(dirent.name)) {
+ continue;
+ }
+ if (!dirent.isDirectory() && !dirent.isFile()) {
+ continue;
+ }
+
+ const relativePath = toPosixPath(
+ relativeDir ? path.join(relativeDir, dirent.name) : dirent.name,
+ );
+ if (isPathInIgnoredDirectory(relativePath)) {
+ continue;
+ }
+ candidates.push({ dirent, relativePath });
+ }
+ return candidates;
+ });
+
+ const candidatePaths = candidateEntriesByDirectory.flatMap((candidateEntries) =>
+ candidateEntries.map((entry) => entry.relativePath),
+ );
+ const allowedPathSet = shouldFilterWithGitIgnore
+ ? new Set(yield* filterGitIgnoredPaths(cwd, candidatePaths))
+ : null;
+
+ for (const candidateEntries of candidateEntriesByDirectory) {
+ for (const candidate of candidateEntries) {
+ if (allowedPathSet && !allowedPathSet.has(candidate.relativePath)) {
+ continue;
+ }
+
+ const entry = toSearchableWorkspaceEntry({
+ path: candidate.relativePath,
+ kind: candidate.dirent.isDirectory() ? "directory" : "file",
+ parentPath: parentPathOf(candidate.relativePath),
+ });
+ entries.push(entry);
+
+ if (candidate.dirent.isDirectory()) {
+ pendingDirectories.push(candidate.relativePath);
+ }
+
+ if (entries.length >= WORKSPACE_INDEX_MAX_ENTRIES) {
+ truncated = true;
+ break;
+ }
+ }
+
+ if (truncated) {
+ break;
+ }
+ }
+ }
+
+ return {
+ scannedAt: Date.now(),
+ entries,
+ truncated,
+ };
+ });
+
+ const buildWorkspaceIndex = Effect.fn("WorkspaceEntries.buildWorkspaceIndex")(function* (
+ cwd: string,
+ ): Effect.fn.Return<WorkspaceIndex, WorkspaceEntriesError> {
+ const gitIndexed = yield* buildWorkspaceIndexFromGit(cwd);
+ if (gitIndexed) {
+ return gitIndexed;
+ }
+ return yield* buildWorkspaceIndexFromFilesystem(cwd);
+ });
+
+ const workspaceIndexCache = yield* Cache.makeWith<string, WorkspaceIndex, WorkspaceEntriesError>({
+ capacity: WORKSPACE_CACHE_MAX_KEYS,
+ lookup: buildWorkspaceIndex,
+ timeToLive: (exit) =>
+ Exit.isSuccess(exit) ? Duration.millis(WORKSPACE_CACHE_TTL_MS) : Duration.zero,
+ });
+
+ const invalidate: WorkspaceEntriesShape["invalidate"] = Effect.fn("WorkspaceEntries.invalidate")(
+ function* (cwd) {
+ return yield* Cache.invalidate(workspaceIndexCache, cwd);
+ },
+ );
+
+ const search: WorkspaceEntriesShape["search"] = Effect.fn("WorkspaceEntries.search")(
+ function* (input) {
+ return yield* Cache.get(workspaceIndexCache, input.cwd).pipe(
+ Effect.map((index) => {
+ const normalizedQuery = normalizeQuery(input.query);
+ const limit = Math.max(0, Math.floor(input.limit));
+ const rankedEntries: RankedWorkspaceEntry[] = [];
+ let matchedEntryCount = 0;
+
+ for (const entry of index.entries) {
+ const score = scoreEntry(entry, normalizedQuery);
+ if (score === null) {
+ continue;
+ }
+
+ matchedEntryCount += 1;
+ insertRankedEntry(rankedEntries, { entry, score }, limit);
+ }
+
+ return {
+ entries: rankedEntries.map((candidate) => candidate.entry),
+ truncated: index.truncated || matchedEntryCount > limit,
+ };
+ }),
+ );
+ },
+ );
+
+ return {
+ invalidate,
+ search,
+ } satisfies WorkspaceEntriesShape;
+});
+
+export const WorkspaceEntriesLive = Layer.effect(WorkspaceEntries, makeWorkspaceEntries);
diff --git a/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts b/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts
new file mode 100644
index 000000000..9ea8835ba
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspaceFileSystem.test.ts
@@ -0,0 +1,135 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it, describe, expect } from "@effect/vitest";
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import { ServerConfig } from "../../config.ts";
+import { GitCoreLive } from "../../git/Layers/GitCore.ts";
+import { WorkspaceEntries } from "../Services/WorkspaceEntries.ts";
+import { WorkspaceFileSystem } from "../Services/WorkspaceFileSystem.ts";
+import { WorkspaceEntriesLive } from "./WorkspaceEntries.ts";
+import { WorkspaceFileSystemLive } from "./WorkspaceFileSystem.ts";
+import { WorkspacePathsLive } from "./WorkspacePaths.ts";
+
+const ProjectLayer = WorkspaceFileSystemLive.pipe(
+ Layer.provide(WorkspacePathsLive),
+ Layer.provide(WorkspaceEntriesLive),
+);
+
+const TestLayer = Layer.empty.pipe(
+ Layer.provideMerge(ProjectLayer),
+ Layer.provideMerge(WorkspaceEntriesLive),
+ Layer.provideMerge(GitCoreLive),
+ Layer.provide(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3-workspace-files-test-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+const makeTempDir = Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ return yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3code-workspace-files-",
+ });
+});
+
+const writeTextFile = Effect.fn("writeTextFile")(function* (
+ cwd: string,
+ relativePath: string,
+ contents = "",
+) {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const absolutePath = path.join(cwd, relativePath);
+ yield* fileSystem
+ .makeDirectory(path.dirname(absolutePath), { recursive: true })
+ .pipe(Effect.orDie);
+ yield* fileSystem.writeFileString(absolutePath, contents).pipe(Effect.orDie);
+});
+
+it.layer(TestLayer)("WorkspaceFileSystemLive", (it) => {
+ describe("writeFile", () => {
+ it.effect("writes files relative to the workspace root", () =>
+ Effect.gen(function* () {
+ const workspaceFileSystem = yield* WorkspaceFileSystem;
+ const cwd = yield* makeTempDir;
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const result = yield* workspaceFileSystem.writeFile({
+ cwd,
+ relativePath: "plans/effect-rpc.md",
+ contents: "# Plan\n",
+ });
+ const saved = yield* fileSystem
+ .readFileString(path.join(cwd, "plans/effect-rpc.md"))
+ .pipe(Effect.orDie);
+
+ expect(result).toEqual({ relativePath: "plans/effect-rpc.md" });
+ expect(saved).toBe("# Plan\n");
+ }),
+ );
+
+ it.effect("invalidates workspace entry search cache after writes", () =>
+ Effect.gen(function* () {
+ const workspaceEntries = yield* WorkspaceEntries;
+ const workspaceFileSystem = yield* WorkspaceFileSystem;
+ const cwd = yield* makeTempDir;
+ yield* writeTextFile(cwd, "src/existing.ts", "export {};\n");
+
+ const beforeWrite = yield* workspaceEntries.search({
+ cwd,
+ query: "rpc",
+ limit: 10,
+ });
+ expect(beforeWrite).toEqual({
+ entries: [],
+ truncated: false,
+ });
+
+ yield* workspaceFileSystem.writeFile({
+ cwd,
+ relativePath: "plans/effect-rpc.md",
+ contents: "# Plan\n",
+ });
+
+ const afterWrite = yield* workspaceEntries.search({
+ cwd,
+ query: "rpc",
+ limit: 10,
+ });
+ expect(afterWrite.entries).toEqual(
+ expect.arrayContaining([expect.objectContaining({ path: "plans/effect-rpc.md" })]),
+ );
+ expect(afterWrite.truncated).toBe(false);
+ }),
+ );
+
+ it.effect("rejects writes outside the workspace root", () =>
+ Effect.gen(function* () {
+ const workspaceFileSystem = yield* WorkspaceFileSystem;
+ const cwd = yield* makeTempDir;
+ const path = yield* Path.Path;
+ const fileSystem = yield* FileSystem.FileSystem;
+
+ const error = yield* workspaceFileSystem
+ .writeFile({
+ cwd,
+ relativePath: "../escape.md",
+ contents: "# nope\n",
+ })
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain(
+ "Workspace file path must be relative to the project root: ../escape.md",
+ );
+
+ const escapedPath = path.resolve(cwd, "..", "escape.md");
+ const escapedStat = yield* fileSystem
+ .stat(escapedPath)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ expect(escapedStat).toBeNull();
+ }),
+ );
+ });
+});
diff --git a/apps/server/src/workspace/Layers/WorkspaceFileSystem.ts b/apps/server/src/workspace/Layers/WorkspaceFileSystem.ts
new file mode 100644
index 000000000..84e5d9c6d
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspaceFileSystem.ts
@@ -0,0 +1,55 @@
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import {
+ WorkspaceFileSystem,
+ WorkspaceFileSystemError,
+ type WorkspaceFileSystemShape,
+} from "../Services/WorkspaceFileSystem.ts";
+import { WorkspaceEntries } from "../Services/WorkspaceEntries.ts";
+import { WorkspacePaths } from "../Services/WorkspacePaths.ts";
+
+export const makeWorkspaceFileSystem = Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const workspacePaths = yield* WorkspacePaths;
+ const workspaceEntries = yield* WorkspaceEntries;
+
+ const writeFile: WorkspaceFileSystemShape["writeFile"] = Effect.fn(
+ "WorkspaceFileSystem.writeFile",
+ )(function* (input) {
+ const target = yield* workspacePaths.resolveRelativePathWithinRoot({
+ workspaceRoot: input.cwd,
+ relativePath: input.relativePath,
+ });
+
+ yield* fileSystem.makeDirectory(path.dirname(target.absolutePath), { recursive: true }).pipe(
+ Effect.mapError(
+ (cause) =>
+ new WorkspaceFileSystemError({
+ cwd: input.cwd,
+ relativePath: input.relativePath,
+ operation: "workspaceFileSystem.makeDirectory",
+ detail: cause.message,
+ cause,
+ }),
+ ),
+ );
+ yield* fileSystem.writeFileString(target.absolutePath, input.contents).pipe(
+ Effect.mapError(
+ (cause) =>
+ new WorkspaceFileSystemError({
+ cwd: input.cwd,
+ relativePath: input.relativePath,
+ operation: "workspaceFileSystem.writeFile",
+ detail: cause.message,
+ cause,
+ }),
+ ),
+ );
+ yield* workspaceEntries.invalidate(input.cwd);
+ return { relativePath: target.relativePath };
+ });
+ return { writeFile } satisfies WorkspaceFileSystemShape;
+});
+
+export const WorkspaceFileSystemLive = Layer.effect(WorkspaceFileSystem, makeWorkspaceFileSystem);
diff --git a/apps/server/src/workspace/Layers/WorkspacePaths.test.ts b/apps/server/src/workspace/Layers/WorkspacePaths.test.ts
new file mode 100644
index 000000000..d02a5929d
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspacePaths.test.ts
@@ -0,0 +1,113 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it, describe, expect } from "@effect/vitest";
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import { WorkspacePaths } from "../Services/WorkspacePaths.ts";
+import { WorkspacePathsLive } from "./WorkspacePaths.ts";
+
+const TestLayer = Layer.empty.pipe(
+ Layer.provideMerge(WorkspacePathsLive),
+ Layer.provideMerge(NodeServices.layer),
+);
+
+const makeTempDir = Effect.fn("makeTempDir")(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ return yield* fileSystem.makeTempDirectoryScoped({
+ prefix: "t3code-project-paths-",
+ });
+});
+
+const writeTextFile = Effect.fn("writeTextFile")(function* (
+ cwd: string,
+ relativePath: string,
+ contents = "",
+) {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const absolutePath = path.join(cwd, relativePath);
+ yield* fileSystem
+ .makeDirectory(path.dirname(absolutePath), { recursive: true })
+ .pipe(Effect.orDie);
+ yield* fileSystem.writeFileString(absolutePath, contents).pipe(Effect.orDie);
+});
+
+it.layer(TestLayer)("WorkspacePathsLive", (it) => {
+ describe("normalizeWorkspaceRoot", () => {
+ it.effect("resolves an existing directory", () =>
+ Effect.gen(function* () {
+ const workspacePaths = yield* WorkspacePaths;
+ const cwd = yield* makeTempDir();
+
+ const resolved = yield* workspacePaths.normalizeWorkspaceRoot(cwd);
+
+ expect(resolved).toBe(cwd);
+ }),
+ );
+
+ it.effect("rejects missing directories", () =>
+ Effect.gen(function* () {
+ const workspacePaths = yield* WorkspacePaths;
+ const cwd = yield* makeTempDir();
+ const path = yield* Path.Path;
+
+ const error = yield* workspacePaths
+ .normalizeWorkspaceRoot(path.join(cwd, "missing"))
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain("Workspace root does not exist:");
+ }),
+ );
+
+ it.effect("rejects file paths", () =>
+ Effect.gen(function* () {
+ const workspacePaths = yield* WorkspacePaths;
+ const cwd = yield* makeTempDir();
+ const path = yield* Path.Path;
+ const filePath = path.join(cwd, "README.md");
+ yield* writeTextFile(cwd, "README.md", "# hi\n");
+
+ const error = yield* workspacePaths.normalizeWorkspaceRoot(filePath).pipe(Effect.flip);
+
+ expect(error.message).toContain("Workspace root is not a directory:");
+ }),
+ );
+ });
+
+ describe("resolveRelativePathWithinRoot", () => {
+ it.effect("resolves relative paths inside the workspace root", () =>
+ Effect.gen(function* () {
+ const workspacePaths = yield* WorkspacePaths;
+ const cwd = yield* makeTempDir();
+ const path = yield* Path.Path;
+
+ const resolved = yield* workspacePaths.resolveRelativePathWithinRoot({
+ workspaceRoot: cwd,
+ relativePath: "plans/effect-rpc.md",
+ });
+
+ expect(resolved).toEqual({
+ absolutePath: path.join(cwd, "plans/effect-rpc.md"),
+ relativePath: "plans/effect-rpc.md",
+ });
+ }),
+ );
+
+ it.effect("rejects paths that escape the workspace root", () =>
+ Effect.gen(function* () {
+ const workspacePaths = yield* WorkspacePaths;
+ const cwd = yield* makeTempDir();
+
+ const error = yield* workspacePaths
+ .resolveRelativePathWithinRoot({
+ workspaceRoot: cwd,
+ relativePath: "../escape.md",
+ })
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain(
+ "Workspace file path must be relative to the project root: ../escape.md",
+ );
+ }),
+ );
+ });
+});
diff --git a/apps/server/src/workspace/Layers/WorkspacePaths.ts b/apps/server/src/workspace/Layers/WorkspacePaths.ts
new file mode 100644
index 000000000..fa7a90cf0
--- /dev/null
+++ b/apps/server/src/workspace/Layers/WorkspacePaths.ts
@@ -0,0 +1,89 @@
+import * as OS from "node:os";
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+import {
+ WorkspacePaths,
+ WorkspacePathOutsideRootError,
+ WorkspaceRootNotDirectoryError,
+ WorkspaceRootNotExistsError,
+ type WorkspacePathsShape,
+} from "../Services/WorkspacePaths.ts";
+
+function toPosixRelativePath(input: string): string {
+ return input.replaceAll("\\", "/");
+}
+
+function expandHomePath(input: string, path: Path.Path): string {
+ if (input === "~") {
+ return OS.homedir();
+ }
+ if (input.startsWith("~/") || input.startsWith("~\\")) {
+ return path.join(OS.homedir(), input.slice(2));
+ }
+ return input;
+}
+
+export const makeWorkspacePaths = Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+
+ const normalizeWorkspaceRoot: WorkspacePathsShape["normalizeWorkspaceRoot"] = Effect.fn(
+ "WorkspacePaths.normalizeWorkspaceRoot",
+ )(function* (workspaceRoot) {
+ const normalizedWorkspaceRoot = path.resolve(expandHomePath(workspaceRoot.trim(), path));
+ const workspaceStat = yield* fileSystem
+ .stat(normalizedWorkspaceRoot)
+ .pipe(Effect.catch(() => Effect.succeed(null)));
+ if (!workspaceStat) {
+ return yield* new WorkspaceRootNotExistsError({
+ workspaceRoot,
+ normalizedWorkspaceRoot,
+ });
+ }
+ if (workspaceStat.type !== "Directory") {
+ return yield* new WorkspaceRootNotDirectoryError({
+ workspaceRoot,
+ normalizedWorkspaceRoot,
+ });
+ }
+ return normalizedWorkspaceRoot;
+ });
+
+ const resolveRelativePathWithinRoot: WorkspacePathsShape["resolveRelativePathWithinRoot"] =
+ Effect.fn("WorkspacePaths.resolveRelativePathWithinRoot")(function* (input) {
+ const normalizedInputPath = input.relativePath.trim();
+ if (path.isAbsolute(normalizedInputPath)) {
+ return yield* new WorkspacePathOutsideRootError({
+ workspaceRoot: input.workspaceRoot,
+ relativePath: input.relativePath,
+ });
+ }
+
+ const absolutePath = path.resolve(input.workspaceRoot, normalizedInputPath);
+ const relativeToRoot = toPosixRelativePath(path.relative(input.workspaceRoot, absolutePath));
+ if (
+ relativeToRoot.length === 0 ||
+ relativeToRoot === "." ||
+ relativeToRoot.startsWith("../") ||
+ relativeToRoot === ".." ||
+ path.isAbsolute(relativeToRoot)
+ ) {
+ return yield* new WorkspacePathOutsideRootError({
+ workspaceRoot: input.workspaceRoot,
+ relativePath: input.relativePath,
+ });
+ }
+
+ return {
+ absolutePath,
+ relativePath: relativeToRoot,
+ };
+ });
+
+ return {
+ normalizeWorkspaceRoot,
+ resolveRelativePathWithinRoot,
+ } satisfies WorkspacePathsShape;
+});
+
+export const WorkspacePathsLive = Layer.effect(WorkspacePaths, makeWorkspacePaths);
diff --git a/apps/server/src/workspace/Services/WorkspaceEntries.ts b/apps/server/src/workspace/Services/WorkspaceEntries.ts
new file mode 100644
index 000000000..2841b1fe2
--- /dev/null
+++ b/apps/server/src/workspace/Services/WorkspaceEntries.ts
@@ -0,0 +1,48 @@
+/**
+ * WorkspaceEntries - Effect service contract for cached workspace entry search.
+ *
+ * Owns indexed workspace entry search plus cache invalidation for workspace
+ * roots when the underlying filesystem changes.
+ *
+ * @module WorkspaceEntries
+ */
+import { Schema, ServiceMap } from "effect";
+import type { Effect } from "effect";
+
+import type { ProjectSearchEntriesInput, ProjectSearchEntriesResult } from "@t3tools/contracts";
+
+export class WorkspaceEntriesError extends Schema.TaggedErrorClass<WorkspaceEntriesError>()(
+ "WorkspaceEntriesError",
+ {
+ cwd: Schema.String,
+ operation: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+/**
+ * WorkspaceEntriesShape - Service API for workspace entry search and cache
+ * invalidation.
+ */
+export interface WorkspaceEntriesShape {
+ /**
+ * Search indexed workspace entries for files and directories matching the
+ * provided query.
+ */
+ readonly search: (
+ input: ProjectSearchEntriesInput,
+ ) => Effect.Effect<ProjectSearchEntriesResult, WorkspaceEntriesError>;
+
+ /**
+ * Drop any cached workspace entries for the given workspace root.
+ */
+ readonly invalidate: (cwd: string) => Effect.Effect<void>;
+}
+
+/**
+ * WorkspaceEntries - Service tag for cached workspace entry search.
+ */
+export class WorkspaceEntries extends ServiceMap.Service<WorkspaceEntries, WorkspaceEntriesShape>()(
+ "t3/workspace/Services/WorkspaceEntries",
+) {}
diff --git a/apps/server/src/workspace/Services/WorkspaceFileSystem.ts b/apps/server/src/workspace/Services/WorkspaceFileSystem.ts
new file mode 100644
index 000000000..85db1514a
--- /dev/null
+++ b/apps/server/src/workspace/Services/WorkspaceFileSystem.ts
@@ -0,0 +1,50 @@
+/**
+ * WorkspaceFileSystem - Effect service contract for workspace file mutations.
+ *
+ * Owns workspace-root-relative file write operations and their associated
+ * safety checks and cache invalidation hooks.
+ *
+ * @module WorkspaceFileSystem
+ */
+import { Schema, ServiceMap } from "effect";
+import type { Effect } from "effect";
+
+import type { ProjectWriteFileInput, ProjectWriteFileResult } from "@t3tools/contracts";
+import { WorkspacePathOutsideRootError } from "./WorkspacePaths.ts";
+
+export class WorkspaceFileSystemError extends Schema.TaggedErrorClass<WorkspaceFileSystemError>()(
+ "WorkspaceFileSystemError",
+ {
+ cwd: Schema.String,
+ relativePath: Schema.optional(Schema.String),
+ operation: Schema.String,
+ detail: Schema.String,
+ cause: Schema.optional(Schema.Defect),
+ },
+) {}
+
+/**
+ * WorkspaceFileSystemShape - Service API for workspace-relative file operations.
+ */
+export interface WorkspaceFileSystemShape {
+ /**
+ * Write a file relative to the workspace root.
+ *
+ * Creates parent directories as needed and rejects paths that escape the
+ * workspace root.
+ */
+ readonly writeFile: (
+ input: ProjectWriteFileInput,
+ ) => Effect.Effect<
+ ProjectWriteFileResult,
+ WorkspaceFileSystemError | WorkspacePathOutsideRootError
+ >;
+}
+
+/**
+ * WorkspaceFileSystem - Service tag for workspace file operations.
+ */
+export class WorkspaceFileSystem extends ServiceMap.Service<
+ WorkspaceFileSystem,
+ WorkspaceFileSystemShape
+>()("t3/workspace/Services/WorkspaceFileSystem") {}
diff --git a/apps/server/src/workspace/Services/WorkspacePaths.ts b/apps/server/src/workspace/Services/WorkspacePaths.ts
new file mode 100644
index 000000000..ad6d9cd3e
--- /dev/null
+++ b/apps/server/src/workspace/Services/WorkspacePaths.ts
@@ -0,0 +1,85 @@
+/**
+ * WorkspacePaths - Effect service contract for workspace path handling.
+ *
+ * Owns normalization and validation of workspace roots plus safe resolution of
+ * workspace-root-relative paths.
+ *
+ * @module WorkspacePaths
+ */
+import { Schema, ServiceMap } from "effect";
+import type { Effect } from "effect";
+
+export class WorkspaceRootNotExistsError extends Schema.TaggedErrorClass<WorkspaceRootNotExistsError>()(
+ "WorkspaceRootNotExistsError",
+ {
+ workspaceRoot: Schema.String,
+ normalizedWorkspaceRoot: Schema.String,
+ },
+) {
+ override get message(): string {
+ return `Workspace root does not exist: ${this.normalizedWorkspaceRoot}`;
+ }
+}
+
+export class WorkspaceRootNotDirectoryError extends Schema.TaggedErrorClass<WorkspaceRootNotDirectoryError>()(
+ "WorkspaceRootNotDirectoryError",
+ {
+ workspaceRoot: Schema.String,
+ normalizedWorkspaceRoot: Schema.String,
+ },
+) {
+ override get message(): string {
+ return `Workspace root is not a directory: ${this.normalizedWorkspaceRoot}`;
+ }
+}
+
+export class WorkspacePathOutsideRootError extends Schema.TaggedErrorClass<WorkspacePathOutsideRootError>()(
+ "WorkspacePathOutsideRootError",
+ {
+ workspaceRoot: Schema.String,
+ relativePath: Schema.String,
+ },
+) {
+ override get message(): string {
+ return `Workspace file path must be relative to the project root: ${this.relativePath}`;
+ }
+}
+
+export const WorkspacePathsError = Schema.Union([
+ WorkspaceRootNotExistsError,
+ WorkspaceRootNotDirectoryError,
+ WorkspacePathOutsideRootError,
+]);
+export type WorkspacePathsError = typeof WorkspacePathsError.Type;
+
+/**
+ * WorkspacePathsShape - Service API for workspace path normalization and guards.
+ */
+export interface WorkspacePathsShape {
+ /**
+ * Normalize a user-provided workspace root and verify it exists as a directory.
+ */
+ readonly normalizeWorkspaceRoot: (
+ workspaceRoot: string,
+ ) => Effect.Effect<string, WorkspaceRootNotExistsError | WorkspaceRootNotDirectoryError>;
+
+ /**
+ * Resolve a relative path within a validated workspace root.
+ *
+ * Rejects absolute paths and traversal attempts outside the workspace root.
+ */
+ readonly resolveRelativePathWithinRoot: (input: {
+ workspaceRoot: string;
+ relativePath: string;
+ }) => Effect.Effect<
+ { absolutePath: string; relativePath: string },
+ WorkspacePathOutsideRootError
+ >;
+}
+
+/**
+ * WorkspacePaths - Service tag for workspace path normalization and resolution.
+ */
+export class WorkspacePaths extends ServiceMap.Service<WorkspacePaths, WorkspacePathsShape>()(
+ "t3/workspace/Services/WorkspacePaths",
+) {}
diff --git a/apps/server/src/workspaceEntries.chunking.test.ts b/apps/server/src/workspaceEntries.chunking.test.ts
deleted file mode 100644
index f978c5233..000000000
--- a/apps/server/src/workspaceEntries.chunking.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { assert, beforeEach, describe, it, vi } from "vitest";
-import type { ProcessRunOptions, ProcessRunResult } from "./processRunner";
-
-const { runProcessMock } = vi.hoisted(() => ({
- runProcessMock:
- vi.fn<
- (
- command: string,
- args: readonly string[],
- options?: ProcessRunOptions,
- ) => Promise<ProcessRunResult>
- >(),
-}));
-
-vi.mock("./processRunner", () => ({
- runProcess: runProcessMock,
-}));
-
-function processResult(
- overrides: Partial<ProcessRunResult> & Pick<ProcessRunResult, "stdout" | "code">,
-): ProcessRunResult {
- return {
- stdout: overrides.stdout,
- code: overrides.code,
- stderr: overrides.stderr ?? "",
- signal: overrides.signal ?? null,
- timedOut: overrides.timedOut ?? false,
- stdoutTruncated: overrides.stdoutTruncated ?? false,
- stderrTruncated: overrides.stderrTruncated ?? false,
- };
-}
-
-describe("searchWorkspaceEntries git-ignore chunking", () => {
- beforeEach(() => {
- runProcessMock.mockReset();
- vi.resetModules();
- });
-
- it("chunks git check-ignore stdin to avoid building giant strings", async () => {
- const ignoredPaths = Array.from(
- { length: 5000 },
- (_, index) => `ignored/${index.toString().padStart(5, "0")}/${"x".repeat(80)}.ts`,
- );
- const keptPaths = ["src/keep.ts", "docs/readme.md"];
- const listedPaths = [...ignoredPaths, ...keptPaths];
- let checkIgnoreCalls = 0;
-
- runProcessMock.mockImplementation(async (_command, args, options) => {
- if (args[0] === "rev-parse") {
- return processResult({ code: 0, stdout: "true\n" });
- }
-
- if (args[0] === "ls-files") {
- return processResult({ code: 0, stdout: `${listedPaths.join("\0")}\0` });
- }
-
- if (args[0] === "check-ignore") {
- checkIgnoreCalls += 1;
- const chunkPaths = (options?.stdin ?? "").split("\0").filter((value) => value.length > 0);
- const chunkIgnored = chunkPaths.filter((value) => value.startsWith("ignored/"));
- return processResult({
- code: chunkIgnored.length > 0 ? 0 : 1,
- stdout: chunkIgnored.length > 0 ? `${chunkIgnored.join("\0")}\0` : "",
- });
- }
-
- throw new Error(`Unexpected command: git ${args.join(" ")}`);
- });
-
- const { searchWorkspaceEntries } = await import("./workspaceEntries");
- const result = await searchWorkspaceEntries({
- cwd: "/virtual/workspace",
- query: "",
- limit: 100,
- });
-
- assert.isAbove(checkIgnoreCalls, 1);
- assert.isFalse(result.entries.some((entry) => entry.path.startsWith("ignored/")));
- assert.isTrue(result.entries.some((entry) => entry.path === "src/keep.ts"));
- });
-});
diff --git a/apps/server/src/workspaceEntries.test.ts b/apps/server/src/workspaceEntries.test.ts
deleted file mode 100644
index d867ad910..000000000
--- a/apps/server/src/workspaceEntries.test.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-import { afterEach, assert, describe, it, vi } from "vitest";
-
-import { searchWorkspaceEntries } from "./workspaceEntries";
-
-const tempDirs: string[] = [];
-
-function makeTempDir(prefix: string): string {
- const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
- tempDirs.push(dir);
- return dir;
-}
-
-function writeFile(cwd: string, relativePath: string, contents = ""): void {
- const absolutePath = path.join(cwd, relativePath);
- fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
- fs.writeFileSync(absolutePath, contents, "utf8");
-}
-
-function runGit(cwd: string, args: string[]): void {
- const result = spawnSync("git", args, { cwd, encoding: "utf8" });
- if (result.status !== 0) {
- throw new Error(result.stderr || `git ${args.join(" ")} failed`);
- }
-}
-
-describe("searchWorkspaceEntries", () => {
- afterEach(() => {
- vi.restoreAllMocks();
- for (const dir of tempDirs.splice(0, tempDirs.length)) {
- fs.rmSync(dir, { recursive: true, force: true });
- }
- });
-
- it("returns files and directories relative to cwd", async () => {
- const cwd = makeTempDir("t3code-workspace-entries-");
- writeFile(cwd, "src/components/Composer.tsx");
- writeFile(cwd, "src/index.ts");
- writeFile(cwd, "README.md");
- writeFile(cwd, ".git/HEAD");
- writeFile(cwd, "node_modules/pkg/index.js");
-
- const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
- const paths = result.entries.map((entry) => entry.path);
-
- assert.include(paths, "src");
- assert.include(paths, "src/components");
- assert.include(paths, "src/components/Composer.tsx");
- assert.include(paths, "README.md");
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".git")));
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith("node_modules")));
- assert.isFalse(result.truncated);
- });
-
- it("filters and ranks entries by query", async () => {
- const cwd = makeTempDir("t3code-workspace-query-");
- writeFile(cwd, "src/components/Composer.tsx");
- writeFile(cwd, "src/components/composePrompt.ts");
- writeFile(cwd, "docs/composition.md");
-
- const result = await searchWorkspaceEntries({ cwd, query: "compo", limit: 5 });
-
- assert.isAbove(result.entries.length, 0);
- assert.isTrue(result.entries.some((entry) => entry.path === "src/components"));
- assert.isTrue(result.entries.every((entry) => entry.path.toLowerCase().includes("compo")));
- });
-
- it("supports fuzzy subsequence queries for composer path search", async () => {
- const cwd = makeTempDir("t3code-workspace-fuzzy-query-");
- writeFile(cwd, "src/components/Composer.tsx");
- writeFile(cwd, "src/components/composePrompt.ts");
- writeFile(cwd, "docs/composition.md");
-
- const result = await searchWorkspaceEntries({ cwd, query: "cmp", limit: 10 });
- const paths = result.entries.map((entry) => entry.path);
-
- assert.isAbove(result.entries.length, 0);
- assert.include(paths, "src/components");
- assert.include(paths, "src/components/Composer.tsx");
- });
-
- it("tracks truncation without sorting every fuzzy match", async () => {
- const cwd = makeTempDir("t3code-workspace-fuzzy-limit-");
- writeFile(cwd, "src/components/Composer.tsx");
- writeFile(cwd, "src/components/composePrompt.ts");
- writeFile(cwd, "docs/composition.md");
-
- const result = await searchWorkspaceEntries({ cwd, query: "cmp", limit: 1 });
-
- assert.lengthOf(result.entries, 1);
- assert.isTrue(result.truncated);
- });
-
- it("excludes gitignored paths for git repositories", async () => {
- const cwd = makeTempDir("t3code-workspace-gitignore-");
- runGit(cwd, ["init"]);
- writeFile(cwd, ".gitignore", ".convex/\nconvex/\nignored.txt\n");
- writeFile(cwd, "src/keep.ts", "export {};");
- writeFile(cwd, "ignored.txt", "ignore me");
- writeFile(cwd, ".convex/local-storage/data.json", "{}");
- writeFile(cwd, "convex/UOoS-l/convex_local_storage/modules/data.json", "{}");
-
- const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
- const paths = result.entries.map((entry) => entry.path);
-
- assert.include(paths, "src");
- assert.include(paths, "src/keep.ts");
- assert.notInclude(paths, "ignored.txt");
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith("convex/")));
- });
-
- it("excludes tracked paths that match ignore rules", async () => {
- const cwd = makeTempDir("t3code-workspace-tracked-gitignore-");
- runGit(cwd, ["init"]);
- writeFile(cwd, ".convex/local-storage/data.json", "{}");
- writeFile(cwd, "src/keep.ts", "export {};");
- runGit(cwd, ["add", ".convex/local-storage/data.json", "src/keep.ts"]);
- writeFile(cwd, ".gitignore", ".convex/\n");
-
- const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
- const paths = result.entries.map((entry) => entry.path);
-
- assert.include(paths, "src");
- assert.include(paths, "src/keep.ts");
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
- });
-
- it("excludes .convex in non-git workspaces", async () => {
- const cwd = makeTempDir("t3code-workspace-non-git-convex-");
- writeFile(cwd, ".convex/local-storage/data.json", "{}");
- writeFile(cwd, "src/keep.ts", "export {};");
-
- const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
- const paths = result.entries.map((entry) => entry.path);
-
- assert.include(paths, "src");
- assert.include(paths, "src/keep.ts");
- assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
- });
-
- it("deduplicates concurrent index builds for the same cwd", async () => {
- const cwd = makeTempDir("t3code-workspace-concurrent-build-");
- writeFile(cwd, "src/components/Composer.tsx");
-
- let rootReadCount = 0;
- const originalReaddir = fsPromises.readdir.bind(fsPromises);
- vi.spyOn(fsPromises, "readdir").mockImplementation((async (
- ...args: Parameters<typeof fsPromises.readdir>
- ) => {
- if (args[0] === cwd) {
- rootReadCount += 1;
- await new Promise((resolve) => setTimeout(resolve, 20));
- }
- return originalReaddir(...args);
- }) as typeof fsPromises.readdir);
-
- await Promise.all([
- searchWorkspaceEntries({ cwd, query: "", limit: 100 }),
- searchWorkspaceEntries({ cwd, query: "comp", limit: 100 }),
- searchWorkspaceEntries({ cwd, query: "src", limit: 100 }),
- ]);
-
- assert.equal(rootReadCount, 1);
- });
-
- it("limits concurrent directory reads while walking the filesystem", async () => {
- const cwd = makeTempDir("t3code-workspace-read-concurrency-");
- for (let index = 0; index < 80; index += 1) {
- writeFile(cwd, `group-${index}/entry-${index}.ts`, "export {};");
- }
-
- let activeReads = 0;
- let peakReads = 0;
- const originalReaddir = fsPromises.readdir.bind(fsPromises);
- vi.spyOn(fsPromises, "readdir").mockImplementation((async (
- ...args: Parameters<typeof fsPromises.readdir>
- ) => {
- const target = args[0];
- if (typeof target === "string" && target.startsWith(cwd)) {
- activeReads += 1;
- peakReads = Math.max(peakReads, activeReads);
- await new Promise((resolve) => setTimeout(resolve, 4));
- try {
- return await originalReaddir(...args);
- } finally {
- activeReads -= 1;
- }
- }
- return originalReaddir(...args);
- }) as typeof fsPromises.readdir);
-
- await searchWorkspaceEntries({ cwd, query: "", limit: 200 });
-
- assert.isAtMost(peakReads, 32);
- });
-});
diff --git a/apps/server/src/workspaceEntries.ts b/apps/server/src/workspaceEntries.ts
deleted file mode 100644
index 684b005e8..000000000
--- a/apps/server/src/workspaceEntries.ts
+++ /dev/null
@@ -1,565 +0,0 @@
-import fs from "node:fs/promises";
-import type { Dirent } from "node:fs";
-import path from "node:path";
-import { runProcess } from "./processRunner";
-
-import {
- ProjectEntry,
- ProjectSearchEntriesInput,
- ProjectSearchEntriesResult,
-} from "@t3tools/contracts";
-
-const WORKSPACE_CACHE_TTL_MS = 15_000;
-const WORKSPACE_CACHE_MAX_KEYS = 4;
-const WORKSPACE_INDEX_MAX_ENTRIES = 25_000;
-const WORKSPACE_SCAN_READDIR_CONCURRENCY = 32;
-const GIT_CHECK_IGNORE_MAX_STDIN_BYTES = 256 * 1024;
-const IGNORED_DIRECTORY_NAMES = new Set([
- ".git",
- ".convex",
- "node_modules",
- ".next",
- ".turbo",
- "dist",
- "build",
- "out",
- ".cache",
-]);
-
-interface WorkspaceIndex {
- scannedAt: number;
- entries: SearchableWorkspaceEntry[];
- truncated: boolean;
-}
-
-interface SearchableWorkspaceEntry extends ProjectEntry {
- normalizedPath: string;
- normalizedName: string;
-}
-
-interface RankedWorkspaceEntry {
- entry: SearchableWorkspaceEntry;
- score: number;
-}
-
-const workspaceIndexCache = new Map<string, WorkspaceIndex>();
-const inFlightWorkspaceIndexBuilds = new Map<string, Promise<WorkspaceIndex>>();
-
-function toPosixPath(input: string): string {
- return input.split(path.sep).join("/");
-}
-
-function parentPathOf(input: string): string | undefined {
- const separatorIndex = input.lastIndexOf("/");
- if (separatorIndex === -1) {
- return undefined;
- }
- return input.slice(0, separatorIndex);
-}
-
-function basenameOf(input: string): string {
- const separatorIndex = input.lastIndexOf("/");
- if (separatorIndex === -1) {
- return input;
- }
- return input.slice(separatorIndex + 1);
-}
-
-function toSearchableWorkspaceEntry(entry: ProjectEntry): SearchableWorkspaceEntry {
- const normalizedPath = entry.path.toLowerCase();
- return {
- ...entry,
- normalizedPath,
- normalizedName: basenameOf(normalizedPath),
- };
-}
-
-function normalizeQuery(input: string): string {
- return input
- .trim()
- .replace(/^[@./]+/, "")
- .toLowerCase();
-}
-
-function scoreSubsequenceMatch(value: string, query: string): number | null {
- if (!query) return 0;
-
- let queryIndex = 0;
- let firstMatchIndex = -1;
- let previousMatchIndex = -1;
- let gapPenalty = 0;
-
- for (let valueIndex = 0; valueIndex < value.length; valueIndex += 1) {
- if (value[valueIndex] !== query[queryIndex]) {
- continue;
- }
-
- if (firstMatchIndex === -1) {
- firstMatchIndex = valueIndex;
- }
- if (previousMatchIndex !== -1) {
- gapPenalty += valueIndex - previousMatchIndex - 1;
- }
-
- previousMatchIndex = valueIndex;
- queryIndex += 1;
- if (queryIndex === query.length) {
- const spanPenalty = valueIndex - firstMatchIndex + 1 - query.length;
- const lengthPenalty = Math.min(64, value.length - query.length);
- return firstMatchIndex * 2 + gapPenalty * 3 + spanPenalty + lengthPenalty;
- }
- }
-
- return null;
-}
-
-function scoreEntry(entry: SearchableWorkspaceEntry, query: string): number | null {
- if (!query) {
- return entry.kind === "directory" ? 0 : 1;
- }
-
- const { normalizedPath, normalizedName } = entry;
-
- if (normalizedName === query) return 0;
- if (normalizedPath === query) return 1;
- if (normalizedName.startsWith(query)) return 2;
- if (normalizedPath.startsWith(query)) return 3;
- if (normalizedPath.includes(`/${query}`)) return 4;
- if (normalizedName.includes(query)) return 5;
- if (normalizedPath.includes(query)) return 6;
-
- const nameFuzzyScore = scoreSubsequenceMatch(normalizedName, query);
- if (nameFuzzyScore !== null) {
- return 100 + nameFuzzyScore;
- }
-
- const pathFuzzyScore = scoreSubsequenceMatch(normalizedPath, query);
- if (pathFuzzyScore !== null) {
- return 200 + pathFuzzyScore;
- }
-
- return null;
-}
-
-function compareRankedWorkspaceEntries(
- left: RankedWorkspaceEntry,
- right: RankedWorkspaceEntry,
-): number {
- const scoreDelta = left.score - right.score;
- if (scoreDelta !== 0) return scoreDelta;
- return left.entry.path.localeCompare(right.entry.path);
-}
-
-function findInsertionIndex(
- rankedEntries: RankedWorkspaceEntry[],
- candidate: RankedWorkspaceEntry,
-): number {
- let low = 0;
- let high = rankedEntries.length;
-
- while (low < high) {
- const middle = low + Math.floor((high - low) / 2);
- const current = rankedEntries[middle];
- if (!current) {
- break;
- }
-
- if (compareRankedWorkspaceEntries(candidate, current) < 0) {
- high = middle;
- } else {
- low = middle + 1;
- }
- }
-
- return low;
-}
-
-function insertRankedEntry(
- rankedEntries: RankedWorkspaceEntry[],
- candidate: RankedWorkspaceEntry,
- limit: number,
-): void {
- if (limit <= 0) {
- return;
- }
-
- const insertionIndex = findInsertionIndex(rankedEntries, candidate);
- if (rankedEntries.length < limit) {
- rankedEntries.splice(insertionIndex, 0, candidate);
- return;
- }
-
- if (insertionIndex >= limit) {
- return;
- }
-
- rankedEntries.splice(insertionIndex, 0, candidate);
- rankedEntries.pop();
-}
-
-function isPathInIgnoredDirectory(relativePath: string): boolean {
- const firstSegment = relativePath.split("/")[0];
- if (!firstSegment) return false;
- return IGNORED_DIRECTORY_NAMES.has(firstSegment);
-}
-
-function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
- const parts = input.split("\0");
- if (parts.length === 0) return [];
-
- // If output was truncated, the final token can be partial.
- if (truncated && parts[parts.length - 1]?.length) {
- parts.pop();
- }
-
- return parts.filter((value) => value.length > 0);
-}
-
-function directoryAncestorsOf(relativePath: string): string[] {
- const segments = relativePath.split("/").filter((segment) => segment.length > 0);
- if (segments.length <= 1) return [];
- const directories: string[] = [];
- for (let index = 1; index < segments.length; index += 1) {
- directories.push(segments.slice(0, index).join("/"));
- }
- return directories;
-}
-
-async function mapWithConcurrency<TInput, TOutput>(
- items: readonly TInput[],
- concurrency: number,
- mapper: (item: TInput, index: number) => Promise<TOutput>,
-): Promise<TOutput[]> {
- if (items.length === 0) {
- return [];
- }
-
- const boundedConcurrency = Math.max(1, Math.min(concurrency, items.length));
- const results = Array.from({ length: items.length }) as TOutput[];
- let nextIndex = 0;
-
- const workers = Array.from({ length: boundedConcurrency }, async () => {
- while (nextIndex < items.length) {
- const currentIndex = nextIndex;
- nextIndex += 1;
- results[currentIndex] = await mapper(items[currentIndex] as TInput, currentIndex);
- }
- });
-
- await Promise.all(workers);
- return results;
-}
-
-async function isInsideGitWorkTree(cwd: string): Promise<boolean> {
- const insideWorkTree = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], {
- cwd,
- allowNonZeroExit: true,
- timeoutMs: 5_000,
- maxBufferBytes: 4_096,
- }).catch(() => null);
- return Boolean(
- insideWorkTree && insideWorkTree.code === 0 && insideWorkTree.stdout.trim() === "true",
- );
-}
-
-async function filterGitIgnoredPaths(cwd: string, relativePaths: string[]): Promise<string[]> {
- if (relativePaths.length === 0) {
- return relativePaths;
- }
-
- const ignoredPaths = new Set<string>();
- let chunk: string[] = [];
- let chunkBytes = 0;
-
- const flushChunk = async (): Promise<boolean> => {
- if (chunk.length === 0) {
- return true;
- }
-
- const checkIgnore = await runProcess("git", ["check-ignore", "--no-index", "-z", "--stdin"], {
- cwd,
- allowNonZeroExit: true,
- timeoutMs: 20_000,
- maxBufferBytes: 16 * 1024 * 1024,
- outputMode: "truncate",
- stdin: `${chunk.join("\0")}\0`,
- }).catch(() => null);
- chunk = [];
- chunkBytes = 0;
-
- if (!checkIgnore) {
- return false;
- }
-
- // git-check-ignore exits with 1 when no paths match.
- if (checkIgnore.code !== 0 && checkIgnore.code !== 1) {
- return false;
- }
-
- const matchedIgnoredPaths = splitNullSeparatedPaths(
- checkIgnore.stdout,
- Boolean(checkIgnore.stdoutTruncated),
- );
- for (const ignoredPath of matchedIgnoredPaths) {
- ignoredPaths.add(ignoredPath);
- }
- return true;
- };
-
- for (const relativePath of relativePaths) {
- const relativePathBytes = Buffer.byteLength(relativePath) + 1;
- if (
- chunk.length > 0 &&
- chunkBytes + relativePathBytes > GIT_CHECK_IGNORE_MAX_STDIN_BYTES &&
- !(await flushChunk())
- ) {
- return relativePaths;
- }
-
- chunk.push(relativePath);
- chunkBytes += relativePathBytes;
-
- if (chunkBytes >= GIT_CHECK_IGNORE_MAX_STDIN_BYTES && !(await flushChunk())) {
- return relativePaths;
- }
- }
-
- if (!(await flushChunk())) {
- return relativePaths;
- }
-
- if (ignoredPaths.size === 0) {
- return relativePaths;
- }
-
- return relativePaths.filter((relativePath) => !ignoredPaths.has(relativePath));
-}
-
-async function buildWorkspaceIndexFromGit(cwd: string): Promise<WorkspaceIndex | null> {
- if (!(await isInsideGitWorkTree(cwd))) {
- return null;
- }
-
- const listedFiles = await runProcess(
- "git",
- ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
- {
- cwd,
- allowNonZeroExit: true,
- timeoutMs: 20_000,
- maxBufferBytes: 16 * 1024 * 1024,
- outputMode: "truncate",
- },
- ).catch(() => null);
- if (!listedFiles || listedFiles.code !== 0) {
- return null;
- }
-
- const listedPaths = splitNullSeparatedPaths(
- listedFiles.stdout,
- Boolean(listedFiles.stdoutTruncated),
- )
- .map((entry) => toPosixPath(entry))
- .filter((entry) => entry.length > 0 && !isPathInIgnoredDirectory(entry));
- const filePaths = await filterGitIgnoredPaths(cwd, listedPaths);
-
- const directorySet = new Set<string>();
- for (const filePath of filePaths) {
- for (const directoryPath of directoryAncestorsOf(filePath)) {
- if (!isPathInIgnoredDirectory(directoryPath)) {
- directorySet.add(directoryPath);
- }
- }
- }
-
- const directoryEntries = [...directorySet]
- .toSorted((left, right) => left.localeCompare(right))
- .map(
- (directoryPath): ProjectEntry => ({
- path: directoryPath,
- kind: "directory",
- parentPath: parentPathOf(directoryPath),
- }),
- )
- .map(toSearchableWorkspaceEntry);
- const fileEntries = [...new Set(filePaths)]
- .toSorted((left, right) => left.localeCompare(right))
- .map(
- (filePath): ProjectEntry => ({
- path: filePath,
- kind: "file",
- parentPath: parentPathOf(filePath),
- }),
- )
- .map(toSearchableWorkspaceEntry);
-
- const entries = [...directoryEntries, ...fileEntries];
- return {
- scannedAt: Date.now(),
- entries: entries.slice(0, WORKSPACE_INDEX_MAX_ENTRIES),
- truncated: Boolean(listedFiles.stdoutTruncated) || entries.length > WORKSPACE_INDEX_MAX_ENTRIES,
- };
-}
-
-async function buildWorkspaceIndex(cwd: string): Promise<WorkspaceIndex> {
- const gitIndexed = await buildWorkspaceIndexFromGit(cwd);
- if (gitIndexed) {
- return gitIndexed;
- }
- const shouldFilterWithGitIgnore = await isInsideGitWorkTree(cwd);
-
- let pendingDirectories: string[] = [""];
- const entries: SearchableWorkspaceEntry[] = [];
- let truncated = false;
-
- while (pendingDirectories.length > 0 && !truncated) {
- const currentDirectories = pendingDirectories;
- pendingDirectories = [];
- const directoryEntries = await mapWithConcurrency(
- currentDirectories,
- WORKSPACE_SCAN_READDIR_CONCURRENCY,
- async (relativeDir) => {
- const absoluteDir = relativeDir ? path.join(cwd, relativeDir) : cwd;
- try {
- const dirents = await fs.readdir(absoluteDir, { withFileTypes: true });
- return { relativeDir, dirents };
- } catch (error) {
- if (!relativeDir) {
- throw new Error(
- `Unable to scan workspace entries at '${cwd}': ${error instanceof Error ? error.message : "unknown error"}`,
- { cause: error },
- );
- }
- return { relativeDir, dirents: null };
- }
- },
- );
-
- const candidateEntriesByDirectory = directoryEntries.map((directoryEntry) => {
- const { relativeDir, dirents } = directoryEntry;
- if (!dirents) return [] as Array<{ dirent: Dirent; relativePath: string }>;
-
- dirents.sort((left, right) => left.name.localeCompare(right.name));
- const candidates: Array<{ dirent: Dirent; relativePath: string }> = [];
- for (const dirent of dirents) {
- if (!dirent.name || dirent.name === "." || dirent.name === "..") {
- continue;
- }
- if (dirent.isDirectory() && IGNORED_DIRECTORY_NAMES.has(dirent.name)) {
- continue;
- }
- if (!dirent.isDirectory() && !dirent.isFile()) {
- continue;
- }
-
- const relativePath = toPosixPath(
- relativeDir ? path.join(relativeDir, dirent.name) : dirent.name,
- );
- if (isPathInIgnoredDirectory(relativePath)) {
- continue;
- }
- candidates.push({ dirent, relativePath });
- }
- return candidates;
- });
-
- const candidatePaths = candidateEntriesByDirectory.flatMap((candidateEntries) =>
- candidateEntries.map((entry) => entry.relativePath),
- );
- const allowedPathSet = shouldFilterWithGitIgnore
- ? new Set(await filterGitIgnoredPaths(cwd, candidatePaths))
- : null;
-
- for (const candidateEntries of candidateEntriesByDirectory) {
- for (const candidate of candidateEntries) {
- if (allowedPathSet && !allowedPathSet.has(candidate.relativePath)) {
- continue;
- }
-
- const entry = toSearchableWorkspaceEntry({
- path: candidate.relativePath,
- kind: candidate.dirent.isDirectory() ? "directory" : "file",
- parentPath: parentPathOf(candidate.relativePath),
- });
- entries.push(entry);
-
- if (candidate.dirent.isDirectory()) {
- pendingDirectories.push(candidate.relativePath);
- }
-
- if (entries.length >= WORKSPACE_INDEX_MAX_ENTRIES) {
- truncated = true;
- break;
- }
- }
-
- if (truncated) {
- break;
- }
- }
- }
-
- return {
- scannedAt: Date.now(),
- entries,
- truncated,
- };
-}
-
-async function getWorkspaceIndex(cwd: string): Promise<WorkspaceIndex> {
- const cached = workspaceIndexCache.get(cwd);
- if (cached && Date.now() - cached.scannedAt < WORKSPACE_CACHE_TTL_MS) {
- return cached;
- }
-
- const inFlight = inFlightWorkspaceIndexBuilds.get(cwd);
- if (inFlight) {
- return inFlight;
- }
-
- const nextPromise = buildWorkspaceIndex(cwd)
- .then((next) => {
- workspaceIndexCache.set(cwd, next);
- while (workspaceIndexCache.size > WORKSPACE_CACHE_MAX_KEYS) {
- const oldestKey = workspaceIndexCache.keys().next().value;
- if (!oldestKey) break;
- workspaceIndexCache.delete(oldestKey);
- }
- return next;
- })
- .finally(() => {
- inFlightWorkspaceIndexBuilds.delete(cwd);
- });
- inFlightWorkspaceIndexBuilds.set(cwd, nextPromise);
- return nextPromise;
-}
-
-export function clearWorkspaceIndexCache(cwd: string): void {
- workspaceIndexCache.delete(cwd);
- inFlightWorkspaceIndexBuilds.delete(cwd);
-}
-
-export async function searchWorkspaceEntries(
- input: ProjectSearchEntriesInput,
-): Promise<ProjectSearchEntriesResult> {
- const index = await getWorkspaceIndex(input.cwd);
- const normalizedQuery = normalizeQuery(input.query);
- const limit = Math.max(0, Math.floor(input.limit));
- const rankedEntries: RankedWorkspaceEntry[] = [];
- let matchedEntryCount = 0;
-
- for (const entry of index.entries) {
- const score = scoreEntry(entry, normalizedQuery);
- if (score === null) {
- continue;
- }
-
- matchedEntryCount += 1;
- insertRankedEntry(rankedEntries, { entry, score }, limit);
- }
-
- return {
- entries: rankedEntries.map((candidate) => candidate.entry),
- truncated: index.truncated || matchedEntryCount > limit,
- };
-}
diff --git a/apps/server/src/wsServer.test.ts b/apps/server/src/wsServer.test.ts
index 0e06650fe..4fa281d29 100644
--- a/apps/server/src/wsServer.test.ts
+++ b/apps/server/src/wsServer.test.ts
@@ -4,7 +4,17 @@ import os from "node:os";
import path from "node:path";
import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Effect, Exit, Fiber, Layer, PlatformError, PubSub, Scope, Stream } from "effect";
+import {
+ Effect,
+ Exit,
+ Fiber,
+ Layer,
+ ManagedRuntime,
+ PlatformError,
+ PubSub,
+ Scope,
+ Stream,
+} from "effect";
import { describe, expect, it, afterEach, vi } from "vitest";
import { createServer } from "./wsServer";
import WebSocket from "ws";
@@ -475,6 +485,7 @@ function deriveServerPathsSync(baseDir: string, devUrl: URL | undefined) {
describe("WebSocket Server", () => {
let server: Http.Server | null = null;
let serverScope: Scope.Closeable | null = null;
+ let disposeServerRuntime: (() => Promise<void>) | null = null;
const connections: WebSocket[] = [];
const tempDirs: string[] = [];
@@ -521,6 +532,12 @@ describe("WebSocket Server", () => {
options.providerRegistry ?? defaultProviderRegistryService,
);
const openLayer = Layer.succeed(Open, options.open ?? defaultOpenService);
+ const nodeServicesLayer = NodeServices.layer;
+ const serverSettingsLayer = ServerSettingsService.layerTest(options.serverSettings);
+ const serverSettingsRuntimeLayer = serverSettingsLayer.pipe(
+ Layer.provideMerge(nodeServicesLayer),
+ );
+ const analyticsLayer = AnalyticsService.layerTest;
const serverConfigLayer = Layer.succeed(ServerConfig, {
mode: "web",
port: 0,
@@ -536,6 +553,11 @@ describe("WebSocket Server", () => {
logWebSocketEvents: options.logWebSocketEvents ?? Boolean(options.devUrl),
} satisfies ServerConfigShape);
const infrastructureLayer = providerLayer.pipe(Layer.provideMerge(persistenceLayer));
+ const providerRuntimeLayer = infrastructureLayer.pipe(
+ Layer.provideMerge(serverConfigLayer),
+ Layer.provideMerge(serverSettingsRuntimeLayer),
+ Layer.provideMerge(analyticsLayer),
+ );
const runtimeOverrides = Layer.mergeAll(
options.gitManager ? Layer.succeed(GitManager, options.gitManager) : Layer.empty,
options.gitCore
@@ -548,41 +570,49 @@ describe("WebSocket Server", () => {
const runtimeLayer = Layer.merge(
Layer.merge(
- makeServerRuntimeServicesLayer().pipe(Layer.provide(infrastructureLayer)),
- infrastructureLayer,
+ makeServerRuntimeServicesLayer().pipe(
+ Layer.provideMerge(providerRuntimeLayer),
+ Layer.provideMerge(serverConfigLayer),
+ Layer.provideMerge(serverSettingsRuntimeLayer),
+ Layer.provideMerge(analyticsLayer),
+ Layer.provideMerge(nodeServicesLayer),
+ ),
+ Layer.mergeAll(providerRuntimeLayer, serverSettingsRuntimeLayer, analyticsLayer),
),
runtimeOverrides,
);
- const dependenciesLayer = Layer.empty.pipe(
- Layer.provideMerge(runtimeLayer),
- Layer.provideMerge(providerRegistryLayer),
- Layer.provideMerge(openLayer),
- Layer.provideMerge(ServerSettingsService.layerTest(options.serverSettings)),
- Layer.provideMerge(serverConfigLayer),
- Layer.provideMerge(AnalyticsService.layerTest),
- Layer.provideMerge(NodeServices.layer),
- );
- const runtimeServices = await Effect.runPromise(
- Layer.build(dependenciesLayer).pipe(Scope.provide(scope)),
+ const dependenciesLayer = Layer.mergeAll(
+ runtimeLayer,
+ providerRegistryLayer,
+ openLayer,
+ serverConfigLayer,
+ nodeServicesLayer,
);
-
+ const runtime = ManagedRuntime.make(dependenciesLayer);
try {
- const runtime = await Effect.runPromise(
- createServer().pipe(Effect.provide(runtimeServices), Scope.provide(scope)),
- );
+ const httpServer = await runtime.runPromise(createServer().pipe(Scope.provide(scope)));
+ disposeServerRuntime = () => runtime.dispose();
serverScope = scope;
- return runtime;
+ return httpServer;
} catch (error) {
+ await runtime.dispose();
await Effect.runPromise(Scope.close(scope, Exit.void));
throw error;
}
}
async function closeTestServer() {
- if (!serverScope) return;
+ if (!serverScope && !disposeServerRuntime) return;
const scope = serverScope;
+ const disposeRuntime = disposeServerRuntime;
serverScope = null;
- await Effect.runPromise(Scope.close(scope, Exit.void));
+ disposeServerRuntime = null;
+ if (scope) {
+ await Effect.runPromise(Scope.close(scope, Exit.void));
+ }
+ if (disposeRuntime) {
+ await disposeRuntime();
+ }
}
afterEach(async () => {
@@ -1255,6 +1285,32 @@ describe("WebSocket Server", () => {
expect(response.error?.message).toContain("exceeds current turn count");
});
+ it("rejects project.create when the workspace root does not exist", async () => {
+ server = await createTestServer({ cwd: "/test" });
+ const addr = server.address();
+ const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+ const [ws] = await connectAndAwaitWelcome(port);
+ connections.push(ws);
+
+ const missingWorkspaceRoot = path.join(makeTempDir("t3code-ws-project-missing-"), "missing");
+ const response = await sendRequest(ws, ORCHESTRATION_WS_METHODS.dispatchCommand, {
+ type: "project.create",
+ commandId: "cmd-ws-project-create-missing",
+ projectId: "project-missing",
+ title: "Missing Project",
+ workspaceRoot: missingWorkspaceRoot,
+ defaultModelSelection: {
+ provider: "codex",
+ model: "gpt-5-codex",
+ },
+ createdAt: new Date().toISOString(),
+ });
+
+ expect(response.result).toBeUndefined();
+ expect(response.error?.message).toContain("Workspace root does not exist:");
+ });
+
it("keeps orchestration domain push behavior for provider runtime events", async () => {
const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());
const emitRuntimeEvent = (event: ProviderRuntimeEvent) => {
@@ -1665,6 +1721,50 @@ describe("WebSocket Server", () => {
);
});
+ it("invalidates workspace entry search cache after projects.writeFile", async () => {
+ const workspace = makeTempDir("t3code-ws-write-file-invalidate-");
+ fs.mkdirSync(path.join(workspace, "src"), { recursive: true });
+ fs.writeFileSync(path.join(workspace, "src", "existing.ts"), "export {};\n", "utf8");
+
+ server = await createTestServer({ cwd: "/test" });
+ const addr = server.address();
+ const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+ const [ws] = await connectAndAwaitWelcome(port);
+ connections.push(ws);
+
+ const beforeWrite = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
+ cwd: workspace,
+ query: "rpc",
+ limit: 10,
+ });
+ expect(beforeWrite.error).toBeUndefined();
+ expect(beforeWrite.result).toEqual({
+ entries: [],
+ truncated: false,
+ });
+
+ const writeResponse = await sendRequest(ws, WS_METHODS.projectsWriteFile, {
+ cwd: workspace,
+ relativePath: "plans/effect-rpc.md",
+ contents: "# Plan\n",
+ });
+ expect(writeResponse.error).toBeUndefined();
+
+ const afterWrite = await sendRequest(ws, WS_METHODS.projectsSearchEntries, {
+ cwd: workspace,
+ query: "rpc",
+ limit: 10,
+ });
+ expect(afterWrite.error).toBeUndefined();
+ expect(afterWrite.result).toEqual({
+ entries: expect.arrayContaining([
+ expect.objectContaining({ path: "plans/effect-rpc.md", kind: "file" }),
+ ]),
+ truncated: false,
+ });
+ });
+
it("rejects projects.writeFile paths outside the workspace root", async () => {
const workspace = makeTempDir("t3code-ws-write-file-reject-");
@@ -1683,7 +1783,7 @@ describe("WebSocket Server", () => {
expect(response.result).toBeUndefined();
expect(response.error?.message).toContain(
- "Workspace file path must stay within the project root.",
+ "Workspace file path must be relative to the project root: ../escape.md",
);
expect(fs.existsSync(path.join(workspace, "..", "escape.md"))).toBe(false);
});
diff --git a/apps/server/src/wsServer.ts b/apps/server/src/wsServer.ts
index 25f815892..b9fd7e58d 100644
--- a/apps/server/src/wsServer.ts
+++ b/apps/server/src/wsServer.ts
@@ -50,7 +50,6 @@ import { GitManager } from "./git/Services/GitManager.ts";
import { TerminalManager } from "./terminal/Services/Manager.ts";
import { Keybindings } from "./keybindings";
import { ServerSettingsService } from "./serverSettings";
-import { searchWorkspaceEntries } from "./workspaceEntries";
import { OrchestrationEngineService } from "./orchestration/Services/OrchestrationEngine";
import { ProjectionSnapshotQuery } from "./orchestration/Services/ProjectionSnapshotQuery";
import { OrchestrationReactor } from "./orchestration/Services/OrchestrationReactor";
@@ -75,10 +74,13 @@ import {
} from "./attachmentStore.ts";
import { parseBase64DataUrl } from "./imageMime.ts";
import { AnalyticsService } from "./telemetry/Services/AnalyticsService.ts";
-import { expandHomePath } from "./os-jank.ts";
import { makeServerPushBus } from "./wsServer/pushBus.ts";
import { makeServerReadiness } from "./wsServer/readiness.ts";
import { decodeJsonResult, formatSchemaError } from "@t3tools/shared/schemaJson";
+import { ProjectFaviconResolver } from "./project/Services/ProjectFaviconResolver.ts";
+import { WorkspaceEntries } from "./workspace/Services/WorkspaceEntries.ts";
+import { WorkspaceFileSystem } from "./workspace/Services/WorkspaceFileSystem.ts";
+import { WorkspacePaths } from "./workspace/Services/WorkspacePaths.ts";
/**
* ServerShape - Service API for server lifecycle control.
@@ -154,48 +156,6 @@ function websocketRawToString(raw: unknown): string | null {
return null;
}
-function toPosixRelativePath(input: string): string {
- return input.replaceAll("\\", "/");
-}
-
-function resolveWorkspaceWritePath(params: {
- workspaceRoot: string;
- relativePath: string;
- path: Path.Path;
-}): Effect.Effect<{ absolutePath: string; relativePath: string }, RouteRequestError> {
- const normalizedInputPath = params.relativePath.trim();
- if (params.path.isAbsolute(normalizedInputPath)) {
- return Effect.fail(
- new RouteRequestError({
- message: "Workspace file path must be relative to the project root.",
- }),
- );
- }
-
- const absolutePath = params.path.resolve(params.workspaceRoot, normalizedInputPath);
- const relativeToRoot = toPosixRelativePath(
- params.path.relative(params.workspaceRoot, absolutePath),
- );
- if (
- relativeToRoot.length === 0 ||
- relativeToRoot === "." ||
- relativeToRoot.startsWith("../") ||
- relativeToRoot === ".." ||
- params.path.isAbsolute(relativeToRoot)
- ) {
- return Effect.fail(
- new RouteRequestError({
- message: "Workspace file path must stay within the project root.",
- }),
- );
- }
-
- return Effect.succeed({
- absolutePath,
- relativePath: relativeToRoot,
- });
-}
-
function stripRequestTag<T extends { _tag: string }>(body: T) {
return Struct.omit(body, ["_tag"]);
}
@@ -218,6 +178,10 @@ export type ServerRuntimeServices =
| TerminalManager
| Keybindings
| ServerSettingsService
+ | ProjectFaviconResolver
+ | WorkspaceEntries
+ | WorkspaceFileSystem
+ | WorkspacePaths
| Open
| AnalyticsService;
@@ -263,6 +227,9 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
const serverSettingsManager = yield* ServerSettingsService;
const providerRegistry = yield* ProviderRegistry;
const git = yield* GitCore;
+ const workspaceEntries = yield* WorkspaceEntries;
+ const workspaceFileSystem = yield* WorkspaceFileSystem;
+ const workspacePaths = yield* WorkspacePaths;
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
@@ -312,35 +279,21 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
const normalizeDispatchCommand = Effect.fnUntraced(function* (input: {
readonly command: ClientOrchestrationCommand;
}) {
- const normalizeProjectWorkspaceRoot = Effect.fnUntraced(function* (workspaceRoot: string) {
- const normalizedWorkspaceRoot = path.resolve(yield* expandHomePath(workspaceRoot.trim()));
- const workspaceStat = yield* fileSystem
- .stat(normalizedWorkspaceRoot)
- .pipe(Effect.catch(() => Effect.succeed(null)));
- if (!workspaceStat) {
- return yield* new RouteRequestError({
- message: `Project directory does not exist: ${normalizedWorkspaceRoot}`,
- });
- }
- if (workspaceStat.type !== "Directory") {
- return yield* new RouteRequestError({
- message: `Project path is not a directory: ${normalizedWorkspaceRoot}`,
- });
- }
- return normalizedWorkspaceRoot;
- });
-
if (input.command.type === "project.create") {
return {
...input.command,
- workspaceRoot: yield* normalizeProjectWorkspaceRoot(input.command.workspaceRoot),
+ workspaceRoot: yield* workspacePaths
+ .normalizeWorkspaceRoot(input.command.workspaceRoot)
+ .pipe(Effect.mapError((cause) => new RouteRequestError({ message: cause.message }))),
} satisfies OrchestrationCommand;
}
if (input.command.type === "project.meta.update" && input.command.workspaceRoot !== undefined) {
return {
...input.command,
- workspaceRoot: yield* normalizeProjectWorkspaceRoot(input.command.workspaceRoot),
+ workspaceRoot: yield* workspacePaths
+ .normalizeWorkspaceRoot(input.command.workspaceRoot)
+ .pipe(Effect.mapError((cause) => new RouteRequestError({ message: cause.message }))),
} satisfies OrchestrationCommand;
}
@@ -437,7 +390,7 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
void runPromise(
Effect.gen(function* () {
const url = new URL(req.url ?? "/", `http://localhost:${port}`);
- if (tryHandleProjectFaviconRequest(url, res)) {
+ if (yield* tryHandleProjectFaviconRequest(url, res)) {
return;
}
@@ -768,41 +721,26 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
case WS_METHODS.projectsSearchEntries: {
const body = stripRequestTag(request.body);
- return yield* Effect.tryPromise({
- try: () => searchWorkspaceEntries(body),
- catch: (cause) =>
- new RouteRequestError({
- message: `Failed to search workspace entries: ${String(cause)}`,
- }),
- });
+ return yield* workspaceEntries.search(body).pipe(
+ Effect.mapError(
+ (cause) =>
+ new RouteRequestError({
+ message: `Failed to search workspace entries: ${cause.detail}`,
+ }),
+ ),
+ );
}
case WS_METHODS.projectsWriteFile: {
const body = stripRequestTag(request.body);
- const target = yield* resolveWorkspaceWritePath({
- workspaceRoot: body.cwd,
- relativePath: body.relativePath,
- path,
- });
- yield* fileSystem
- .makeDirectory(path.dirname(target.absolutePath), { recursive: true })
- .pipe(
- Effect.mapError(
- (cause) =>
- new RouteRequestError({
- message: `Failed to prepare workspace path: ${String(cause)}`,
- }),
- ),
- );
- yield* fileSystem.writeFileString(target.absolutePath, body.contents).pipe(
+ return yield* workspaceFileSystem.writeFile(body).pipe(
Effect.mapError(
(cause) =>
new RouteRequestError({
- message: `Failed to write workspace file: ${String(cause)}`,
+ message: `Failed to write workspace file: ${cause.message}`,
}),
),
);
- return { relativePath: target.relativePath };
}
case WS_METHODS.shellOpenInEditor: {