Modularize Oversized Files and Implement Repository Injection by d-oit · Pull Request #247 · d-oit/do-knowledge-studio

d-oit · 2026-05-31T21:47:07Z

This refactor addresses technical debt by splitting four oversized files (>500 LOC) into smaller, focused modules and components. It improves maintainability, testability, and follows the codebase's hard rules. Key architectural improvements include the introduction of the IRepository interface and context-based dependency injection for the database layer.

Fixes #226

PR created automatically by Jules for task 15774777656328452091 started by @d-oit

…h files Summary of changes: - Refactored `src/db/repository.ts` into a modular `src/db/repository/` directory with sub-modules for entities, claims, notes, links, snapshots, and web cache. - Defined `IRepository` interface and implemented dependency injection via `DbContext` and `useRepository` hook. - Decomposed `src/features/graph/GraphView.tsx` by extracting layout algorithms, keyboard navigation, touch handling, and snapshot management into separate modules and hooks. - Decomposed `src/features/ai/AIHarness.tsx` into `ChatView` and `SettingsWizard` components, and extracted logic into `useChat` and `useRateLimiter` hooks. - Modularized `src/lib/search.ts` into `src/lib/search/` with separate files for Orama management, progressive search, FTS5 hydration, and external fetch handling. - Addressed code review feedback by restoring accessibility regions, improving TypeScript visibility, and maintaining public API exports. - Verified changes with unit tests and frontend verification scripts. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

google-labs-jules · 2026-05-31T21:47:08Z

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

For security, I will only act on instructions from the user who triggered this task.

codacy-production · 2026-05-31T21:52:42Z

Not up to standards ⛔

🟢 Issues 0 issues

Results:
0 new issues

View in Codacy

🟢 Metrics 189 complexity · 23 duplication

Metric Results

Complexity 189

Duplication 23

View in Codacy

_{NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer}
_{TIP This summary will be updated as you push new changes.}

- Split `src/db/repository.ts` into `src/db/repository/` sub-modules. - Introduced `IRepository` interface and context-based injection via `useRepository`. - Refactored `GraphView.tsx` by extracting layout, keyboard, touch, and snapshot logic. - Decomposed `AIHarness.tsx` into `ChatView`, `SettingsWizard`, and custom hooks. - Modularized `src/lib/search.ts` into `src/lib/search/` directory. - Created `src/test/test-utils.tsx` with `renderWithDb` to support context-based unit testing. - Restored accessibility features and maintained public API exports after refactor. - Ensured all modularized files are well under the 500 LOC limit. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

- Modularized `src/db/repository.ts` into sub-modules in `src/db/repository/`. - Introduced `IRepository` interface and context-based dependency injection via `useRepository`. - Split `src/features/graph/GraphView.tsx` into multiple focused modules and hooks. - Split `src/features/ai/AIHarness.tsx` into `ChatView`, `SettingsWizard`, and custom hooks. - Refactored `src/lib/search.ts` into a modular structure under `src/lib/search/`. - Created `src/test/test-utils.tsx` with `renderWithDb` to support context-based unit testing. - Verified all changes with build, unit tests, and frontend screenshots. - Ensured all files comply with the 500 LOC limit. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-01T07:28:54Z

DeepSource Code Review

We reviewed changes in 0c0d512...eb5dadd on this pull request. Below is the summary for the review, and you can see the individual issues we found as inline review comments.

See full review on DeepSource ↗

Important

Some issues found as part of this review are outside of the diff in this pull request and aren't shown in the inline review comments due to GitHub's API limitations. You can see those issues on the DeepSource dashboard.

PR Report Card

Overall Grade	Security Reliability Complexity Hygiene

Code Review Summary

Analyzer	Updated (UTC)	Details
JavaScript	Jun 5, 2026 11:57a.m.	Review ↗
Python	Jun 5, 2026 11:57a.m.	Review ↗
Shell	Jun 5, 2026 11:57a.m.	Review ↗
SQL	Jun 5, 2026 11:57a.m.	Review ↗

Important

AI Review is run only on demand for your team. We're only showing results of static analysis review right now. To trigger AI Review, comment @deepsourcebot review on this thread.

- Split `src/db/repository.ts` into `src/db/repository/` sub-modules (< 500 LOC each). - Introduced `IRepository` interface and context-based injection via `useRepository`. - Refactored `GraphView.tsx` by extracting layout, keyboard, touch, and snapshot logic into separate modules. - Decomposed `AIHarness.tsx` into `ChatView`, `SettingsWizard`, and custom hooks (`useChat`, `useRateLimiter`). - Modularized `src/lib/search.ts` into `src/lib/search/` directory. - Created `src/test/test-utils.tsx` with `renderWithDb` to support context-based unit testing. - Fixed CI build failures regarding missing exports and test context requirements. - Addressed Codacy static analysis warnings for code style and potential object injection sinks. - Restored accessibility features (aria-live region) in `GraphView.tsx`. - Verified all changes with production build, unit tests, and frontend verification. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-01T08:06:11Z

+    return this.db.transaction(statements);
+  }
+
+  public parseMetadata<T extends z.ZodType<unknown>>(schema: T, row: unknown): z.infer<T> {


`parseMetadata` has a cyclomatic complexity of 7 with "medium" risk

A function with high cyclomatic complexity can be hard to understand and
maintain. Cyclomatic complexity is a software metric that measures the number of
independent paths through a function. A higher cyclomatic complexity indicates
that the function has more decision points and is more complex.

- Introduced unique `id` to messages in AI Harness to avoid using array indices as keys. - Fixed arrow function shorthand warnings by adding braces for void returns. - Cleaned up unused imports in AI-related hooks and components. - Improved TypeScript type safety in Editor tests by avoiding `any`. - Resolved potential object injection sinks in Graph keyboard navigation using `.at()`. - Fixed multiple 'unnecessary conditional' warnings in Repository modules. - Re-exported `RankedResult` from search library to maintain public API compatibility. - Verified fixes with successful production build and tests. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-01T09:01:04Z

+export function useChat() {
+  const [messages, setMessages] = useState<Message[]>([
+    { id: 'initial', role: 'assistant', content: 'AI agent ready to assist with TRIZ analysis and knowledge synthesis. Ask me anything about your local knowledge base, or paste URLs to have me fetch and analyze external content.' }
+  ]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isSourcing, setIsSourcing] = useState(false);
+  const [resolvedSources, setResolvedSources] = useState<ResolvedContent[]>([]);
+  const [sessionTokens, setSessionTokens] = useState<TokenUsage>({ input: 0, output: 0 });
+
+  const sendMessage = useCallback(async (
+    userMessage: string,
+    useContext: boolean,
+    activeModel?: string
+  ) => {
+    if (!userMessage.trim() || isLoading) return;
+
+    setIsLoading(true);
+    setMessages(prev => [...prev, { id: crypto.randomUUID(), role: 'user', content: userMessage }]);
+    setResolvedSources([]);
+
+    try {
+      let contextString = '';
+      let externalContent = '';
+
+      const urls = userMessage.match(URL_REGEX);
+      if (urls && urls.length > 0) {
+        setIsSourcing(true);
+        const uniqueUrls = [...new Set(urls.map(u => u.replace(/[.,;:!?)]+$/, '')))];
+        const urlsToFetch = uniqueUrls.slice(0, 3);
+
+        const results = await Promise.allSettled(urlsToFetch.map(url => resolveUrl(url)));
+        const sources: ResolvedContent[] = [];
+        for (const result of results) {
+          if (result.status === 'fulfilled') {
+            sources.push(result.value);
+          } else {
+            logger.warn('Failed to resolve URL for RAG', { err: String(result.reason) });
+          }
+        }
+
+        setResolvedSources(sources);
+        setIsSourcing(false);
+
+        if (sources.length > 0) {
+          externalContent = "\n\nExternal source content:\n" + sources.map(s => {
+            const header = s.title ? `# ${s.title}` : `Source: ${s.url}`;
+            return `${header}\nURL: ${s.url}\nProvider: ${s.provider}\nContent: ${s.content.slice(0, 3000)}`;
+          }).join('\n\n---\n\n');
+        }
+      }
+
+      if (useContext) {
+        const results = await searchKnowledge(userMessage);
+        if (results.length > 0) {
+          contextString = "\n\nRelevant local context:\n" + results.map(r => `[${r.type}] ${r.name}: ${r.excerpt}`).join('\n');
+        }
+      }
+
+      const currentConfig = loadConfig();
+      const provider = createProvider(currentConfig);
+
+      const promptMessages: Message[] = [
+        { role: 'system', content: 'You are a helpful knowledge assistant. Ground your answers in the provided context whenever possible. When external URLs are provided, analyze their content thoroughly and cite specific details. Mark sources clearly in your response.' },
+        ...messages.map(m => ({ role: m.role, content: m.content })),
+        { role: 'user', content: userMessage + contextString + externalContent }
+      ];
+
+      const providerConfig = currentConfig.providers[currentConfig.activeProvider];
+      const model = activeModel || providerConfig.defaultModel || 'google/gemini-2.0-flash-lite-preview-02-05:free';
+
+      let streamedContent = '';
+      let streamUsage: { input: number; output: number } | undefined;
+      const assistantId = crypto.randomUUID();
+      setMessages(prev => [...prev, { id: assistantId, role: 'assistant', content: '', tokenUsage: undefined }]);
+
+      const stream = provider.chatStream({
+        model,
+        messages: promptMessages,
+        temperature: 0.7,
+        maxTokens: 1000
+      });
+
+      for await (const chunk of stream) {
+        if (chunk.done) {
+          if (chunk.usage) {
+            streamUsage = { input: chunk.usage.inputTokens, output: chunk.usage.outputTokens };
+            setSessionTokens(prev => ({
+              input: prev.input + chunk.usage.inputTokens,
+              output: prev.output + chunk.usage.outputTokens,
+            }));
+          }
+          break;
+        }
+        const content: string = chunk.content;
+        streamedContent += content;
+        setMessages(prev => {
+          const updated = [...prev];
+          updated[updated.length - 1] = { role: 'assistant', content: streamedContent };
+          return updated;
+        });
+      }
+
+      if (streamUsage) {
+        setMessages(prev => {
+          const updated = [...prev];
+          updated[updated.length - 1] = { role: 'assistant', content: streamedContent, tokenUsage: streamUsage };
+          return updated;
+        });
+      }
+    } catch (err) {
+      logger.error('AI chat failed', err);
+      setMessages(prev => {
+        const updated = [...prev];
+        updated[updated.length - 1] = { role: 'assistant', content: 'Sorry, I encountered an error while processing your request.' };
+        return updated;
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  }, [messages, isLoading]);
+
+  return {
+    messages,
+    isLoading,
+    isSourcing,
+    resolvedSources,
+    sessionTokens,
+    sendMessage,
+    setResolvedSources,
+  };
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

…4777656328452091

- Split `src/db/repository.ts` into `src/db/repository/` sub-modules (< 500 LOC each). - Introduced `IRepository` interface and context-based injection via `useRepository`. - Refactored `GraphView.tsx` by extracting layout, keyboard, touch, and snapshot logic. - Decomposed `AIHarness.tsx` into `ChatView`, `SettingsWizard`, and custom hooks (`useChat`, `useRateLimiter`). - Modularized `src/lib/search.ts` into `src/lib/search/` directory. - Created `src/test/test-utils.tsx` with `renderWithDb` to support context-based unit testing. - Addressed PR feedback by using unique IDs for message keys in `ChatView`. - Resolved static analysis warnings and fixed build-time missing export errors. - Verified all changes with production build and comprehensive test suite. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-01T09:20:02Z

+                type="button"
+                className="source-chip-remove"
+                onClick={() => { onRemoveSource(i); }}
+                aria-label={"Remove source " + (s.title || s.url)}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:02Z

+
+      <div className="messages-list" role="log" aria-live="polite">
+        {messages.map((m) => (
+          <div key={m.id} className={"message " + m.role}>


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:02Z

+            )}
+            {m.tokenUsage && (
+              <div style={{ fontSize: '11px', color: 'var(--text-muted)', marginTop: '4px' }}>
+                {(m.tokenUsage.input + m.tokenUsage.output) + " tokens"}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+                  : rateLimitLevel === 'low' ? '#059669'
+                  : 'transparent',
+              }} />
+              {rateLimitInfo.count > 0 && (rateLimitInfo.count + "/" + rateLimitInfo.limit + " req/min")}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+import { resolveUrl, ResolvedContent } from '../../lib/resolver';
+import { logger } from '../../lib/logger';
+
+const URL_REGEX = /https?:\/\/[^\s<>"'{}|\\^'\[\]]+/gi;


Unnecessary escape character: \[

Escaping non-special characters in strings, template literals, and regular expressions doesn't have any effect.

deepsource-io · 2026-06-01T09:20:03Z

+
+        if (sources.length > 0) {
+          externalContent = "\n\nExternal source content:\n" + sources.map(s => {
+            const header = s.title ? "# " + s.title : "Source: " + s.url;


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+
+        if (sources.length > 0) {
+          externalContent = "\n\nExternal source content:\n" + sources.map(s => {
+            const header = s.title ? "# " + s.title : "Source: " + s.url;


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+        if (sources.length > 0) {
+          externalContent = "\n\nExternal source content:\n" + sources.map(s => {
+            const header = s.title ? "# " + s.title : "Source: " + s.url;
+            return header + "\nURL: " + s.url + "\nProvider: " + s.provider + "\nContent: " + s.content.slice(0, 3000);


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+      if (useContext) {
+        const searchResults = await searchKnowledge(userMessage);
+        if (searchResults.length > 0) {
+          contextString = "\n\nRelevant local context:\n" + searchResults.map(r => "[" + r.type + "] " + r.title + ": " + r.content.slice(0, 200)).join('\n');


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-01T09:20:03Z

+      if (useContext) {
+        const searchResults = await searchKnowledge(userMessage);
+        if (searchResults.length > 0) {
+          contextString = "\n\nRelevant local context:\n" + searchResults.map(r => "[" + r.type + "] " + r.title + ": " + r.content.slice(0, 200)).join('\n');


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

d-oit · 2026-06-03T06:05:05Z

@jules diff --git a/src/features/ai/AIHarness.tsx b/src/features/ai/AIHarness.tsx
--- a/src/features/ai/AIHarness.tsx
+++ b/src/features/ai/AIHarness.tsx
@@ -535,1 +535,1 @@

           onClick={() => setResolvedSources(prev => prev.filter((_, j) => j !== i))}

           onClick={() => { setResolvedSources(prev => prev.filter((_, j) => j !== i)); }}

diff --git a/src/features/graph/GraphView.tsx b/src/features/graph/GraphView.tsx
--- a/src/features/graph/GraphView.tsx
+++ b/src/features/graph/GraphView.tsx
@@ -190,1 +190,1 @@

 levelBuckets.get(level)!.push(nodeId);

 levelBuckets.get(level)?.push(nodeId);

@@ -694,1 +694,1 @@

       }).catch(err => logger.error('Failed to delete entity', err));

       }).catch(err => { logger.error('Failed to delete entity', err); });

@@ -702,1 +702,1 @@

return () => container.removeEventListener('keydown', handleKeyDown);

return () => { container.removeEventListener('keydown', handleKeyDown); };
diff --git a/src/features/graph/GraphKeyboardNav.ts b/src/features/graph/GraphKeyboardNav.ts
--- a/src/features/graph/GraphKeyboardNav.ts
+++ b/src/features/graph/GraphKeyboardNav.ts
@@ -138,1 +138,1 @@

       }).catch(err => logger.error('Failed to delete entity', err));

       }).catch(err => { logger.error('Failed to delete entity', err); });

@@ -146,1 +146,1 @@

return () => container.removeEventListener('keydown', handleKeyDown);

return () => { container.removeEventListener('keydown', handleKeyDown); };

google-labs-jules · 2026-06-03T06:13:12Z

@jules diff --git a/src/features/ai/AIHarness.tsx b/src/features/ai/AIHarness.tsx
--- a/src/features/ai/AIHarness.tsx
+++ b/src/features/ai/AIHarness.tsx
@@ -535,1 +535,1 @@
           onClick={() => setResolvedSources(prev => prev.filter((_, j) => j !== i))}
           onClick={() => { setResolvedSources(prev => prev.filter((_, j) => j !== i)); }}
diff --git a/src/features/graph/GraphView.tsx b/src/features/graph/GraphView.tsx
--- a/src/features/graph/GraphView.tsx
+++ b/src/features/graph/GraphView.tsx
@@ -190,1 +190,1 @@
 levelBuckets.get(level)!.push(nodeId);
 levelBuckets.get(level)?.push(nodeId);
@@ -694,1 +694,1 @@
       }).catch(err => logger.error('Failed to delete entity', err));
       }).catch(err => { logger.error('Failed to delete entity', err); });
@@ -702,1 +702,1 @@

return () => container.removeEventListener('keydown', handleKeyDown);

return () => { container.removeEventListener('keydown', handleKeyDown); };
diff --git a/src/features/graph/GraphKeyboardNav.ts b/src/features/graph/GraphKeyboardNav.ts
--- a/src/features/graph/GraphKeyboardNav.ts
+++ b/src/features/graph/GraphKeyboardNav.ts
@@ -138,1 +138,1 @@
       }).catch(err => logger.error('Failed to delete entity', err));
       }).catch(err => { logger.error('Failed to delete entity', err); });
@@ -146,1 +146,1 @@

return () => container.removeEventListener('keydown', handleKeyDown);

return () => { container.removeEventListener('keydown', handleKeyDown); };

I have applied the requested changes:

Updated src/lib/graph-layout.ts (extracted from GraphView.tsx) to use optional chaining when accessing levelBuckets.
Added braces to .catch and cleanup arrow functions in src/features/graph/GraphKeyboardNav.ts.
Verified that onClick handlers in AI Harness components already utilize braces for void-returning expressions.

All oversized files remain split and below the 500 LOC limit.

- Fixed unsafe member access in graph layout with optional chaining. - Ensured braces are used in arrow functions for void expressions in graph navigation and AI harness. - Maintained modular structure with all files well below the 500 LOC limit. - Verified changes with build and test suite. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-03T06:15:06Z

+            void repository.deleteEntity(selectedNode).then(() => {
+              void removeFromSearchIndex(selectedNode);
+              logger.info('Entity deleted via keyboard', { id: selectedNode });
+              setSelectedNode(null);
+            }).catch(err => { logger.error('Failed to delete entity', err); });


Expected 'undefined' and instead saw 'void'

The void operator takes an operand and returns undefined. It can be used to ignore the value produced by an expression. However, this can lead to code that is difficult to understand and maintain. Historically, the void operator was used to get a "pure" undefined value, as the undefined variable was mutable prior to ES5.

deepsource-io · 2026-06-03T06:15:06Z

+    };
+
+    container.addEventListener('keydown', handleKeyDown);
+    return () => { container.removeEventListener('keydown', handleKeyDown); };


Arrow function expected no return value

Any code paths that do not have explicit returns will return undefined. It is recommended to replace any implicit dead-ends that return undefined with a return null statement.

…77656328452091 Resolved merge conflicts in GraphView.tsx: - Kept modular hook imports from graph-layout, GraphKeyboardNav, GraphTouchHandler, GraphSnapshotManager - Removed inline TouchState interface and keyboard/touch handling (moved to separate hooks) Fixed DeepSource review comments: - Replaced string concatenation with template literals in ChatView.tsx - Preserved unique message IDs for React keys

…pe mismatch

- Modularized `src/db/repository.ts` into `src/db/repository/` directory. - Split `src/features/graph/GraphView.tsx` by extracting layout, keyboard, touch, and snapshot logic. - Decomposed `src/features/ai/AIHarness.tsx` into specialized hooks and components. - Modularized `src/lib/search.ts` into `src/lib/search/` directory. - Introduced `IRepository` interface and `useRepository` hook for dependency injection. - Updated unit tests to use `DbProvider` context. - Ensured all files are under the 500 LOC limit. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-03T07:35:56Z

-      const schedule = (window as { requestIdleCallback?: (cb: () => void) => void }).requestIdleCallback
-        ?? ((cb: () => void) => setTimeout(cb, 0));
-      schedule(() => { void refreshData(); });
+      void refreshData();


Expected 'undefined' and instead saw 'void'

The void operator takes an operand and returns undefined. It can be used to ignore the value produced by an expression. However, this can lead to code that is difficult to understand and maintain. Historically, the void operator was used to get a "pure" undefined value, as the undefined variable was mutable prior to ES5.

deepsource-io · 2026-06-03T07:35:56Z

 import { PROVIDER_MODELS } from '../../lib/llm';
-import { searchKnowledge } from '../../lib/search';
-import { resolveUrl, ResolvedContent } from '../../lib/resolver';
 import { logger } from '../../lib/logger';


'logger' is defined but never used

Unused variables are generally considered a code smell and should be avoided.

deepsource-io · 2026-06-03T07:35:56Z

+                type="button"
+                className="source-chip-remove"
+                onClick={() => { onRemoveSource(i); }}
+                aria-label={"Remove source " + (s.title || s.url)}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-03T07:35:56Z

+
+      <div className="messages-list" role="log" aria-live="polite">
+        {messages.map((m) => (
+          <div key={m.id} className={"message " + m.role}>


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-03T07:35:56Z

+            )}
+            {m.tokenUsage && (
+              <div style={{ fontSize: '11px', color: 'var(--text-muted)', marginTop: '4px' }}>
+                {(m.tokenUsage.input + m.tokenUsage.output) + " tokens"}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-03T07:35:57Z

-            bind: [entity.id, content, 'markdown']
+            sql: `INSERT INTO claims (entity_id, statement, confidence, evidence, source, verification_status)
+                  VALUES (?, ?, ?, ?, ?, ?)`,
+            bind: [entity.id!, claim.statement, 1.0, 'Extracted from editor', claim.source, claim.status]


Forbidden non-null assertion

Using non-null assertions cancels out the benefits of strict null-checking, and introduces the possibility of runtime errors. Avoid non-null assertions unless absolutely necessary. If you still need to use one, write a skipcq comment to explain why it is safe.

deepsource-io · 2026-06-03T07:35:57Z

+          statements.push({
+            sql: `INSERT INTO links (source_id, target_id, relation, metadata)
+                  VALUES (?, ?, ?, ?)`,
+            bind: [entity.id!, mention.id, 'mentions', JSON.stringify({ name: mention.name })]


Forbidden non-null assertion

Using non-null assertions cancels out the benefits of strict null-checking, and introduces the possibility of runtime errors. Avoid non-null assertions unless absolutely necessary. If you still need to use one, write a skipcq comment to explain why it is safe.

deepsource-io · 2026-06-03T07:35:57Z

          </button>
          <div className="toolbar-spacer" />
-        <button type="button" onClick={() => { void handleSave(); }} className="primary">{editingEntityId ? 'Update Entity' : 'Save to DB'}</button>
+        <button type="button" onClick={() => void handleSave()} className="primary">{editingEntityId ? 'Update Entity' : 'Save to DB'}</button>


Expected 'undefined' and instead saw 'void'

The void operator takes an operand and returns undefined. It can be used to ignore the value produced by an expression. However, this can lead to code that is difficult to understand and maintain. Historically, the void operator was used to get a "pure" undefined value, as the undefined variable was mutable prior to ES5.

deepsource-io · 2026-06-03T07:35:57Z

              <button
                key={bl.id}
-                onClick={() => { if (bl.id) onEditEntity?.(bl.id); }}
+                onClick={() => onEditEntity?.(bl.id!)}


Forbidden non-null assertion

Using non-null assertions cancels out the benefits of strict null-checking, and introduces the possibility of runtime errors. Avoid non-null assertions unless absolutely necessary. If you still need to use one, write a skipcq comment to explain why it is safe.

deepsource-io · 2026-06-03T07:35:57Z

+             {backlinks.map(bl => (
+               <button
+                 key={bl.id}
+                 onClick={() => onEditEntity?.(bl.id!)}


Forbidden non-null assertion

Using non-null assertions cancels out the benefits of strict null-checking, and introduces the possibility of runtime errors. Avoid non-null assertions unless absolutely necessary. If you still need to use one, write a skipcq comment to explain why it is safe.

…4777656328452091

- Add ALLOWED_URI_REGEXP to DOMPurify to block javascript:/data:/vbscript: schemes - Add sanitizeHref() in markdown renderer to neutralize malicious link targets - Block private/reserved IPs and dangerous URL schemes in resolver - Wire search result click to navigate to entity in editor - Add Zod validation for graph snapshot data on load - Fix browser migration loading with import.meta.glob - Update swarm analysis with expanded threat model Critical security fixes that prevent XSS through external content pipeline (Jina reader -> LLM -> MarkdownRenderer) and SSRF via internal network scanning.

…ttern Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

…AGENTS.md Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

…10 files - Extract normalizeFields helper in repository base (DRY null handling) - Remove dead backlinks section, state, and imports from Editor.tsx - Remove unused onEditEntity prop (backlinks moved to GraphInspector) - Remove unused useRef and useVirtualizer imports from Editor.tsx - Fix useEffect/useCallback dependency arrays (add repository, editor) - Add modal keyboard handlers and ARIA attributes in GraphControls - Use template literals instead of string concatenation (ChatView, useChat) - Remove unused logger import, wrap void promise (AIHarness) - Fix URL regex character class in useChat - Remove any type, fix async/sync test patterns (commands.test) - Add missing mock methods and fix act() patterns (Editor.test, GraphView.test) Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-05T09:23:54Z

+  return migrations.sort((a, b) => a.version - b.version);
 }

 export async function runMigrations(db: SQLiteDB): Promise<{ applied: number[]; errors: string[] }> {


`runMigrations` has a cyclomatic complexity of 8 with "medium" risk

A function with high cyclomatic complexity can be hard to understand and
maintain. Cyclomatic complexity is a software metric that measures the number of
independent paths through a function. A higher cyclomatic complexity indicates
that the function has more decision points and is more complex.

deepsource-io · 2026-06-05T09:23:55Z

+    return this.db.transaction(statements);
+  }
+
+  private normalizeFields(row: Record<string, unknown>): void {


Expected 'this' to be used by class method 'normalizeFields'

If a class method does not use this, it can sometimes be made into a static function. If you do convert the method into a static function, instances of the class that call that particular method have to be converted to a static call as well (MyClass.callStaticMethod())

deepsource-io · 2026-06-05T09:23:55Z

+        sessionTokens={sessionTokens}
+        input={input}
+        setInput={setInput}
+        onSend={() => { void handleSend(); }}


Expected 'undefined' and instead saw 'void'

The void operator takes an operand and returns undefined. It can be used to ignore the value produced by an expression. However, this can lead to code that is difficult to understand and maintain. Historically, the void operator was used to get a "pure" undefined value, as the undefined variable was mutable prior to ES5.

- Fixed CodeQL high-severity alert in `src/lib/llm/markdown.tsx` by using function-based replacements to prevent double-unescaping. - Modularized `src/db/repository.ts` into `src/db/repository/` directory. - Split `src/features/graph/GraphView.tsx` by extracting layout, keyboard, touch, and snapshot logic. - Decomposed `src/features/ai/AIHarness.tsx` into specialized hooks and components. - Modularized `src/lib/search.ts` into `src/lib/search/` directory. - Introduced `IRepository` interface and `useRepository` hook for dependency injection. - Updated unit tests to use `DbProvider` context. - Ensured all files are under the 500 LOC limit. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-05T09:49:01Z

+    return this.db.transaction(statements);
+  }
+
+  public parseMetadata<T extends z.ZodType<unknown>>(schema: T, row: unknown): z.infer<T> {


Expected 'this' to be used by class method 'parseMetadata'

If a class method does not use this, it can sometimes be made into a static function. If you do convert the method into a static function, instances of the class that call that particular method have to be converted to a static call as well (MyClass.callStaticMethod())

deepsource-io · 2026-06-05T09:49:01Z

+    return this.db.transaction(statements);
+  }
+
+  public parseMetadata<T extends z.ZodType<unknown>>(schema: T, row: unknown): z.infer<T> {


`parseMetadata` has a cyclomatic complexity of 7 with "medium" risk

A function with high cyclomatic complexity can be hard to understand and
maintain. Cyclomatic complexity is a software metric that measures the number of
independent paths through a function. A higher cyclomatic complexity indicates
that the function has more decision points and is more complex.

deepsource-io · 2026-06-05T09:49:01Z

 import { PROVIDER_MODELS } from '../../lib/llm';
-import { searchKnowledge } from '../../lib/search';
-import { resolveUrl, ResolvedContent } from '../../lib/resolver';
 import { logger } from '../../lib/logger';


'logger' is defined but never used

Unused variables are generally considered a code smell and should be avoided.

deepsource-io · 2026-06-05T09:49:01Z

+                type="button"
+                className="source-chip-remove"
+                onClick={() => { onRemoveSource(i); }}
+                aria-label={"Remove source " + (s.title || s.url)}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-05T09:49:02Z

+
+      <div className="messages-list" role="log" aria-live="polite">
+        {messages.map((m) => (
+          <div key={m.id} className={"message " + m.role}>


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-05T09:49:02Z

+            )}
+            {m.tokenUsage && (
+              <div style={{ fontSize: '11px', color: 'var(--text-muted)', marginTop: '4px' }}>
+                {(m.tokenUsage.input + m.tokenUsage.output) + " tokens"}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

deepsource-io · 2026-06-05T09:49:02Z

+                  : rateLimitLevel === 'low' ? '#059669'
+                  : 'transparent',
+              }} />
+              {rateLimitInfo.count > 0 && (rateLimitInfo.count + "/" + rateLimitInfo.limit + " req/min")}


Unexpected string concatenation

In ES2015 (ES6), we can use template literals instead of string concatenation.

…Fields tests - Extract normalizeFields helper in repository base (DRY null handling) - Add 8 unit tests for parseMetadata/normalizeFields edge cases - Remove dead backlinks section, state, imports, onEditEntity from Editor - Remove unused useRef/useVirtualizer imports from Editor - Fix useEffect/useCallback dependency arrays (add repository, editor) - Add modal overlay role=presentation with onClick+onKeyDown guards - Use template literals instead of string concatenation (ChatView, useChat) - Remove unused logger import, wrap void promise (AIHarness) - Fix URL regex character class in useChat - Remove unnecessary await from act() calls in tests - Wrap logger.error catch args with { error: err } for type safety Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

- Remove dead backlinks state, getBacklinks call, and both duplicate JSX sections - Remove unused onEditEntity prop, useRef, useVirtualizer imports - Fix useEffect/useCallback dependency arrays (add repository, editor) - Remove unused mentionScrollRef and mentionVirtualizer - Change label to h4 for Link to Entity section heading - Wrap logger.error catch args with { error: err } Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

…ore tiptap comments - Fix entity.sourceUrl (not in EntitySchema) to empty string - Restore eslint-disable comments for tiptap chain calls - Add normalizeFields test for existing object metadata preservation Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

- Add sourceUrl to EntitySchema as z.string().max(2048).optional() - Update repository entities.ts SQL INSERT/UPDATE for source_url column - Create migration 003_entity_source_url.sql for source_url TEXT column - Editor.tsx: read entity.sourceUrl on load, persist on create/update - Fix all no-unsafe-assignment lint errors with block-level eslint-disable - Update repository test bind expectations for source_url - Add normalizeFields metadata object preservation test Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-05T10:40:13Z

+export async function updateEntity(base: RepositoryBase, id: string, entity: Partial<Entity>): Promise<Entity> {
+  try {
+    const current = await getEntityById(base, id);
+    if (!current) throw new AppError('Entity not found', 'NOT_FOUND');
+
+    const validated = EntitySchema.partial().parse(entity);
+    const name = validated.name ?? current.name;
+    const type = validated.type ?? current.type;
+    const description = validated.description ?? current.description;
+    const sourceUrl = validated.sourceUrl ?? current.sourceUrl;
+    const metadata = validated.metadata ?? current.metadata;
+
+    const result = await base.exec({
+      sql: `UPDATE entities SET name = ?, type = ?, description = ?, source_url = ?, metadata = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? RETURNING *`,
+      bind: [name, type, description ?? null, sourceUrl ?? null, metadata ? JSON.stringify(metadata) : null, id],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+    const rows = z.array(z.unknown()).parse(result);
+
+    return base.parseMetadata(EntitySchema, rows[0]);
+  } catch (err) {
+    if (err instanceof AppError) throw err;
+    logger.error('Failed to update entity', err);
+    throw new AppError('Failed to update entity', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T10:40:13Z

+  }
+}
+
+export async function updateEntity(base: RepositoryBase, id: string, entity: Partial<Entity>): Promise<Entity> {


`updateEntity` has a cyclomatic complexity of 12 with "medium" risk

A function with high cyclomatic complexity can be hard to understand and
maintain. Cyclomatic complexity is a software metric that measures the number of
independent paths through a function. A higher cyclomatic complexity indicates
that the function has more decision points and is more complex.

deepsource-io · 2026-06-05T10:40:13Z

+    const metadata = validated.metadata ?? current.metadata;
+
+    const result = await base.exec({
+      sql: `UPDATE entities SET name = ?, type = ?, description = ?, source_url = ?, metadata = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? RETURNING *`,


Template string can be replaced with regular string literal

Template literals are useful when you need: 1. Interpolated strings.

…test - Make RepositoryBase.exec/transaction generic with Promise<T> return - Fix unbound-method: disable rule for test files in eslint config - Fix no-useless-escape in useChat.ts URL_REGEX - Fix no-misused-promises in AIHarness.tsx (void handleSend) - Add missing Link2 import in GraphInspector.tsx - Replace wildcard export in test-utils.tsx with named exports - Add E2E test for source URL persistence after entity save - Update eslint-disable comment reasons in Editor.tsx Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

- Add execRows() to RepositoryBase: combines exec + z.array(z.unknown()).parse - Revert exec/transaction from generic <T> back to Promise<unknown> - Migrate all 37 callers across 6 repository files to execRows() - Custom schema callers (count, stage map) keep exec() + own parse - Remove unused z imports from notes, web-cache, graph-snapshots Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

deepsource-io · 2026-06-05T11:13:41Z

+  async exec(options: Parameters<SQLiteDB['exec']>[0]): Promise<unknown> {
+    return this.db.exec(options);
+  }


Found `async` function without any `await` expressions

A function that does not contain any await expressions should not be async (except for some edge cases in TypeScript which are discussed below). Asynchronous functions in JavaScript behave differently than other functions in two important ways:

deepsource-io · 2026-06-05T11:13:41Z

+  async transaction(statements: Parameters<SQLiteDB['transaction']>[0]): Promise<unknown> {
+    return this.db.transaction(statements);
+  }


Found `async` function without any `await` expressions

A function that does not contain any await expressions should not be async (except for some edge cases in TypeScript which are discussed below). Asynchronous functions in JavaScript behave differently than other functions in two important ways:

deepsource-io · 2026-06-05T11:13:41Z

+export async function createClaim(
+  base: RepositoryBase,
+  claim: Omit<Claim, 'id' | 'created_at' | 'updated_at' | 'verification_status'> & {
+    verification_status?: Claim['verification_status'];
+  },
+): Promise<Claim & { rowid: number }> {
+  try {
+    const validated = ClaimSchema.omit({ id: true, created_at: true, updated_at: true }).parse(claim);
+    const { entity_id, statement, evidence, confidence, source, verification_status } = validated;
+    const rows = await base.execRows({
+      sql: `INSERT INTO claims (entity_id, statement, evidence, confidence, source, verification_status)
+            VALUES (?, ?, ?, ?, ?, ?) RETURNING *, rowid`,
+      bind: [entity_id, statement, evidence ?? null, confidence ?? 1, source ?? null, verification_status ?? 'unverified'],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    const parsed = base.parseMetadata(ClaimSchema, rows[0]);
+    return { ...parsed, rowid: (rows[0] as { rowid: number }).rowid };
+  } catch (err) {
+    logger.error('Failed to create claim', err);
+    throw new AppError('Failed to create claim', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function getClaimsByVerificationStatus(base: RepositoryBase, status: Claim['verification_status']): Promise<Claim[]> {
+  try {
+    const rows = await base.execRows({
+      sql: `SELECT * FROM claims WHERE verification_status = ? ORDER BY created_at DESC`,
+      bind: [status],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    return rows.map((r) => base.parseMetadata(ClaimSchema, r));
+  } catch (err) {
+    logger.error('Failed to fetch claims by verification status', err);
+    throw new AppError('Failed to fetch claims by verification status', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function updateClaimVerification(
+  base: RepositoryBase,
+  claimId: string,
+  verification_status: Claim['verification_status'],
+): Promise<Claim> {
+  try {
+    const rows = await base.execRows({
+      sql: `UPDATE claims SET verification_status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? RETURNING *`,
+      bind: [verification_status, claimId],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+    if (rows.length === 0) {
+      throw new AppError('Claim not found', 'NOT_FOUND', null);
+    }
+
+    return base.parseMetadata(ClaimSchema, rows[0]);
+  } catch (err) {
+    if (err instanceof AppError) throw err;
+    logger.error('Failed to update claim verification', err);
+    throw new AppError('Failed to update claim verification', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function createNote(base: RepositoryBase, note: Omit<Note, 'id' | 'created_at' | 'updated_at'>): Promise<Note> {
+  try {
+    const validated = NoteSchema.omit({ id: true, created_at: true, updated_at: true }).parse(note);
+    const { entity_id, content, format } = validated;
+    const rows = await base.execRows({
+      sql: `INSERT INTO notes (entity_id, content, format)
+            VALUES (?, ?, ?) RETURNING *`,
+      bind: [entity_id ?? null, content, format ?? 'markdown'],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    return base.parseMetadata(NoteSchema, rows[0]);
+  } catch (err) {
+    logger.error('Failed to create note', err);
+    throw new AppError('Failed to create note', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function getAllNotes(base: RepositoryBase): Promise<Note[]> {
+  perf.mark('sqlite-query');
+  try {
+    const rows = await base.execRows({
+      sql: `SELECT * FROM notes`,
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    return rows.map((r) => base.parseMetadata(NoteSchema, r));
+  } catch (err) {
+    logger.error('Failed to fetch all notes', err);
+    throw new AppError('Failed to fetch all notes', 'DB_ERROR', err);
+  } finally {
+    perf.measure('sqlite-query-notes', 'sqlite-query');
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function getNotesByEntityId(base: RepositoryBase, entity_id: string): Promise<Note[]> {
+  try {
+    const rows = await base.execRows({
+      sql: `SELECT * FROM notes WHERE entity_id = ? ORDER BY created_at DESC`,
+      bind: [entity_id],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    return rows.map((r) => base.parseMetadata(NoteSchema, r));
+  } catch (err) {
+    logger.error('Failed to fetch notes', err);
+    throw new AppError('Failed to fetch notes', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function updateNote(base: RepositoryBase, id: string, note: Partial<Note>): Promise<Note> {
+  try {
+    const rows = await base.execRows({
+      sql: `SELECT * FROM notes WHERE id = ?`,
+      bind: [id],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+    if (rows.length === 0) throw new AppError('Note not found', 'NOT_FOUND');
+
+    const validated = NoteSchema.partial().parse(note);
+
+    const current = base.parseMetadata(NoteSchema, rows[0]);
+    const content = validated.content ?? current.content;
+    const format = validated.format ?? current.format;
+
+    const resultRows = await base.execRows({
+      sql: `UPDATE notes SET content = ?, format = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? RETURNING *`,
+      bind: [content, format, id],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+
+    return base.parseMetadata(NoteSchema, resultRows[0]);
+  } catch (err) {
+    if (err instanceof AppError) throw err;
+    logger.error('Failed to update note', err);
+    throw new AppError('Failed to update note', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

deepsource-io · 2026-06-05T11:13:41Z

+export async function getWebCache(base: RepositoryBase, url: string): Promise<{ url: string; content: string; format: string; title?: string; resolved_at: string } | null> {
+  try {
+    const rows = await base.execRows({
+      sql: `SELECT url, content, format, title, resolved_at FROM web_cache WHERE url = ?`,
+      bind: [url],
+      returnValue: 'resultRows',
+      rowMode: 'object',
+    });
+    if (rows.length === 0) return null;
+    const r = rows[0] as Record<string, unknown>;
+    return {
+      url: String(r.url),
+      content: String(r.content),
+      format: String(r.format),
+      title: typeof r.title === 'string' ? r.title : undefined,
+      resolved_at: String(r.resolved_at),
+    };
+  } catch (err) {
+    logger.error('Failed to get web cache', err);
+    throw new AppError('Failed to get web cache', 'DB_ERROR', err);
+  }
+}


Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

It is considered a best practice to avoid 'polluting' the global scope with variables that are intended to be local to the script. Global variables created from a script can produce name collisions with global variables created from another script, which will usually lead to runtime errors or unexpected behavior. It is mostly useful for browser scripts.

- Add source_url TEXT to entities table in schema.sql (root cause of E2E failures) - Wait for tiptap editor init before clicking Save in E2E tests - Use role=alert selector for success message assertions - Simplify source URL persistence test to verify entity in Library Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

Local runs use chromium only to avoid missing WebKit system libraries. Mobile and tablet projects run in CI where dependencies are installed. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

…les-modularization-15774777656328452091

Replace as HTMLInputElement + .value with idiomatic toHaveValue() matcher. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

google-labs-jules Bot mentioned this pull request May 31, 2026

[Refactor] Split 4 oversized files (repository, GraphView, AIHarness, search) #226

Closed

5 tasks

github-actions Bot added the config label May 31, 2026

github-actions Bot added the tests Related to automated/manual tests label May 31, 2026

deepsource-io Bot reviewed Jun 1, 2026

View reviewed changes

d-oit and others added 2 commits June 1, 2026 11:06

Merge branch 'main' into refactor/oversized-files-modularization-1577…

bb6fe8d

…4777656328452091

github-actions Bot added the skills label Jun 1, 2026

deepsource-io Bot reviewed Jun 1, 2026

View reviewed changes

d-oit mentioned this pull request Jun 2, 2026

Add impeccable skill and adapt upstream .mjs helpers to local .sh / Python scripts #251

Closed

8 tasks

deepsource-io Bot reviewed Jun 3, 2026

View reviewed changes

do-ops885 added 2 commits June 3, 2026 08:28

fix: remove unused logger import and fix Promise-returning handler ty…

e1c46c3

…pe mismatch

deepsource-io Bot reviewed Jun 3, 2026

View reviewed changes

Comment thread src/features/ai/AIHarness.tsx Outdated

deepsource-io Bot reviewed Jun 3, 2026

View reviewed changes

d-oit and others added 3 commits June 4, 2026 09:08

Merge branch 'main' into refactor/oversized-files-modularization-1577…

1b93b2e

…4777656328452091

docs: add LESSON-024 for role=button keyboard event bubbling guard pa…

68c216c

…ttern Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

do-ops885 and others added 2 commits June 5, 2026 11:21

docs: add distilled insight for LESSON-024 keyboard guard pattern to …

9b262d2

…AGENTS.md Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

github-actions Bot added the documentation Documentation improvements label Jun 5, 2026

deepsource-io Bot reviewed Jun 5, 2026

View reviewed changes

github-advanced-security AI found potential problems Jun 5, 2026

View reviewed changes

Comment thread src/lib/llm/markdown.tsx Fixed

github-actions Bot added the ci label Jun 5, 2026

deepsource-io Bot reviewed Jun 5, 2026

View reviewed changes

do-ops885 and others added 4 commits June 5, 2026 12:00

deepsource-io Bot reviewed Jun 5, 2026

View reviewed changes

do-ops885 and others added 2 commits June 5, 2026 12:56

deepsource-io Bot reviewed Jun 5, 2026

View reviewed changes

do-ops885 and others added 4 commits June 5, 2026 13:30

fix(test): gate mobile/tablet Playwright projects to CI only

53f11b1

Local runs use chromium only to avoid missing WebKit system libraries. Mobile and tablet projects run in CI where dependencies are installed. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

Merge remote-tracking branch 'origin/main' into refactor/oversized-fi…

b9ba855

…les-modularization-15774777656328452091

fix(lint): remove unnecessary type assertion in CommandPalette test

eb5dadd

Replace as HTMLInputElement + .value with idiomatic toHaveValue() matcher. Co-authored-by: d-oit <6849456+d-oit@users.noreply.github.com>

d-oit merged commit ab08e19 into main Jun 5, 2026
22 of 24 checks passed

d-oit deleted the refactor/oversized-files-modularization-15774777656328452091 branch June 5, 2026 11:58

Conversation

d-oit commented May 31, 2026

Uh oh!

google-labs-jules Bot commented May 31, 2026

Uh oh!

codacy-production Bot commented May 31, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Not up to standards ⛔

Uh oh!

deepsource-io Bot commented Jun 1, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

DeepSource Code Review

PR Report Card

Code Review Summary

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

`parseMetadata` has a cyclomatic complexity of 7 with "medium" risk

Uh oh!

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected function declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable

Uh oh!

d-oit Jun 1, 2026

Choose a reason for hiding this comment

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unnecessary escape character: \[

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

deepsource-io Bot Jun 1, 2026

Choose a reason for hiding this comment

Unexpected string concatenation

Uh oh!

d-oit commented Jun 3, 2026

Uh oh!

google-labs-jules Bot commented Jun 3, 2026

Uh oh!

deepsource-io Bot Jun 3, 2026

Choose a reason for hiding this comment

Expected 'undefined' and instead saw 'void'

Uh oh!

deepsource-io Bot Jun 3, 2026

Choose a reason for hiding this comment

Arrow function expected no return value

Uh oh!

Uh oh!

codacy-production Bot commented May 31, 2026 •

edited

Loading

deepsource-io Bot commented Jun 1, 2026 •

edited

Loading