memorix 1.1.7 → 1.1.9

package/src/cli/update-checker.ts

@@ -9,85 +9,85 @@
  * Set MEMORIX_AUTO_UPDATE=install to opt into silent background install.
  * Disable via MEMORIX_AUTO_UPDATE=off.
  */
-
-import { execFile } from 'node:child_process';
-import type { ExecFileException } from 'node:child_process';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { getCliVersion } from './version.js';
-
-const PACKAGE_NAME = 'memorix';
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const DEFAULT_AUTO_UPDATE_TIMEOUT_MS = 5 * 60 * 1000;
-const MIN_AUTO_UPDATE_TIMEOUT_MS = 5_000;
-const MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1000;
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const CACHE_DIR = join(homedir(), '.memorix');
-const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
-
+
+import { execFile } from 'node:child_process';
+import type { ExecFileException } from 'node:child_process';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getCliVersion } from './version.js';
+
+const PACKAGE_NAME = 'memorix';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const DEFAULT_AUTO_UPDATE_TIMEOUT_MS = 5 * 60 * 1000;
+const MIN_AUTO_UPDATE_TIMEOUT_MS = 5_000;
+const MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1000;
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CACHE_DIR = join(homedir(), '.memorix');
+const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
+
 export interface UpdateCache {
-  lastCheck: number;
-  latestVersion: string;
-  lastAutoUpdate?: number;
-  lastAutoUpdateStatus?: 'success' | 'failed';
-  lastAutoUpdateError?: string;
-  lastAutoUpdateTimedOut?: boolean;
-  lastAutoUpdateExitCode?: number | null;
-  lastAutoUpdateSignal?: string | null;
-  lastAutoUpdateTimeoutMs?: number;
-  updatedFrom?: string;
-  updatedTo?: string;
+  lastCheck: number;
+  latestVersion: string;
+  lastAutoUpdate?: number;
+  lastAutoUpdateStatus?: 'success' | 'failed';
+  lastAutoUpdateError?: string;
+  lastAutoUpdateTimedOut?: boolean;
+  lastAutoUpdateExitCode?: number | null;
+  lastAutoUpdateSignal?: string | null;
+  lastAutoUpdateTimeoutMs?: number;
+  updatedFrom?: string;
+  updatedTo?: string;
 }
 
 export type AutoUpdateMode = 'off' | 'notify' | 'install';
-
-/**
- * Get the current installed version from package.json.
- */
-export function getCurrentVersion(): string {
-  try {
-    return getCliVersion();
-  } catch {
-    return '0.0.0';
-  }
-}
-
-/**
- * Compare two semver strings. Returns true if remote > local.
- */
-export function isNewer(remote: string, local: string): boolean {
-  const r = remote.split('.').map(Number);
-  const l = local.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
-    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
-  }
-  return false;
-}
-
-/**
- * Read the update check cache. Exported for doctor/status display.
- */
-export async function readCache(): Promise<UpdateCache | null> {
-  try {
-    const data = await readFile(CACHE_FILE, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write the update check cache.
- */
-async function writeCache(cache: UpdateCache): Promise<void> {
-  try {
-    await mkdir(CACHE_DIR, { recursive: true });
-    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
-  } catch { /* silent */ }
-}
-
+
+/**
+ * Get the current installed version from package.json.
+ */
+export function getCurrentVersion(): string {
+  try {
+    return getCliVersion();
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Compare two semver strings. Returns true if remote > local.
+ */
+export function isNewer(remote: string, local: string): boolean {
+  const r = remote.split('.').map(Number);
+  const l = local.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
+    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+/**
+ * Read the update check cache. Exported for doctor/status display.
+ */
+export async function readCache(): Promise<UpdateCache | null> {
+  try {
+    const data = await readFile(CACHE_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the update check cache.
+ */
+async function writeCache(cache: UpdateCache): Promise<void> {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+  } catch { /* silent */ }
+}
+
 /**
  * Parse MEMORIX_AUTO_UPDATE into an explicit mode.
  * Default: notify-only.
@@ -99,105 +99,105 @@ function parseAutoUpdateMode(raw: string | undefined): AutoUpdateMode {
   if (env === 'install' || env === 'true' || env === '1') return 'install';
   return 'notify';
 }
-
-function parseAutoUpdateTimeoutMs(raw: string | undefined): number {
-  const value = raw?.trim();
-  if (!value) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
-  return Math.max(MIN_AUTO_UPDATE_TIMEOUT_MS, Math.min(MAX_AUTO_UPDATE_TIMEOUT_MS, Math.floor(parsed)));
-}
-
-function describeAutoUpdateFailure(error: ExecFileException, timeoutMs: number): {
-  message: string;
-  timedOut: boolean;
-  exitCode: number | null;
-  signal: string | null;
-} {
-  const timedOut = /timed out/i.test(error.message);
-  const exitCode = typeof error.code === 'number' ? error.code : null;
-  const signal = typeof error.signal === 'string' ? error.signal : null;
-  const details: string[] = [];
-  if (timedOut) details.push(`timeout ${timeoutMs}ms`);
-  if (exitCode !== null) details.push(`exit code ${exitCode}`);
-  if (signal) details.push(`signal ${signal}`);
-  return {
-    message: details.length > 0 ? `${error.message} (${details.join(', ')})` : error.message,
-    timedOut,
-    exitCode,
-    signal,
-  };
-}
-
-/**
- * Fetch the latest version from npm registry.
- * Uses native https to avoid dependencies. Timeout: 5s.
- */
-async function fetchLatestVersion(): Promise<string | null> {
-  try {
-    const { default: https } = await import('node:https');
-    return new Promise((resolve) => {
-      const req = https.get(REGISTRY_URL, { timeout: 5000 }, (res) => {
-        if (res.statusCode !== 200) { resolve(null); return; }
-        let body = '';
-        res.on('data', (chunk: Buffer) => { body += chunk.toString(); });
-        res.on('end', () => {
-          try {
-            const data = JSON.parse(body);
-            resolve(data.version ?? null);
-          } catch { resolve(null); }
-        });
-      });
-      req.on('error', () => resolve(null));
-      req.on('timeout', () => { req.destroy(); resolve(null); });
-    });
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Silently install the latest version in the background.
- * Writes result to the cache file so doctor/status can report it.
- */
-function installUpdateInBackground(targetVersion: string, currentVersion: string, cache: UpdateCache): void {
-  try {
-    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const timeoutMs = parseAutoUpdateTimeoutMs(process.env.MEMORIX_AUTO_UPDATE_TIMEOUT_MS);
-    const child = execFile(
-      npmCmd,
-      ['install', '-g', `${PACKAGE_NAME}@${targetVersion}`],
-      { timeout: timeoutMs },
-      async (error) => {
-        const failure = error ? describeAutoUpdateFailure(error, timeoutMs) : null;
-        const updatedCache: UpdateCache = {
-          ...cache,
-          lastAutoUpdate: Date.now(),
-          updatedFrom: currentVersion,
-          updatedTo: targetVersion,
-          lastAutoUpdateStatus: error ? 'failed' : 'success',
-          lastAutoUpdateError: failure?.message,
-          lastAutoUpdateTimedOut: failure?.timedOut,
-          lastAutoUpdateExitCode: failure?.exitCode,
-          lastAutoUpdateSignal: failure?.signal,
-          lastAutoUpdateTimeoutMs: timeoutMs,
-        };
-        await writeCache(updatedCache);
-        if (error) {
-          console.error(`[memorix] Auto-update failed: ${failure?.message ?? error.message}`);
-        } else {
-          console.error(`[memorix] Auto-updated to v${targetVersion} — restart to apply`);
-        }
-      },
-    );
-    // Unref so the child process doesn't prevent the main process from exiting
-    child.unref();
-  } catch (err) {
-    console.error(`[memorix] Auto-update spawn failed:`, (err as Error)?.message ?? err);
-  }
-}
-
-/**
+
+function parseAutoUpdateTimeoutMs(raw: string | undefined): number {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return DEFAULT_AUTO_UPDATE_TIMEOUT_MS;
+  return Math.max(MIN_AUTO_UPDATE_TIMEOUT_MS, Math.min(MAX_AUTO_UPDATE_TIMEOUT_MS, Math.floor(parsed)));
+}
+
+function describeAutoUpdateFailure(error: ExecFileException, timeoutMs: number): {
+  message: string;
+  timedOut: boolean;
+  exitCode: number | null;
+  signal: string | null;
+} {
+  const timedOut = /timed out/i.test(error.message);
+  const exitCode = typeof error.code === 'number' ? error.code : null;
+  const signal = typeof error.signal === 'string' ? error.signal : null;
+  const details: string[] = [];
+  if (timedOut) details.push(`timeout ${timeoutMs}ms`);
+  if (exitCode !== null) details.push(`exit code ${exitCode}`);
+  if (signal) details.push(`signal ${signal}`);
+  return {
+    message: details.length > 0 ? `${error.message} (${details.join(', ')})` : error.message,
+    timedOut,
+    exitCode,
+    signal,
+  };
+}
+
+/**
+ * Fetch the latest version from npm registry.
+ * Uses native https to avoid dependencies. Timeout: 5s.
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const { default: https } = await import('node:https');
+    return new Promise((resolve) => {
+      const req = https.get(REGISTRY_URL, { timeout: 5000 }, (res) => {
+        if (res.statusCode !== 200) { resolve(null); return; }
+        let body = '';
+        res.on('data', (chunk: Buffer) => { body += chunk.toString(); });
+        res.on('end', () => {
+          try {
+            const data = JSON.parse(body);
+            resolve(data.version ?? null);
+          } catch { resolve(null); }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Silently install the latest version in the background.
+ * Writes result to the cache file so doctor/status can report it.
+ */
+function installUpdateInBackground(targetVersion: string, currentVersion: string, cache: UpdateCache): void {
+  try {
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const timeoutMs = parseAutoUpdateTimeoutMs(process.env.MEMORIX_AUTO_UPDATE_TIMEOUT_MS);
+    const child = execFile(
+      npmCmd,
+      ['install', '-g', `${PACKAGE_NAME}@${targetVersion}`],
+      { timeout: timeoutMs },
+      async (error) => {
+        const failure = error ? describeAutoUpdateFailure(error, timeoutMs) : null;
+        const updatedCache: UpdateCache = {
+          ...cache,
+          lastAutoUpdate: Date.now(),
+          updatedFrom: currentVersion,
+          updatedTo: targetVersion,
+          lastAutoUpdateStatus: error ? 'failed' : 'success',
+          lastAutoUpdateError: failure?.message,
+          lastAutoUpdateTimedOut: failure?.timedOut,
+          lastAutoUpdateExitCode: failure?.exitCode,
+          lastAutoUpdateSignal: failure?.signal,
+          lastAutoUpdateTimeoutMs: timeoutMs,
+        };
+        await writeCache(updatedCache);
+        if (error) {
+          console.error(`[memorix] Auto-update failed: ${failure?.message ?? error.message}`);
+        } else {
+          console.error(`[memorix] Auto-updated to v${targetVersion} — restart to apply`);
+        }
+      },
+    );
+    // Unref so the child process doesn't prevent the main process from exiting
+    child.unref();
+  } catch (err) {
+    console.error(`[memorix] Auto-update spawn failed:`, (err as Error)?.message ?? err);
+  }
+}
+
+/**
  * Run the background update check.
  *
  * Call this fire-and-forget from entry points (serve-http, TUI).
@@ -215,32 +215,32 @@ export async function checkForUpdates(): Promise<void> {
 
     const cache = await readCache();
     const now = Date.now();
-
-    // Rate limit: skip if checked within the last 24 hours
-    if (cache && (now - cache.lastCheck) < CHECK_INTERVAL_MS) {
-      return;
-    }
-
-    const latestVersion = await fetchLatestVersion();
-    if (!latestVersion) return;
-
-    const currentVersion = getCurrentVersion();
-
-    // Update cache with check timestamp
-    const updatedCache: UpdateCache = {
-      lastCheck: now,
-      latestVersion,
-      lastAutoUpdate: cache?.lastAutoUpdate,
-      lastAutoUpdateStatus: cache?.lastAutoUpdateStatus,
-      lastAutoUpdateError: cache?.lastAutoUpdateError,
-      lastAutoUpdateTimedOut: cache?.lastAutoUpdateTimedOut,
-      lastAutoUpdateExitCode: cache?.lastAutoUpdateExitCode,
-      lastAutoUpdateSignal: cache?.lastAutoUpdateSignal,
-      lastAutoUpdateTimeoutMs: cache?.lastAutoUpdateTimeoutMs,
-      updatedFrom: cache?.updatedFrom,
-      updatedTo: cache?.updatedTo,
-    };
-    await writeCache(updatedCache);
+
+    // Rate limit: skip if checked within the last 24 hours
+    if (cache && (now - cache.lastCheck) < CHECK_INTERVAL_MS) {
+      return;
+    }
+
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) return;
+
+    const currentVersion = getCurrentVersion();
+
+    // Update cache with check timestamp
+    const updatedCache: UpdateCache = {
+      lastCheck: now,
+      latestVersion,
+      lastAutoUpdate: cache?.lastAutoUpdate,
+      lastAutoUpdateStatus: cache?.lastAutoUpdateStatus,
+      lastAutoUpdateError: cache?.lastAutoUpdateError,
+      lastAutoUpdateTimedOut: cache?.lastAutoUpdateTimedOut,
+      lastAutoUpdateExitCode: cache?.lastAutoUpdateExitCode,
+      lastAutoUpdateSignal: cache?.lastAutoUpdateSignal,
+      lastAutoUpdateTimeoutMs: cache?.lastAutoUpdateTimeoutMs,
+      updatedFrom: cache?.updatedFrom,
+      updatedTo: cache?.updatedTo,
+    };
+    await writeCache(updatedCache);
 
     if (isNewer(latestVersion, currentVersion)) {
       if (mode === 'install') {
@@ -254,12 +254,12 @@ export async function checkForUpdates(): Promise<void> {
     }
   } catch {
     // Entire update check is best-effort — never crash the caller
-  }
-}
-
-// ── Test helpers (exported for testing only) ──────────────────
-
-/** @internal */
+  }
+}
+
+// ── Test helpers (exported for testing only) ──────────────────
+
+/** @internal */
 export const _testing = {
   CACHE_FILE,
   CHECK_INTERVAL_MS,
@@ -268,8 +268,8 @@ export const _testing = {
   parseAutoUpdateTimeoutMs,
   describeAutoUpdateFailure,
   fetchLatestVersion,
-  installUpdateInBackground,
-  writeCache,
-  isNewer,
-  getCurrentVersion,
-};
+  installUpdateInBackground,
+  writeCache,
+  isNewer,
+  getCurrentVersion,
+};

package/src/cli/version.ts

@@ -1,7 +1,7 @@
-import pkg from '../../package.json';
-
-export function getCliVersion(): string {
-  return typeof __MEMORIX_VERSION__ !== 'undefined'
-    ? __MEMORIX_VERSION__
-    : pkg.version;
-}
+import pkg from '../../package.json';
+
+export function getCliVersion(): string {
+  return typeof __MEMORIX_VERSION__ !== 'undefined'
+    ? __MEMORIX_VERSION__
+    : pkg.version;
+}

package/src/cli/workbench.ts

@@ -5,4 +5,4 @@
  * Kept for backward-compat: `import { startWorkbench } from './workbench.js'`
  */
 
-export { startWorkbench } from './tui/index.js';
+export { startWorkbench } from './tui/index.js';

package/src/codegraph/auto-context.ts

@@ -1,5 +1,6 @@
 import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { getResolvedConfig } from '../config/resolved-config.js';
 import type { ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, type CurrentProjectFacts } from './current-facts.js';
@@ -100,11 +101,13 @@ export async function buildAutoProjectContext(input: {
   refresh?: AutoContextRefreshMode;
   maxAgeMs?: number;
   now?: Date;
+  exclude?: string[];
 }): Promise<AutoProjectContext> {
   const refreshMode = input.refresh ?? 'auto';
   const now = input.now ?? new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
+  const exclude = input.exclude ?? getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph.excludePatterns;
   const store = new CodeGraphStore();
   await store.init(input.dataDir);
 
@@ -126,6 +129,7 @@ export async function buildAutoProjectContext(input: {
       const indexed = await indexProjectLite({
         projectId: input.project.id,
         projectRoot: input.project.rootPath,
+        exclude,
       });
       store.replaceProjectIndex(input.project.id, indexed);
       const backfill = await backfillMissingObservationCodeRefs(
@@ -147,11 +151,13 @@ export async function buildAutoProjectContext(input: {
     project: input.project,
     store,
     observations: input.observations,
+    exclude,
   });
   const explain = buildProjectContextExplain({
     project: input.project,
     store,
     observations: input.observations,
+    exclude,
   });
 
   return {

package/src/codegraph/context-pack.ts

@@ -1,6 +1,7 @@
 import { evaluateCodeRefFreshness } from './freshness.js';
 import type { CodeFile, CodeRefStatus, CodeSymbol, ObservationCodeRef } from './types.js';
 import type { CodeGraphStore } from './store.js';
+import { isCodeGraphExcludedPath } from './exclude.js';
 
 export interface ContextPackMemory {
   id: number;
@@ -52,6 +53,7 @@ export interface AssembleContextPackInput {
   files: CodeFile[];
   symbols: CodeSymbol[];
   suggestedVerification?: string[];
+  exclude?: string[];
 }
 
 function uniq<T>(items: T[]): T[] {
@@ -68,10 +70,6 @@ function timestampOf(observation: ContextPackObservation): number {
   return Date.parse(observation.updatedAt ?? observation.createdAt ?? '') || 0;
 }
 
-function isGeneratedPath(path: string): boolean {
-  return /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules)\//i.test(path.replace(/\\/g, '/'));
-}
-
 function relevanceScore(observation: ContextPackObservation, taskTokens: string[]): number {
   if (taskTokens.length === 0) return 0;
   const title = observation.title.toLowerCase();
@@ -133,6 +131,7 @@ export function assembleContextPackForTask(input: {
   observations: ContextPackObservation[];
   limit?: number;
   suggestedVerification?: string[];
+  exclude?: string[];
 }): ContextPack {
   const selected = selectRelevantObservations(input.observations, input.task, input.limit ?? 20);
   const refs = selected.flatMap(obs => input.store.listObservationRefs(input.projectId, obs.id));
@@ -147,6 +146,7 @@ export function assembleContextPackForTask(input: {
     files,
     symbols,
     suggestedVerification: input.suggestedVerification,
+    exclude: input.exclude,
   });
 }
 
@@ -168,6 +168,7 @@ export function assembleContextPack(input: AssembleContextPackInput): ContextPac
 
     const file = ref.fileId ? files.get(ref.fileId) : undefined;
     const symbol = ref.symbolId ? symbols.get(ref.symbolId) : undefined;
+    if (file && isCodeGraphExcludedPath(file.path, input.exclude)) continue;
     const freshness = evaluateCodeRefFreshness(ref, file, symbol);
 
     if (freshness.status === 'current') {
@@ -243,8 +244,8 @@ export function buildContextPackPrompt(pack: ContextPack): string {
   const reliableMemories = pack.memories.filter(memory => memory.status === 'current');
   const unboundMemories = pack.memories.filter(memory => memory.status === 'unbound');
   const lines: string[] = ['## Task', pack.task, '', '## Reliable Memories'];
-  const visibleCodeFacts = pack.codeFacts.filter(fact => !isGeneratedPath(fact.path)).slice(0, 5);
-  const visibleSuggestedReads = pack.suggestedReads.filter(path => !isGeneratedPath(path)).slice(0, 5);
+  const visibleCodeFacts = pack.codeFacts.filter(fact => !isCodeGraphExcludedPath(fact.path)).slice(0, 5);
+  const visibleSuggestedReads = pack.suggestedReads.filter(path => !isCodeGraphExcludedPath(path)).slice(0, 5);
 
   if (reliableMemories.length === 0) lines.push('- none');
   for (const memory of reliableMemories) {

package/src/codegraph/exclude.ts

@@ -0,0 +1,47 @@
+export const DEFAULT_CODEGRAPH_EXCLUDES = [
+  'node_modules/**',
+  'dist/**',
+  'build/**',
+  'coverage/**',
+  '.next/**',
+  '.turbo/**',
+  '.git/**',
+  '.tmp/**',
+  '.worktrees/**',
+  '.claude/worktrees/**',
+];
+
+export function normalizeCodeGraphExcludePatterns(exclude?: string[]): string[] {
+  return [...new Set([
+    ...DEFAULT_CODEGRAPH_EXCLUDES,
+    ...(exclude ?? []).map(pattern => pattern.trim()).filter(Boolean),
+  ])];
+}
+
+export function isCodeGraphExcludedPath(path: string, exclude?: string[]): boolean {
+  const normalized = normalizeCodePath(path);
+  return normalizeCodeGraphExcludePatterns(exclude).some((pattern) => matchesPattern(normalized, normalizeCodePath(pattern)));
+}
+
+function normalizeCodePath(path: string): string {
+  return path.replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+
+function matchesPattern(path: string, pattern: string): boolean {
+  if (pattern.endsWith('/**')) {
+    const base = pattern.slice(0, -3);
+    if (base.startsWith('**/')) {
+      const suffix = base.slice(3);
+      return path === suffix || path.endsWith(`/${suffix}`) || path.includes(`/${suffix}/`);
+    }
+    if (!base.includes('/')) {
+      return path === base || path.startsWith(`${base}/`) || path.includes(`/${base}/`);
+    }
+    return path === base || path.startsWith(`${base}/`);
+  }
+  if (pattern.startsWith('**/')) {
+    const suffix = pattern.slice(3);
+    return path === suffix || path.endsWith(`/${suffix}`);
+  }
+  return path === pattern || path.startsWith(`${pattern}/`);
+}