smart-context-mcp 1.6.0 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-context-mcp",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "MCP server that reduces agent token usage by 90% with intelligent context compression, task checkpoint persistence, and workflow-aware agent guidance.",
   "author": "Francisco Caballero Portero <fcp1978@hotmail.com>",
   "type": "module",

package/src/storage/sqlite.js

@@ -2,12 +2,16 @@ import fs from 'node:fs';
 import { createHash } from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
 import { projectRoot } from '../utils/runtime-config.js';
 
 export const STATE_DB_FILENAME = 'state.sqlite';
 export const SQLITE_SCHEMA_VERSION = 5;
 export const ACTIVE_SESSION_SCOPE = 'project';
 export const STATE_DB_SOFT_MAX_BYTES = 32 * 1024 * 1024;
+const STATE_DB_BUSY_TIMEOUT_MS = 1000;
+const STATE_DB_LOCK_RETRY_ATTEMPTS = 3;
+const STATE_DB_LOCK_RETRY_DELAY_MS = 75;
 export const EXPECTED_TABLES = [
   'active_session',
   'context_access',
@@ -444,7 +448,32 @@ export const getMeta = (db, key) => {
 const getSchemaVersion = (db) => Number(getMeta(db, 'schema_version') ?? 0);
 const VALID_STATUSES = new Set(['planning', 'in_progress', 'blocked', 'completed']);
 
-const applyPragmas = (db) => {
+const isStateDbLockError = (error) =>
+  /database is locked|database table is locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(String(error?.message ?? error ?? ''));
+
+const withStateDbLockRetry = async (operation) => {
+  for (let attempt = 1; attempt <= STATE_DB_LOCK_RETRY_ATTEMPTS; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isStateDbLockError(error) || attempt === STATE_DB_LOCK_RETRY_ATTEMPTS) {
+        throw error;
+      }
+
+      await delay(STATE_DB_LOCK_RETRY_DELAY_MS * attempt);
+    }
+  }
+
+  throw new Error('SQLite lock retry exhausted unexpectedly.');
+};
+
+const applyPragmas = (db, { readOnly = false } = {}) => {
+  db.exec(`PRAGMA busy_timeout = ${STATE_DB_BUSY_TIMEOUT_MS}`);
+
+  if (readOnly) {
+    return;
+  }
+
   db.exec('PRAGMA foreign_keys = ON');
   db.exec('PRAGMA journal_mode = WAL');
   db.exec('PRAGMA synchronous = NORMAL');
@@ -505,17 +534,28 @@ export const listStateTables = (db) =>
 
 export const openStateDb = async ({ filePath = getStateDbPath(), readOnly = false } = {}) => {
   try {
-    const { DatabaseSync } = await loadSqliteModule();
-    if (!readOnly) {
-      ensureStateDir(filePath);
-    }
+    return await withStateDbLockRetry(async () => {
+      const { DatabaseSync } = await loadSqliteModule();
+      if (!readOnly) {
+        ensureStateDir(filePath);
+      }
 
-    const db = new DatabaseSync(filePath, readOnly ? { readOnly: true } : {});
-    if (!readOnly) {
-      applyPragmas(db);
-      runStateMigrations(db);
-    }
-    return db;
+      let db = null;
+
+      try {
+        db = new DatabaseSync(filePath, readOnly ? { readOnly: true } : {});
+        applyPragmas(db, { readOnly });
+        if (!readOnly) {
+          runStateMigrations(db);
+        }
+        return db;
+      } catch (error) {
+        try {
+          db?.close();
+        } catch {}
+        throw error;
+      }
+    });
   } catch (error) {
     throw enrichStateDbError(error, { filePath, readOnly });
   }

package/src/task-runner.js

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from 'node:timers/promises';
 import { persistMetrics } from './metrics.js';
 import { countTokens } from './tokenCounter.js';
 import { TASK_RUNNER_QUALITY_ANALYTICS_KIND } from './analytics/product-quality.js';
@@ -22,6 +23,8 @@ import {
 
 const START_MAX_TOKENS = 350;
 const END_MAX_TOKENS = 350;
+const RUNNER_LOCK_RETRY_ATTEMPTS = 3;
+const RUNNER_LOCK_RETRY_DELAY_MS = 100;
 
 const normalizeWhitespace = (value) => String(value ?? '').replace(/\s+/g, ' ').trim();
 const truncate = (value, maxLength = 160) => {
@@ -39,6 +42,13 @@ const truncate = (value, maxLength = 160) => {
 
 const asArray = (value) => Array.isArray(value) ? value : [];
 const uniqueCompact = (values) => [...new Set(asArray(values).map((value) => normalizeWhitespace(value)).filter(Boolean))];
+const extractContextTopFiles = (topFiles) => uniqueCompact(asArray(topFiles).map((item) => {
+  if (typeof item === 'string') {
+    return item;
+  }
+
+  return item?.file ?? item?.path ?? '';
+})).slice(0, 3);
 
 const extractPreflightTopFiles = (preflightResult) => {
   if (!preflightResult) {
@@ -50,12 +60,7 @@ const extractPreflightTopFiles = (preflightResult) => {
   }
 
   if (preflightResult.tool === 'smart_search') {
-    return uniqueCompact(asArray(preflightResult.result?.topFiles).map((item) => {
-      if (typeof item === 'string') {
-        return item;
-      }
-      return item?.file ?? item?.path ?? '';
-    })).slice(0, 3);
+    return extractContextTopFiles(preflightResult.result?.topFiles);
   }
 
   return [];
@@ -100,7 +105,7 @@ const buildPreflightTask = ({ workflowProfile, prompt, startResult }) => {
   const normalizedPrompt = normalizeWhitespace(prompt);
   const persistedNextStep = normalizeWhitespace(startResult?.summary?.nextStep);
   const currentFocus = normalizeWhitespace(startResult?.summary?.currentFocus);
-  const refreshedTopFiles = uniqueCompact(startResult?.refreshedContext?.topFiles).slice(0, 3);
+  const refreshedTopFiles = extractContextTopFiles(startResult?.refreshedContext?.topFiles);
 
   if (workflowProfile.commandName === 'continue' || workflowProfile.commandName === 'resume') {
     if (persistedNextStep) {
@@ -178,7 +183,7 @@ const buildContinuityGuidance = ({ startResult }) => {
   ];
   const nextStep = normalizeWhitespace(startResult?.summary?.nextStep);
   const currentFocus = normalizeWhitespace(startResult?.summary?.currentFocus);
-  const refreshedTopFiles = uniqueCompact(startResult?.refreshedContext?.topFiles).slice(0, 3);
+  const refreshedTopFiles = extractContextTopFiles(startResult?.refreshedContext?.topFiles);
   const recommendedNextTools = asArray(startResult?.recommendedPath?.nextTools)
     .map((tool) => normalizeWhitespace(tool))
     .filter(Boolean)
@@ -253,6 +258,29 @@ const buildWorkflowPolicyPayload = ({ commandName, workflowProfile, preflightSum
   preflight: preflightSummary,
 });
 
+const isRetriableLockError = (error) => {
+  const issue = error?.storageHealth?.issue ?? error?.cause?.storageHealth?.issue ?? null;
+  const retriable = error?.storageHealth?.retriable ?? error?.cause?.storageHealth?.retriable ?? false;
+  const message = String(error?.message ?? error?.cause?.message ?? error ?? '');
+  return retriable || issue === 'locked' || /database is locked|database table is locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(message);
+};
+
+const withRunnerLockRetry = async (operation) => {
+  for (let attempt = 1; attempt <= RUNNER_LOCK_RETRY_ATTEMPTS; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isRetriableLockError(error) || attempt === RUNNER_LOCK_RETRY_ATTEMPTS) {
+        throw error;
+      }
+
+      await delay(RUNNER_LOCK_RETRY_DELAY_MS * attempt);
+    }
+  }
+
+  throw new Error('Task runner lock retry exhausted unexpectedly.');
+};
+
 const recordRunnerMetrics = async ({
   commandName,
   client,
@@ -330,13 +358,13 @@ const runWorkflowCommand = async ({
   });
   const workflowProfile = buildWorkflowPolicyProfile({ commandName });
 
-  const start = await smartTurn({
+  const start = await withRunnerLockRetry(() => smartTurn({
     phase: 'start',
     sessionId,
     prompt: requestedPrompt,
     ensureSession: true,
     maxTokens: START_MAX_TOKENS,
-  });
+  }));
 
   const gate = evaluateRunnerGate({ startResult: start });
   let preflightSummary = null;
@@ -363,7 +391,7 @@ const runWorkflowCommand = async ({
   });
 
   if (gate.requiresDoctor && !allowDegraded) {
-    const doctor = await smartDoctor();
+    const doctor = await withRunnerLockRetry(() => smartDoctor());
     const blockedResult = buildRunnerBlockedResult({
       commandName,
       client,
@@ -423,7 +451,7 @@ const runWorkflowCommand = async ({
 };
 
 const runDoctorCommand = async ({ verifyIntegrity = true, client }) => {
-  const result = await smartDoctor({ verifyIntegrity });
+  const result = await withRunnerLockRetry(() => smartDoctor({ verifyIntegrity }));
   await recordRunnerMetrics({
     commandName: 'doctor',
     client,
@@ -436,7 +464,7 @@ const runDoctorCommand = async ({ verifyIntegrity = true, client }) => {
 };
 
 const runStatusCommand = async ({ format = 'compact', maxItems = 10, client }) => {
-  const result = await smartStatus({ format, maxItems });
+  const result = await withRunnerLockRetry(() => smartStatus({ format, maxItems }));
   await recordRunnerMetrics({
     commandName: 'status',
     client,
@@ -451,13 +479,13 @@ const runCheckpointCommand = async ({
   event = 'milestone',
   update = {},
 }) => {
-  const result = await smartTurn({
+  const result = await withRunnerLockRetry(() => smartTurn({
     phase: 'end',
     sessionId,
     event,
     update,
     maxTokens: END_MAX_TOKENS,
-  });
+  }));
   await recordRunnerMetrics({
     commandName: 'checkpoint',
     client,

package/src/utils/runtime-config.js

@@ -27,14 +27,14 @@ const readEnvValue = (...names) => {
 };
 
 const defaultDevctxRoot = path.resolve(currentDir, '..', '..');
-const defaultProjectRoot = path.resolve(defaultDevctxRoot, '..', '..');
+const defaultProjectRoot = path.resolve(process.cwd());
 const projectRootArg = readArgValue('--project-root');
 const projectRootEnv = readEnvValue('DEVCTX_PROJECT_ROOT', 'MCP_PROJECT_ROOT');
 const rawProjectRoot = projectRootArg ?? projectRootEnv ?? defaultProjectRoot;
 
 export const devctxRoot = defaultDevctxRoot;
 export let projectRoot = path.resolve(rawProjectRoot);
-export const projectRootSource = projectRootArg ? 'argv' : projectRootEnv ? 'env' : 'default';
+export const projectRootSource = projectRootArg ? 'argv' : projectRootEnv ? 'env' : 'cwd';
 
 export const setProjectRoot = (newRoot) => {
   projectRoot = path.resolve(newRoot);