add remult entities

.mcp.json

@@ -1,8 +1,9 @@
 {
 	"mcpServers": {
-		"svelte-llm": {
-			"type": "http",
-			"url": "https://svelte-llm.stanislav.garden/mcp/mcp"
+		"svelte": {
+			"type": "stdio",
+			"command": "node",
+			"args": ["packages/mcp-stdio/dist/index.js"]
 		}
 	}
 }

.vscode/mcp.json

@@ -3,7 +3,7 @@
 		"Svelte MCP": {
 			"type": "stdio",
 			"command": "node",
-			"args": ["dist/lib/stdio.js"]
+			"args": ["packages/mcp-stdio/dist/index.js"]
 		}
 	},
 	"inputs": []

apps/mcp-remote/package.json

@@ -39,7 +39,6 @@
 	"devDependencies": {
 		"@eslint/compat": "^1.3.2",
 		"@eslint/js": "^9.36.0",
-		"@libsql/client": "^0.14.0",
 		"@modelcontextprotocol/inspector": "^0.16.7",
 		"@sveltejs/adapter-vercel": "^5.6.3",
 		"@sveltejs/kit": "^2.22.0",
@@ -53,6 +52,7 @@
 		"globals": "^16.0.0",
 		"prettier": "^3.4.2",
 		"prettier-plugin-svelte": "^3.3.3",
+		"remult": "3.3.0-next.1",
 		"svelte": "^5.0.0",
 		"svelte-check": "^4.0.0",
 		"svelte-eslint-parser": "^1.3.2",
@@ -62,8 +62,10 @@
 		"vitest": "^3.2.3"
 	},
 	"dependencies": {
+		"@libsql/client": "^0.14.0",
 		"@sveltejs/mcp-schema": "workspace:^",
 		"@sveltejs/mcp-server": "workspace:^",
-		"@tmcp/transport-http": "^0.6.2"
+		"@tmcp/transport-http": "^0.6.3",
+		"tmcp": "^1.14.0"
 	}
 }

apps/mcp-remote/src/hooks.server.ts

@@ -1,9 +1,10 @@
 import { http_transport } from '$lib/mcp/index.js';
-import { db } from '$lib/server/db/index.js';
+import { db, entities } from '$lib/server/db/index.js';
 
 export async function handle({ event, resolve }) {
 	const mcp_response = await http_transport.respond(event.request, {
 		db,
+		entities,
 	});
 	// we are deploying on vercel the SSE connection will timeout after 5 minutes...for
 	// the moment we are not sending back any notifications (logs, or list changed notifications)

apps/mcp-remote/src/lib/server/db/index.ts

@@ -1,9 +1,15 @@
 import { createClient } from '@libsql/client';
 import { drizzle } from 'drizzle-orm/libsql';
 import * as schema from './schema.js';
+import { remult, SqlDatabase } from 'remult';
+import { TursoDataProvider } from 'remult/remult-turso';
 // let's disable it for the moment...i can't figure out a way to make it wotk with eslint
 // eslint-disable-next-line import/extensions
 import { DATABASE_TOKEN, DATABASE_URL } from '$env/static/private';
+import { Content } from '../../../shared/entities/Content.js';
+import { ContentDistilled } from '../../../shared/entities/ContentDistilled.js';
+import { Distillation } from '../../../shared/entities/Distillation.js';
+import { DistillationJob } from '../../../shared/entities/DistillationJob.js';
 if (!DATABASE_URL) throw new Error('DATABASE_URL is not set');
 if (!DATABASE_TOKEN) throw new Error('DATABASE_TOKEN is not set');
 
@@ -13,3 +19,13 @@ const client = createClient({
 });
 
 export const db = drizzle(client, { schema, logger: true });
+
+remult.dataProvider = new SqlDatabase(new TursoDataProvider(client));
+SqlDatabase.LogToConsole = true;
+
+export const entities = {
+	Content,
+	ContentDistilled,
+	Distillation,
+	DistillationJob,
+};

apps/mcp-remote/src/shared/FieldVector.ts

@@ -0,0 +1,19 @@
+import { Fields, type FieldOptions } from 'remult';
+
+export function FieldVector<entityType = unknown>(
+	...options: (FieldOptions<entityType, number[]> & { dimensions?: number })[]
+) {
+	const dimensions = options[0].dimensions ?? 1024;
+
+	return Fields.object<entityType, number[]>(
+		{
+			valueConverter: {
+				fieldTypeInDb: `F32_BLOB(${dimensions})`,
+				toDb: (val) => JSON.stringify(val),
+				toDbSql: (val) => `vector32(${val})`,
+				fromDb: (val: Buffer) => Array.from(new Float32Array(val)),
+			},
+		},
+		...options,
+	);
+}

apps/mcp-remote/src/shared/entities/Content.ts

@@ -0,0 +1,35 @@
+import { Entity, Fields } from 'remult';
+import { FieldVector } from '../FieldVector';
+
+@Entity<Content>('content', {
+	allowApiCrud: true,
+	dbName: 'content',
+})
+export class Content {
+	@Fields.integer()
+	id!: number;
+
+	@Fields.string()
+	path!: string;
+
+	@Fields.string()
+	filename!: string;
+
+	@Fields.string()
+	content!: string;
+
+	@Fields.integer()
+	size_bytes!: number;
+
+	@FieldVector({ allowNull: true })
+	embeddings: number[] | null = null;
+
+	@Fields.string()
+	metadata = '{}';
+
+	@Fields.integer()
+	created_at!: number;
+
+	@Fields.integer()
+	updated_at!: number;
+}

apps/mcp-remote/src/shared/entities/ContentDistilled.ts

@@ -0,0 +1,35 @@
+import { Entity, Fields } from 'remult';
+import { FieldVector } from '../FieldVector';
+
+@Entity<ContentDistilled>('content_distilled', {
+	allowApiCrud: true,
+	dbName: 'content_distilled',
+})
+export class ContentDistilled {
+	@Fields.integer()
+	id!: number;
+
+	@Fields.string()
+	path!: string;
+
+	@Fields.string()
+	filename!: string;
+
+	@Fields.string()
+	content!: string;
+
+	@Fields.integer()
+	size_bytes!: number;
+
+	@FieldVector({ allowNull: true })
+	embeddings: number[] | null = null;
+
+	@Fields.string()
+	metadata = '{}';
+
+	@Fields.integer()
+	created_at!: number;
+
+	@Fields.integer()
+	updated_at!: number;
+}

apps/mcp-remote/src/shared/entities/Distillation.ts

@@ -0,0 +1,36 @@
+import { Entity, Field, Fields } from "remult"
+import { Relations } from "remult"
+import { DistillationJob } from "./DistillationJob.js"
+
+@Entity<Distillation>("distillations", {
+  allowApiCrud: true,
+  dbName: "distillations",
+})
+export class Distillation {
+  @Fields.integer()
+  id!: number
+
+  @Fields.string()
+  preset_name!: string
+
+  @Fields.string()
+  version!: string
+
+  @Fields.string()
+  content!: string
+
+  @Fields.integer()
+  size_kb!: number
+
+  @Fields.integer()
+  document_count!: number
+
+  @Fields.integer({ allowNull: true })
+  distillation_job_id?: number
+
+  @Relations.toOne(() => DistillationJob, { field: "distillation_job_id" })
+  distillation_job?: DistillationJob
+
+  @Fields.integer()
+  created_at!: number
+}

apps/mcp-remote/src/shared/entities/DistillationJob.ts

@@ -0,0 +1,64 @@
+import { Entity, Fields } from 'remult';
+import { Relations } from 'remult';
+import { Distillation } from './Distillation.js';
+
+@Entity<DistillationJob>('distillation_jobs', {
+	allowApiCrud: true,
+	dbName: 'distillation_jobs',
+})
+export class DistillationJob {
+	@Fields.integer()
+	id!: number;
+
+	@Fields.string()
+	preset_name!: string;
+
+	@Fields.string({ allowNull: true })
+	batch_id?: string;
+
+	@Fields.string()
+	status!: string;
+
+	@Fields.string()
+	model_used!: string;
+
+	@Fields.integer()
+	total_files!: number;
+
+	@Fields.integer()
+	processed_files = 0;
+
+	@Fields.integer()
+	successful_files = 0;
+
+	@Fields.boolean()
+	minimize_applied = false;
+
+	@Fields.integer()
+	total_input_tokens = 0;
+
+	@Fields.integer()
+	total_output_tokens = 0;
+
+	@Fields.integer({ allowNull: true })
+	started_at?: number;
+
+	@Fields.integer({ allowNull: true })
+	completed_at?: number;
+
+	@Fields.string({ allowNull: true })
+	error_message?: string;
+
+	@Fields.string()
+	metadata = '{}';
+
+	@Fields.integer()
+	created_at!: number;
+
+	@Fields.integer()
+	updated_at!: number;
+
+	// Relations toMany
+	@Relations.toMany(() => Distillation)
+	distillations?: Distillation[];
+}

apps/mcp-remote/tsconfig.json

@@ -9,7 +9,8 @@
 		"skipLibCheck": true,
 		"sourceMap": true,
 		"strict": true,
-		"moduleResolution": "bundler"
+		"moduleResolution": "bundler",
+		"experimentalDecorators": true
 	}
 	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
 	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files

packages/mcp-server/package.json

@@ -36,6 +36,7 @@
 		"@sveltejs/kit": "^2.42.2",
 		"@types/eslint-scope": "^8.3.2",
 		"@types/estree": "^1.0.8",
-		"@typescript-eslint/types": "^8.44.0"
+		"@typescript-eslint/types": "^8.44.0",
+		"remult": "3.3.0-next.1"
 	}
 }

packages/mcp-server/src/mcp/autofixers/add-autofixers-issues.test.ts

@@ -10,279 +10,292 @@ function run_autofixers_on_code(code: string, desired_svelte_version = 5) {
 	return content;
 }
 
+function with_possible_inits(title: string, fn: (args: { init: string }) => void) {
+	describe.each([
+		{ init: '$state' },
+		{ init: '$state.raw' },
+		{ init: '$derived' },
+		{ init: '$derived.by' },
+	])(title, fn);
+}
+
 describe('add_autofixers_issues', () => {
 	describe('assign_in_effect', () => {
-		it(`should add suggestions when assigning to a stateful variable inside an effect`, () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				const count = $state(0);
-				$effect(() => {
-					count = 43;
-				});
-			</script>`);
+		with_possible_inits('($init)', ({ init }) => {
+			it(`should add suggestions when assigning to a stateful variable inside an effect`, () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					const count = ${init}(0);
+					$effect(() => {
+						count = 43;
+					});
+				</script>`);
 
-			expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-			expect(content.suggestions).toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-		});
+				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+				expect(content.suggestions).toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
 
-		it(`should add a suggestion for each variable assigned within an effect`, () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				const count = $state(0);
-				const count2 = $state(0);
-				$effect(() => {
-					count = 43;
-					count2 = 44;
-				});
-			</script>`);
+			it(`should add a suggestion for each variable assigned within an effect`, () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					const count = $state(0);
+					const count2 = $state(0);
+					$effect(() => {
+						count = 43;
+						count2 = 44;
+					});
+				</script>`);
 
-			expect(content.suggestions.length).toBeGreaterThanOrEqual(2);
-			expect(content.suggestions).toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-			expect(content.suggestions).toContain(
-				'The stateful variable "count2" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-		});
-		it(`should not add a suggestion for variables that are not assigned within an effect`, () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				const count = $state(0);
-			</script>
-			
-			<button onclick={() => count = 43}>Increment</button>
-			`);
-
-			expect(content.suggestions).not.toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-		});
-
-		it("should not add a suggestions for variables that are assigned within an effect but aren't stateful", () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				const count = 0;
+				expect(content.suggestions.length).toBeGreaterThanOrEqual(2);
+				expect(content.suggestions).toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+				expect(content.suggestions).toContain(
+					'The stateful variable "count2" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
+			it(`should not add a suggestion for variables that are not assigned within an effect`, () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					const count = ${init}(0);
+				</script>
 				
-				$effect(() => {
-					count = 43;
-				});
-			</script>`);
+				<button onclick={() => count = 43}>Increment</button>
+				`);
 
-			expect(content.suggestions).not.toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-		});
+				expect(content.suggestions).not.toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
 
-		it(`should add a suggestion for variables that are assigned within an effect with an update`, () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				let count = $state(0);
-				
-				$effect(() => {
-					count++;
-				});
-			</script>
-			`);
+			it("should not add a suggestions for variables that are assigned within an effect but aren't stateful", () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					const count = 0;
+					
+					$effect(() => {
+						count = 43;
+					});
+				</script>`);
 
-			expect(content.suggestions).toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
-		});
+				expect(content.suggestions).not.toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
 
-		it(`should add a suggestion for variables that are mutated within an effect`, () => {
-			const content = run_autofixers_on_code(`
-			<script>
-				let count = $state({ value: 0 });
-				
-				$effect(() => {
-					count.value = 42;
-				});
-			</script>
-			`);
+			it(`should add a suggestion for variables that are assigned within an effect with an update`, () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					let count = ${init}(0);
+					
+					$effect(() => {
+						count++;
+					});
+				</script>
+				`);
 
-			expect(content.suggestions).toContain(
-				'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
-			);
+				expect(content.suggestions).toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
+
+			it(`should add a suggestion for variables that are mutated within an effect`, () => {
+				const content = run_autofixers_on_code(`
+				<script>
+					let count = ${init}({ value: 0 });
+					
+					$effect(() => {
+						count.value = 42;
+					});
+				</script>
+				`);
+
+				expect(content.suggestions).toContain(
+					'The stateful variable "count" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.',
+				);
+			});
 		});
 	});
 
-	describe.each([{ method: 'set' }, { method: 'update' }])(
-		'wrong_property_access_state ($method)',
-		({ method }) => {
-			it(`should add suggestions when using .${method}() on a stateful variable with a literal init`, () => {
-				const content = run_autofixers_on_code(`
+	with_possible_inits('($init)', ({ init }) => {
+		describe.each([{ method: 'set' }, { method: 'update' }])(
+			'wrong_property_access_state ($method)',
+			({ method }) => {
+				it(`should add suggestions when using .${method}() on a stateful variable with a literal init`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state(0);
+				const count = ${init}(0);
 				function update_count() {
 					count.${method}(43);
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them.`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them.`,
+					);
+				});
 
-			it(`should add suggestions when using .${method}() on a stateful variable with an array init`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when using .${method}() on a stateful variable with an array init`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state([0]);
+				const count = ${init}([0]);
 				function update_count() {
 					count.${method}([1]);
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them.`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them.`,
+					);
+				});
 
-			it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable ($state({}))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable (${init}({}))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state({ value: 0 });
+				const count = ${init}({ value: 0 });
 				function update_count() {
 					count.${method}({ value: 43 });
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
+					);
+				});
 
-			it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable ($state(new Class()))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable (${init}(new Class()))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state(new Class());
+				const count = ${init}(new Class());
 				function update_count() {
 					count.${method}(new Class());
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
+					);
+				});
 
-			it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable ($state(variable_name))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when using .${method}() on a stateful variable with conditional if it's not sure if the method could actually be present on the variable (${init}(variable_name))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
 				const { init } = $props();
-				const count = $state(init);
+				const count = ${init}(init);
 				function update_count() {
 					count.${method}(43);
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
+					);
+				});
 
-			it(`should not add suggestions when using .${method} on a stateful variable if it's not a method call`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should not add suggestions when using .${method} on a stateful variable if it's not a method call`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state({});
+				const count = ${init}({});
 				function update_count() {
 					console.log(count.${method});
 				}
 			</script>`);
 
-				expect(content.suggestions).not.toContain(
-					`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
-				);
-			});
-		},
-	);
+					expect(content.suggestions).not.toContain(
+						`You are trying to update the stateful variable "count" using "${method}". stateful variables should be updated with a normal assignment/mutation, do not use methods to update them. However I can't verify if "count" is a state variable of an object or a class with a "${method}" method on it. Please verify that before updating the code to use a normal assignment`,
+					);
+				});
+			},
+		);
 
-	describe.each([{ property: '$' }])(
-		'wrong_property_access_state property ($property)',
-		async ({ property }) => {
-			it(`should add suggestions when reading .${property} on a stateful variable with a literal init`, () => {
-				const content = run_autofixers_on_code(`
+		describe.each([{ property: '$' }])(
+			'wrong_property_access_state property ($property)',
+			async ({ property }) => {
+				it(`should add suggestions when reading .${property} on a stateful variable with a literal init`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state(0);
+				const count = ${init}(0);
 				function read_count() {
 					count.${property};
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them.`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them.`,
+					);
+				});
 
-			it(`should add suggestions when reading .${property} on a stateful variable with an array init`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when reading .${property} on a stateful variable with an array init`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state([1]);
+				const count = ${init}([1]);
 				function read_count() {
 					count.${property};
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them.`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them.`,
+					);
+				});
 
-			it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable ($state({}))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable (${init}({}))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state({ value: 0 });
+				const count = ${init}({ value: 0 });
 				function read_count() {
 					count.${property};
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
+					);
+				});
 
-			it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable ($state(new Class()))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable (${init}(new Class()))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
-				const count = $state(new Class());
+				const count = ${init}(new Class());
 				function read_count() {
 					count.${property};
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
-				);
-			});
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
+					);
+				});
 
-			it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable ($state(variable_name))`, () => {
-				const content = run_autofixers_on_code(`
+				it(`should add suggestions when reading .${property} on a stateful variable with conditional if it's not sure if the property could actually be present on the variable (${init}(variable_name))`, () => {
+					const content = run_autofixers_on_code(`
 			<script>
 				const { init } = $props();
-				const count = $state(init);
+				const count = ${init}(init);
 				function read_count() {
 					count.${property};
 				}
 			</script>`);
 
-				expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
-				expect(content.suggestions).toContain(
-					`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
-				);
-			});
-		},
-	);
+					expect(content.suggestions.length).toBeGreaterThanOrEqual(1);
+					expect(content.suggestions).toContain(
+						`You are trying to read the stateful variable "count" using "${property}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them. However I can't verify if "count" is a state variable of an object or a class with a "${property}" property on it. Please verify that before updating the code to use a normal access`,
+					);
+				});
+			},
+		);
+	});
 
 	describe('imported_runes', () => {
 		describe.each([{ source: 'svelte' }, { source: 'svelte/runes' }])(

packages/mcp-server/src/mcp/autofixers/visitors/assign-in-effect.ts

@@ -39,7 +39,7 @@ function visitor(
 				const init = definition.node.init;
 				if (
 					init?.type === 'CallExpression' &&
-					state.parsed.is_rune(init, ['$state', '$state.raw'])
+					state.parsed.is_rune(init, ['$state', '$state.raw', '$derived', '$derived.by'])
 				) {
 					state.output.suggestions.push(
 						`The stateful variable "${id.name}" is assigned inside an $effect which is generally consider a malpractice. Consider using $derived if possible.`,

packages/mcp-server/src/mcp/autofixers/visitors/wrong-property-access-state.ts

@@ -22,7 +22,7 @@ export const wrong_property_access_state: Autofixer = {
 					const init = definition.node.init;
 					if (
 						init?.type === 'CallExpression' &&
-						state.parsed.is_rune(init, ['$state', '$state.raw'])
+						state.parsed.is_rune(init, ['$state', '$state.raw', '$derived', '$derived.by'])
 					) {
 						let suggestion = is_property
 							? `You are trying to read the stateful variable "${id.name}" using "${node.property.name}". stateful variables should be read just by accessing them like normal variable, do not use properties to read them.`

packages/mcp-server/src/mcp/handlers/resources/list-sections.ts

@@ -4,6 +4,7 @@ export function list_sections(server: SvelteMcp) {
 	server.resource(
 		{
 			name: 'list-sections',
+			enabled: () => false,
 			description:
 				'The list of all the available Svelte 5 and SvelteKit documentation sections in a structured format.',
 			uri: 'svelte://list-sections',

packages/mcp-server/src/mcp/handlers/tools/get-documentation.ts

@@ -5,6 +5,7 @@ export function get_documentation(server: SvelteMcp) {
 	server.tool(
 		{
 			name: 'get-documentation',
+			enabled: () => false,
 			description:
 				'Retrieves full documentation content for Svelte 5 or SvelteKit sections. Supports flexible search by title (e.g., "$state", "routing") or file path (e.g., "docs/svelte/state.md"). Can accept a single section name or an array of sections. Before running this, make sure to analyze the users query, as well as the output from list_sections (which should be called first). Then ask for ALL relevant sections the user might require. For example, if the user asks to build anything interactive, you will need to fetch all relevant runes, and so on.',
 			schema: v.object({

packages/mcp-server/src/mcp/handlers/tools/list-sections.ts

@@ -4,6 +4,7 @@ export function list_sections(server: SvelteMcp) {
 	server.tool(
 		{
 			name: 'list-sections',
+			enabled: () => false,
 			description:
 				'Lists all available Svelte 5 and SvelteKit documentation sections in a structured format. Returns sections as a list of "* title: [section_title], path: [file_path]" - you can use either the title or path when querying a specific section via the get_documentation tool. Always run list_sections first for any query related to Svelte development to discover available content.',
 		},

packages/mcp-server/src/mcp/index.ts

@@ -3,6 +3,7 @@ import { McpServer } from 'tmcp';
 import { setup_prompts, setup_resources, setup_tools } from './handlers/index.js';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { Schema } from '@sveltejs/mcp-schema';
+import type { ClassType } from 'remult';
 
 export const server = new McpServer(
 	{
@@ -21,7 +22,7 @@ export const server = new McpServer(
 		instructions:
 			'This is the official Svelte MCP server. It MUST be used whenever svelte development is involved. It can provide official documentation, code examples and correct your code. After you correct the component call this tool again to confirm all the issues are fixed.',
 	},
-).withContext<{ db: LibSQLDatabase<Schema> }>();
+).withContext<{ db: LibSQLDatabase<Schema>; entities: Record<string, ClassType<unknown>> }>();
 
 export type SvelteMcp = typeof server;
 

packages/mcp-stdio/package.json

@@ -29,7 +29,7 @@
 	},
 	"devDependencies": {
 		"@sveltejs/mcp-server": "workspace:^",
-		"@tmcp/transport-stdio": "^0.3.0",
+		"@tmcp/transport-stdio": "^0.3.1",
 		"@types/node": "^22.15.17",
 		"publint": "^0.3.13",
 		"tsdown": "^0.11.9",