memorix 1.2.3 → 1.2.5

package/src/cli/commands/context.ts

@@ -22,11 +22,16 @@ export default defineCommand({
   },
   args: {
     task: { type: 'string', description: 'Current task for context shaping' },
+    input: { type: 'positional', description: 'Current task for context shaping (ergonomic positional form)' },
+    resume: { type: 'boolean', description: 'Always include the bounded prior-work projection' },
     refresh: { type: 'string', description: 'Project scan policy: auto, always, or never' },
     json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
   },
   run: async ({ args }) => {
     const asJson = !!args.json;
+    const task = (args.task as string | undefined)?.trim()
+      || (args.input as string | undefined)?.trim()
+      || undefined;
 
     try {
       const { project, dataDir, reader } = await getCliProjectContext();
@@ -34,8 +39,10 @@ export default defineCommand({
         project,
         dataDir,
         observations: filterReadableObservations(getAllObservations(), reader),
-        task: args.task as string | undefined,
+        task,
         refresh: coerceRefreshMode(args.refresh as string | undefined),
+        reader,
+        ...(args.resume ? { continuation: 'always' as const } : {}),
       });
 
       emitResult(
@@ -49,6 +56,7 @@ export default defineCommand({
           providerQuality: context.providerQuality,
           workset: context.workset,
           ...(context.task ? { task: context.task } : {}),
+          ...(context.continuation ? { continuation: context.continuation } : {}),
         },
         formatAutoProjectContextPrompt(context),
         asJson,

package/src/cli/commands/memory.ts

@@ -7,8 +7,10 @@ import { canManageObservation, filterReadableObservations, resolveObservationVis
 import {
   coerceObservationStatus,
   coerceObservationType,
+  coerceRetrievalQuality,
   emitError,
   emitResult,
+  getCliReadContext,
   getCliProjectContext,
   parseCsvList,
   parsePositiveInt,
@@ -36,6 +38,7 @@ export default defineCommand({
     topicKey: { type: 'string', description: 'Stable topic key override' },
     action: { type: 'string', description: 'Secondary action for advanced memory commands' },
     limit: { type: 'string', description: 'Limit for search/recent output' },
+    quality: { type: 'string', description: 'Retrieval profile: fast, balanced (default), or thorough' },
     graphLimit: { type: 'string', description: 'Limit for graph-context output' },
     graphQuery: { type: 'string', description: 'Query for graph-context packet' },
     format: { type: 'string', description: 'Output format for graph-context: summary or prompt' },
@@ -56,7 +59,12 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, dataDir, reader, identity } = await getCliProjectContext({ searchIndex: true });
+      const readOnlyActions = new Set(['', 'search', 'graph-context', 'recent', 'suggest-topic-key', 'detail', 'timeline']);
+      const needsSearchIndex = action === 'search' || action === 'detail' || action === 'timeline';
+      const context = readOnlyActions.has(action)
+        ? await getCliReadContext({ searchIndex: needsSearchIndex })
+        : await getCliProjectContext({ searchIndex: true });
+      const { project, dataDir, reader, identity } = context;
 
       switch (action) {
         case 'search': {
@@ -66,7 +74,8 @@ export default defineCommand({
             return;
           }
           const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const result = await compactSearch({ query, limit, projectId: project.id, reader });
+          const quality = coerceRetrievalQuality(args.quality as string | undefined);
+          const result = await compactSearch({ query, limit, quality, projectId: project.id, reader });
           emitResult({ project, entries: result.entries }, result.formatted, asJson);
           return;
         }
@@ -420,7 +429,7 @@ export default defineCommand({
           console.log('Memorix Memory Commands');
           console.log('');
           console.log('Usage:');
-          console.log('  memorix memory search --query "timeout bug" [--limit 10]');
+          console.log('  memorix memory search --query "timeout bug" [--limit 10] [--quality fast|balanced|thorough]');
           console.log('  memorix memory recent [--limit 10]');
           console.log('  memorix memory store --text "..." [--title "..."] [--type discovery] [--visibility project|personal|team]');
           console.log('  memorix memory suggest-topic-key --type decision --title "..."');

package/src/cli/commands/operator-shared.ts

@@ -9,9 +9,10 @@ import type {
   ObservationStatus,
   ObservationType,
   ObservationVisibility,
+  RetrievalQuality,
 } from '../../types.js';
 import { getCliInvocation } from '../invocation.js';
-import { resolveCliIdentity, type CliIdentity } from '../identity.js';
+import { loadCliIdentity, resolveCliIdentity, type CliIdentity } from '../identity.js';
 
 export interface CliProjectContext {
   project: ProjectInfo;
@@ -22,7 +23,24 @@ export interface CliProjectContext {
   identityWarning?: string;
 }
 
-export async function getCliProjectContext(options?: { searchIndex?: boolean; projectRoot?: string }): Promise<CliProjectContext> {
+export interface CliReadContext {
+  project: ProjectInfo;
+  dataDir: string;
+  reader: ObservationReader;
+  identity: CliIdentity | null;
+  identityWarning?: string;
+}
+
+interface CliContextOptions {
+  searchIndex?: boolean;
+  projectRoot?: string;
+}
+
+async function resolveCliProjectContext(options?: CliContextOptions): Promise<{
+  project: ProjectInfo;
+  dataDir: string;
+  invocation: ReturnType<typeof getCliInvocation>;
+}> {
   const invocation = getCliInvocation();
   const detection = detectProjectWithDiagnostics(
     options?.projectRoot
@@ -37,6 +55,51 @@ export async function getCliProjectContext(options?: { searchIndex?: boolean; pr
 
   const project = detection.project;
   const dataDir = await getProjectDataDir(project.id);
+  return { project, dataDir, invocation };
+}
+
+/**
+ * Read-only memory commands do not need session bookkeeping or maintenance
+ * target registration. Identity resolution remains intact so visibility rules
+ * stay identical to the full operator context.
+ */
+export async function getCliReadContext(options?: CliContextOptions): Promise<CliReadContext> {
+  const { project, dataDir, invocation } = await resolveCliProjectContext(options);
+  await initObservations(dataDir);
+
+  if (options?.searchIndex) {
+    await prepareSearchIndex();
+  }
+
+  const storedIdentity = await loadCliIdentity(dataDir, project.id);
+  if (!invocation.actorId && !storedIdentity) {
+    return {
+      project,
+      dataDir,
+      reader: { projectId: project.id },
+      identity: null,
+    };
+  }
+
+  const teamStore = await initTeamStore(dataDir);
+  const identity = await resolveCliIdentity({
+    project,
+    dataDir,
+    teamStore,
+    explicitActorId: invocation.actorId,
+  });
+
+  return {
+    project,
+    dataDir,
+    reader: identity.reader,
+    identity: identity.identity,
+    ...(identity.warning ? { identityWarning: identity.warning } : {}),
+  };
+}
+
+export async function getCliProjectContext(options?: CliContextOptions): Promise<CliProjectContext> {
+  const { project, dataDir, invocation } = await resolveCliProjectContext(options);
   try {
     const { MaintenanceTargetStore } = await import('../../runtime/maintenance-targets.js');
     new MaintenanceTargetStore(dataDir).register({
@@ -129,6 +192,7 @@ const OBSERVATION_TYPES: ObservationType[] = [
 ];
 
 const OBSERVATION_STATUSES: ObservationStatus[] = ['active', 'resolved', 'archived'];
+const RETRIEVAL_QUALITIES: RetrievalQuality[] = ['fast', 'balanced', 'thorough'];
 
 export function coerceObservationType(input?: string): ObservationType {
   const normalized = (input ?? 'discovery') as ObservationType;
@@ -150,6 +214,14 @@ export function coerceObservationStatus(input?: string): ObservationStatus {
   return normalized;
 }
 
+export function coerceRetrievalQuality(input?: string): RetrievalQuality {
+  const normalized = (input ?? 'balanced').trim().toLowerCase() as RetrievalQuality;
+  if (!RETRIEVAL_QUALITIES.includes(normalized)) {
+    throw new Error('quality must be fast, balanced, or thorough');
+  }
+  return normalized;
+}
+
 export function coerceObservationVisibility(input?: string): ObservationVisibility {
   const normalized = (input ?? 'project').trim().toLowerCase();
   if (normalized === 'personal' || normalized === 'project' || normalized === 'team') {

package/src/cli/commands/resume.ts

@@ -0,0 +1,31 @@
+import { defineCommand } from 'citty';
+import contextCommand from './context.js';
+
+/**
+ * A human- and agent-friendly continuation entry point. It deliberately
+ * delegates to Project Context so CLI and MCP keep one Workset contract.
+ */
+export default defineCommand({
+  meta: {
+    name: 'resume',
+    description: 'Resume prior project work with one bounded Memory Autopilot brief',
+  },
+  args: {
+    task: { type: 'positional', description: 'Current continuation task', required: false },
+    refresh: { type: 'string', description: 'Project scan policy: auto, always, or never' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  async run({ args }) {
+    await contextCommand.run?.({
+      args: {
+        _: [],
+        input: args.task,
+        refresh: args.refresh,
+        json: args.json,
+        resume: true,
+      },
+      rawArgs: [],
+      cmd: contextCommand,
+    } as any);
+  },
+});

package/src/cli/index.ts

@@ -985,12 +985,14 @@ const main = defineCommand({
       args: {
         query: { type: 'positional', description: 'Search query', required: true },
         limit: { type: 'string', description: 'Maximum results' },
+        quality: { type: 'string', description: 'Retrieval profile: fast, balanced (default), or thorough' },
         json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
       },
       async run({ args }) {
         await runMemoryShortcut('search', {
           query: args.query,
           limit: args.limit,
+          quality: args.quality,
           json: args.json,
         });
       },
@@ -1045,6 +1047,7 @@ const main = defineCommand({
     integrate: () => import('./commands/integrate.js').then(m => m.default),
     memory: () => import('./commands/memory.js').then(m => m.default),
     context: () => import('./commands/context.js').then(m => m.default),
+    resume: () => import('./commands/resume.js').then(m => m.default),
     explain: () => import('./commands/explain.js').then(m => m.default),
     codegraph: () => import('./commands/codegraph.js').then(m => m.default),
     knowledge: () => import('./commands/knowledge.js').then(m => m.default),
@@ -1115,7 +1118,7 @@ const main = defineCommand({
     // Detect by checking if the first CLI arg matches a registered subcommand name.
     const firstArg = process.argv[2];
     const knownSubs = ['ask', 'search', 'remember', 'recent', 'help', 'workbench', 'memcode', 'config',
-      'init', 'setup', 'integrate', 'memory', 'context', 'explain', 'codegraph', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
+      'init', 'setup', 'integrate', 'memory', 'context', 'resume', 'explain', 'codegraph', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
       'session', 'team', 'task', 'message', 'lock', 'handoff', 'poll',
       'receipt',
       'serve', 'serve-http', 'status', 'sync',
@@ -1155,6 +1158,7 @@ const main = defineCommand({
       console.error('  session    Start/end/context for coding sessions');
       console.error('  memory     Search/store/detail/timeline/resolve observations');
       console.error('  context    Show the Memory Autopilot brief for this project');
+      console.error('  resume     Resume prior work with one bounded project brief');
       console.error('  explain    Explain where Memorix project context comes from');
       console.error('  codegraph  Refresh/status/context-pack for CodeGraph Memory');
       console.error('  knowledge  Review source-backed knowledge pages and project workflows');

package/src/codegraph/auto-context.ts

@@ -1,9 +1,11 @@
 import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { truncateToTokenBudget } from '../compact/token-budget.js';
 import { getResolvedConfig } from '../config/resolved-config.js';
 import { buildTaskWorkset, type TaskWorkset, type WorksetCaution } from '../knowledge/workset.js';
 import type { ContextDeliveryTarget } from '../knowledge/context-assembly.js';
-import type { ProjectInfo } from '../types.js';
+import { sanitizeCredentials } from '../memory/secret-filter.js';
+import type { ObservationReader, ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, formatGitFact, type CurrentProjectFacts } from './current-facts.js';
 import { refreshProjectLite } from './lite-provider.js';
@@ -21,7 +23,10 @@ import {
 } from './project-context.js';
 import { CodeGraphStore } from './store.js';
 import { isEligibleForAutomaticDelivery } from '../memory/admission.js';
+import { getSessionResumeBrief, type SessionResumeBrief } from '../memory/session.js';
+import { initSessionStore } from '../store/session-store.js';
 import {
+  isContinuationTask,
   lensPathCandidates,
   lensVerificationHints,
   rankLensPaths,
@@ -50,6 +55,8 @@ export interface AutoProjectContext {
   explain: ProjectContextExplain;
   refresh: AutoContextRefreshResult;
   providerQuality: CodeGraphProviderQuality;
+  /** Present only when the caller asked to continue prior work. */
+  continuation?: SessionResumeBrief;
   workset: TaskWorkset;
 }
 
@@ -123,6 +130,10 @@ export async function buildAutoProjectContext(input: {
   maxFileBytes?: number;
   /** Test-only injection point; production uses the bounded local runner. */
   externalRunner?: ExternalCodeGraphRunner;
+  /** Reader used when continuation retrieval loads session and durable memory evidence. */
+  reader?: ObservationReader;
+  /** Auto detects continuation language; always is used by the explicit resume path. */
+  continuation?: 'auto' | 'always' | 'never';
   /**
    * When supplied, a needed refresh is queued instead of running in this
    * request. MCP and hook callers use this to keep their response path fast.
@@ -135,6 +146,8 @@ export async function buildAutoProjectContext(input: {
   const now = input.now ?? new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
+  const continuationRequested = input.continuation === 'always'
+    || (input.continuation !== 'never' && isContinuationTask(task));
   const codegraphConfig = getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph;
   const exclude = input.exclude ?? codegraphConfig.excludePatterns;
   const maxFileBytes = input.maxFileBytes ?? codegraphConfig.maxFileBytes;
@@ -278,6 +291,14 @@ export async function buildAutoProjectContext(input: {
   if (externalCaution) {
     runtimeCautions.push({ kind: 'external-codegraph-fallback', message: externalCaution });
   }
+  // Project Context is also used by lightweight callers that have not touched
+  // session APIs yet. Initialize only when continuation was requested so a
+  // normal Workset remains independent of session persistence.
+  let continuation: SessionResumeBrief | undefined;
+  if (continuationRequested) {
+    await initSessionStore(input.dataDir);
+    continuation = await getSessionResumeBrief(input.project.id, task, input.reader);
+  }
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
     dataDir: input.dataDir,
@@ -287,6 +308,7 @@ export async function buildAutoProjectContext(input: {
     ...(externalOutline ? { semanticCode: externalOutline } : {}),
     providerQuality,
     currentFacts: worksetFactLines(currentFacts),
+    ...(continuation ? { continuation } : {}),
     codeState: codeStateLine(overview),
     reliableMemory: sourceSets.reliableSources
       .slice(0, lens.sourceLimit)
@@ -340,6 +362,7 @@ export async function buildAutoProjectContext(input: {
     explain,
     refresh,
     providerQuality,
+    ...(continuationRequested && workset.continuation ? { continuation: workset.continuation } : {}),
     workset,
   };
 }
@@ -350,6 +373,13 @@ function formatLanguages(overview: ProjectContextOverview): string {
     : 'none indexed yet';
 }
 
+function compactContinuationText(text: string, budget: number): string {
+  return truncateToTokenBudget(
+    sanitizeCredentials(text).replace(/\s+/g, ' ').trim(),
+    budget,
+  );
+}
+
 function codeStateLine(overview: ProjectContextOverview): string {
   const snapshot = overview.code.latestSnapshot;
   if (!snapshot) return '- Code state: no completed snapshot yet';
@@ -533,6 +563,29 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
       : '- none yet',
   );
 
+  const continuation = context.workset.continuation;
+  if (continuation?.previousSession || continuation?.memories.length) {
+    lines.push('', 'Resume from prior work');
+    if (continuation.previousSession) {
+      const session = continuation.previousSession;
+      const source = [session.agent, session.endedAt ? session.endedAt.slice(0, 10) : undefined]
+        .filter(Boolean)
+        .join(', ');
+      lines.push(
+        '- Previous session' + (source ? ` (${source})` : '') + ': '
+          + compactContinuationText(session.summary, 44),
+      );
+    }
+    for (const memory of continuation.memories.slice(0, 3)) {
+      const detail = memory.detail ? ': ' + compactContinuationText(memory.detail, 20) : '';
+      lines.push(
+        '- #' + memory.id + ' ' + memory.type + ': '
+          + compactContinuationText(memory.title, 18)
+          + detail,
+      );
+    }
+  }
+
   return lines.join('\n');
 }
 

package/src/codegraph/task-lens.ts

@@ -121,6 +121,7 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
     'fail',
     'failing',
     'fix',
+    'fixing',
     'issue',
     'regression',
     'repro',
@@ -139,6 +140,22 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
   test: ['coverage', 'fixture', 'smoke', 'spec', 'test', 'tests', 'testing', 'vitest', '测试'],
 };
 
+// Continuation is a delivery intent, not a task lens. A request can both resume
+// prior work and be a bugfix, feature, or release task, so callers keep the
+// normal lens and add a bounded prior-work projection separately.
+const CONTINUATION_KEYWORDS = [
+  'continue',
+  'resume',
+  'pick up',
+  'carry on',
+  'previous session',
+  '继续',
+  '接手',
+  '恢复',
+  '延续',
+  '上次会话',
+];
+
 const LENS_PRIORITY: Exclude<TaskLensId, 'general'>[] = [
   'bugfix',
   'release',
@@ -229,6 +246,18 @@ export function resolveTaskLens(task?: string): TaskLens {
   return best.score > 0 ? LENSES[best.id] : LENSES.general;
 }
 
+/**
+ * Detect when the caller is asking to continue existing work. This stays
+ * separate from task-lens routing so "continue fixing the timeout" remains a
+ * bugfix, while still receiving a compact prior-work brief.
+ */
+export function isContinuationTask(task?: string): boolean {
+  const normalized = (task ?? '').trim().toLowerCase();
+  return normalized.length > 0 && CONTINUATION_KEYWORDS.some((keyword) =>
+    containsTaskKeyword(normalized, keyword),
+  );
+}
+
 function pathKindScore(path: string, lens: TaskLens): number {
   const normalized = normalizePath(path).toLowerCase();
   const name = normalized.split('/').pop() ?? normalized;

package/src/compact/token-budget.ts

@@ -56,7 +56,22 @@ export function truncateToTokenBudget(text: string, budget: number): string {
       result = result.slice(0, Math.floor(result.length * 0.9));
     }
     if (result.length < text.length) {
-      result += '...';
+      // A character estimate can end halfway through a flag, path, or symbol.
+      // Drop the incomplete whitespace-delimited token instead of returning
+      // misleading fragments such as `AUTH...`.
+      const nextCharacter = text.charAt(result.length);
+      if (nextCharacter && !/[\s.,;:!?)}\]]/.test(nextCharacter)) {
+        const boundary = result.search(/\s+\S*$/);
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : '';
+      }
+
+      // Keep the suffix inside the stated budget when there is room. An empty
+      // prefix is more honest than a partial identifier that appears valid.
+      while (result && fitsInBudget(result + '...', budget) === false) {
+        const boundary = result.lastIndexOf(' ');
+        result = boundary > 0 ? result.slice(0, boundary).trimEnd() : '';
+      }
+      result = result ? result + '...' : '...';
     }
   }
 

package/src/config/resolved-config.ts

@@ -88,6 +88,27 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
   const legacy = loadFileConfig();
   const embeddingBaseUrl = first(process.env.MEMORIX_EMBEDDING_BASE_URL, toml.embedding?.base_url, yaml.embedding?.baseUrl, legacy.embeddingApi?.baseUrl);
   const openRouterEmbeddingApiKey = isOpenRouterUrl(embeddingBaseUrl) ? process.env.OPENROUTER_API_KEY : undefined;
+  const memoryLlmProvider = first(
+    process.env.MEMORIX_LLM_PROVIDER,
+    toml.memory?.llm?.provider,
+    yaml.llm?.provider,
+    legacy.llm?.provider,
+  );
+  const memoryLlmModel = first(
+    process.env.MEMORIX_LLM_MODEL,
+    toml.memory?.llm?.model,
+    yaml.llm?.model,
+    legacy.llm?.model,
+  );
+  const memoryLlmBaseUrl = first(
+    process.env.MEMORIX_LLM_BASE_URL,
+    toml.memory?.llm?.base_url,
+    yaml.llm?.baseUrl,
+    legacy.llm?.baseUrl,
+  );
+  const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl)
+    ? process.env.OPENROUTER_API_KEY
+    : undefined;
 
   const resolved: ResolvedMemorixConfig = {
     agent: {
@@ -126,9 +147,9 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
       autoCleanup: firstBool(toml.memory?.auto_cleanup, yaml.behavior?.autoCleanup),
       syncAdvisory: firstBool(toml.memory?.sync_advisory, yaml.behavior?.syncAdvisory),
       llm: {
-        provider: first(process.env.MEMORIX_LLM_PROVIDER, toml.memory?.llm?.provider, yaml.llm?.provider, legacy.llm?.provider),
-        model: first(process.env.MEMORIX_LLM_MODEL, toml.memory?.llm?.model, yaml.llm?.model, legacy.llm?.model),
-        baseUrl: first(process.env.MEMORIX_LLM_BASE_URL, toml.memory?.llm?.base_url, yaml.llm?.baseUrl, legacy.llm?.baseUrl),
+        provider: memoryLlmProvider,
+        model: memoryLlmModel,
+        baseUrl: memoryLlmBaseUrl,
         apiKey: first(
           process.env.MEMORIX_LLM_API_KEY,
           process.env.MEMORIX_API_KEY,
@@ -137,7 +158,7 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
           legacy.llm?.apiKey,
           process.env.OPENAI_API_KEY,
           process.env.ANTHROPIC_API_KEY,
-          process.env.OPENROUTER_API_KEY,
+          openRouterMemoryLlmApiKey,
         ),
       },
     },
@@ -290,6 +311,10 @@ function isOpenRouterUrl(value: string | undefined): boolean {
   }
 }
 
+function isOpenRouterMemoryLane(provider: string | undefined, baseUrl: string | undefined): boolean {
+  return provider?.trim().toLowerCase() === 'openrouter' || isOpenRouterUrl(baseUrl);
+}
+
 function normalizeExternalContext(value: string | undefined): 'auto' | 'off' | undefined {
   const normalized = value?.trim().toLowerCase();
   if (normalized === 'auto' || normalized === 'off') return normalized;

package/src/config/toml-loader.ts

@@ -144,6 +144,9 @@ function parseTomlValue(raw: string, filePath: string, line: number): unknown {
   if (raw.startsWith('"') && raw.endsWith('"')) {
     return raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
   }
+  if (raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
   if (raw === 'true') return true;
   if (raw === 'false') return false;
   if (/^-?\d+$/.test(raw)) return Number.parseInt(raw, 10);
@@ -157,7 +160,7 @@ function parseTomlValue(raw: string, filePath: string, line: number): unknown {
 }
 
 function stripComment(line: string): string {
-  let inString = false;
+  let quote: '"' | "'" | null = null;
   let escaped = false;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
@@ -165,15 +168,16 @@ function stripComment(line: string): string {
       escaped = false;
       continue;
     }
-    if (char === '\\' && inString) {
+    if (char === '\\' && quote === '"') {
       escaped = true;
       continue;
     }
-    if (char === '"') {
-      inString = !inString;
+    if (char === '"' || char === "'") {
+      if (quote === char) quote = null;
+      else if (quote === null) quote = char;
       continue;
     }
-    if (char === '#' && !inString) {
+    if (char === '#' && quote === null) {
       return line.slice(0, i);
     }
   }