@contextstream/mcp-server 0.4.62 → 0.4.63

package/dist/index.js

@@ -17229,6 +17229,170 @@ var TASK_HINTS = {
   linked_to_plan: "Task linked to plan. Progress will be tracked."
 };
 
+// src/project-index-utils.ts
+var INDEX_FRESH_HOURS = 1;
+var INDEX_RECENT_HOURS = 24;
+var INDEX_STALE_HOURS = 24 * 7;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function candidateObjects(result) {
+  const root = asRecord(result);
+  const data = asRecord(root?.data);
+  if (data && root) return [data, root];
+  if (data) return [data];
+  if (root) return [root];
+  return [];
+}
+function readBoolean(candidates, key) {
+  for (const candidate of candidates) {
+    const value = candidate[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readNumber(candidates, keys) {
+  for (const candidate of candidates) {
+    for (const key of keys) {
+      const value = candidate[key];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+      }
+      if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+          return parsed;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function readString(candidates, key) {
+  for (const candidate of candidates) {
+    const value = candidate[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function extractIndexTimestamp(result) {
+  const candidates = candidateObjects(result);
+  for (const key of ["last_updated", "indexed_at", "last_indexed"]) {
+    const raw = readString(candidates, key);
+    if (!raw) continue;
+    const parsed = new Date(raw);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function apiResultReportsIndexed(result) {
+  const candidates = candidateObjects(result);
+  const indexed = readBoolean(candidates, "indexed");
+  if (indexed !== void 0) {
+    return indexed;
+  }
+  const indexedFiles = readNumber(candidates, ["indexed_files", "indexed_file_count"]) ?? 0;
+  if (indexedFiles > 0) {
+    return true;
+  }
+  const totalFiles = readNumber(candidates, ["total_files"]) ?? 0;
+  if (totalFiles > 0) {
+    const status = readString(candidates, "status")?.toLowerCase();
+    if (status === "completed" || status === "ready") {
+      return true;
+    }
+  }
+  return false;
+}
+function apiResultIsIndexing(result) {
+  const candidates = candidateObjects(result);
+  const projectIndexState = readString(candidates, "project_index_state")?.toLowerCase();
+  if (projectIndexState === "indexing" || projectIndexState === "committing") {
+    return true;
+  }
+  const status = readString(candidates, "status")?.toLowerCase();
+  if (status === "indexing" || status === "processing") {
+    return true;
+  }
+  const pendingFiles = readNumber(candidates, ["pending_files"]) ?? 0;
+  return pendingFiles > 0;
+}
+function countFromObject(value) {
+  const obj = asRecord(value);
+  if (!obj) return void 0;
+  if (Array.isArray(obj.entries)) {
+    return obj.entries.length;
+  }
+  if (Array.isArray(obj.history)) {
+    return obj.history.length;
+  }
+  return void 0;
+}
+function indexHistoryEntryCount(result) {
+  const rootCount = countFromObject(result);
+  if (typeof rootCount === "number") {
+    return rootCount;
+  }
+  const root = asRecord(result);
+  const dataCount = countFromObject(root?.data);
+  if (typeof dataCount === "number") {
+    return dataCount;
+  }
+  if (Array.isArray(result)) {
+    return result.length;
+  }
+  if (Array.isArray(root?.data)) {
+    return root.data.length;
+  }
+  return 0;
+}
+function classifyIndexFreshness(indexed, ageHours) {
+  if (!indexed) {
+    return "missing";
+  }
+  if (typeof ageHours !== "number" || Number.isNaN(ageHours)) {
+    return "unknown";
+  }
+  if (ageHours <= INDEX_FRESH_HOURS) {
+    return "fresh";
+  }
+  if (ageHours <= INDEX_RECENT_HOURS) {
+    return "recent";
+  }
+  if (ageHours <= INDEX_STALE_HOURS) {
+    return "aging";
+  }
+  return "stale";
+}
+function classifyIndexConfidence(indexed, apiIndexed, locallyIndexed, freshness) {
+  if (!indexed) {
+    return {
+      confidence: "low",
+      reason: "Neither API status nor local index metadata currently indicates a usable index."
+    };
+  }
+  if (apiIndexed && locallyIndexed) {
+    const reason = freshness === "stale" ? "API and local metadata agree, but index age indicates stale coverage." : "API and local metadata agree for this project scope.";
+    return { confidence: "high", reason };
+  }
+  if (apiIndexed || locallyIndexed) {
+    return {
+      confidence: "medium",
+      reason: "Only one source reports index readiness (API vs local metadata)."
+    };
+  }
+  return {
+    confidence: "low",
+    reason: "Index state is inferred but lacks corroborating API/local metadata."
+  };
+}
+
 // src/tools.ts
 function parseBoolEnvDefault(raw, fallback) {
   if (raw === void 0) return fallback;
@@ -25575,6 +25739,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           plan_step_id: external_exports.string().optional().describe("Which plan step this task implements"),
           description: external_exports.string().optional().describe("Description for task"),
           task_status: external_exports.enum(["pending", "in_progress", "completed", "blocked", "cancelled"]).optional().describe("Task status"),
+          status: external_exports.enum(["pending", "in_progress", "completed", "blocked", "cancelled"]).optional().describe("Backward-compatible alias for task_status in task actions"),
           priority: external_exports.enum(["low", "medium", "high", "urgent"]).optional().describe("Task priority"),
           order: external_exports.number().optional().describe("Task order within plan"),
           task_ids: external_exports.array(external_exports.string().uuid()).optional().describe("Task IDs for reorder_tasks"),
@@ -25877,6 +26042,7 @@ ${formatContent(result)}`
             if (!workspaceId) {
               return errorResult("create_task requires workspace_id. Call session_init first.");
             }
+            const requestedTaskStatus = input.task_status ?? input.status;
             const result = await client.createTask({
               workspace_id: workspaceId,
               project_id: projectId,
@@ -25885,7 +26051,7 @@ ${formatContent(result)}`
               description: input.description,
               plan_id: input.plan_id ?? void 0,
               plan_step_id: input.plan_step_id,
-              status: input.task_status,
+              status: requestedTaskStatus,
               priority: input.priority,
               order: input.order,
               code_refs: input.code_refs,
@@ -25913,12 +26079,13 @@ ${formatContent(result)}`
             if (!input.task_id) {
               return errorResult("update_task requires: task_id");
             }
+            const requestedTaskStatus = input.task_status ?? input.status;
             const result = await client.updateTask({
               task_id: input.task_id,
               title: input.title,
               content: input.content,
               description: input.description,
-              status: input.task_status,
+              status: requestedTaskStatus,
               priority: input.priority,
               order: input.order,
               plan_id: input.plan_id,
@@ -25928,11 +26095,11 @@ ${formatContent(result)}`
               blocked_reason: input.blocked_reason
             });
             let taskUpdateHint = "Task updated.";
-            if (input.task_status === "completed") {
+            if (requestedTaskStatus === "completed") {
               taskUpdateHint = TASK_HINTS.completed;
-            } else if (input.task_status === "blocked") {
+            } else if (requestedTaskStatus === "blocked") {
               taskUpdateHint = TASK_HINTS.blocked;
-            } else if (input.task_status === "cancelled") {
+            } else if (requestedTaskStatus === "cancelled") {
               taskUpdateHint = TASK_HINTS.cancelled;
             }
             const resultWithHint = { ...result, hint: taskUpdateHint };
@@ -25955,11 +26122,12 @@ ${formatContent(result)}`
             if (!workspaceId) {
               return errorResult("list_tasks requires workspace_id. Call session_init first.");
             }
+            const requestedTaskStatus = input.task_status ?? input.status;
             const result = await client.listTasks({
               workspace_id: workspaceId,
               project_id: projectId,
               plan_id: input.plan_id ?? void 0,
-              status: input.task_status,
+              status: requestedTaskStatus,
               priority: input.priority,
               limit: input.limit,
               is_personal: input.is_personal
@@ -26246,11 +26414,12 @@ ${formatContent(result)}`
             const teamWorkspacesForTasks = await client.listTeamWorkspaces({ page_size: 100 });
             const workspacesForTasks = teamWorkspacesForTasks?.items || teamWorkspacesForTasks?.data?.items || [];
             const allTasks = [];
+            const requestedTaskStatus = input.task_status ?? input.status;
             for (const ws of workspacesForTasks.slice(0, 10)) {
               try {
                 const tasks = await client.listTasks({
                   workspace_id: ws.id,
-                  status: input.task_status,
+                  status: requestedTaskStatus,
                   limit: input.limit ? Math.ceil(input.limit / workspacesForTasks.length) : 10
                 });
                 const items = tasks?.data?.tasks || tasks?.tasks || tasks?.data?.items || tasks?.items || [];
@@ -26866,8 +27035,7 @@ ${formatContent(result)}`
             for (const [index, candidateId] of candidateIds.entries()) {
               try {
                 const statusResult = await client.projectIndexStatus(candidateId);
-                const data = statusResult?.data ?? statusResult;
-                const apiIndexed = Boolean(data?.indexed);
+                const apiIndexed = apiResultReportsIndexed(statusResult);
                 if (apiIndexed) {
                   selected = { index, projectId: candidateId, result: statusResult, apiIndexed };
                   break;
@@ -26897,7 +27065,17 @@ ${formatContent(result)}`
               });
             }
             const locallyIndexed = localIndexProjectId !== void 0 ? localIndexProjectId === selected.projectId : Boolean(folderPath && await indexedProjectIdForFolder(folderPath));
+            const apiIndexing = apiResultIsIndexing(selected.result);
             const indexed = selected.apiIndexed || locallyIndexed;
+            const indexedAt = extractIndexTimestamp(selected.result);
+            const ageHours = indexedAt !== void 0 ? Math.floor((Date.now() - indexedAt.getTime()) / (1e3 * 60 * 60)) : void 0;
+            const freshness = classifyIndexFreshness(indexed, ageHours);
+            const { confidence: confidenceLevel, reason: confidenceReason } = classifyIndexConfidence(
+              indexed,
+              selected.apiIndexed,
+              locallyIndexed,
+              freshness
+            );
             const response = selected.result && typeof selected.result === "object" ? { ...selected.result } : {};
             const responseData = response.data && typeof response.data === "object" ? { ...response.data } : {};
             responseData.indexed = indexed;
@@ -26909,8 +27087,30 @@ ${formatContent(result)}`
             }
             responseData.resolved_project_id = selected.projectId;
             responseData.resolution_rank = selected.index;
+            responseData.index_freshness = freshness;
+            responseData.index_age_hours = ageHours ?? null;
+            responseData.index_confidence = confidenceLevel;
+            responseData.index_confidence_reason = confidenceReason;
+            responseData.index_timestamp = indexedAt ? indexedAt.toISOString() : null;
+            responseData.index_in_progress = apiIndexing;
             response.data = responseData;
-            const text = indexed ? locallyIndexed && !selected.apiIndexed ? "Project index is ready (local state). Semantic search is available." : "Project index is ready. Semantic search is available." : 'Project index not found. Run project(action="ingest_local", path="<folder>") to start indexing.';
+            let text = "";
+            if (apiIndexing) {
+              text = indexed ? "Project indexing is in progress. Search is using the latest committed generation." : "Project indexing is in progress. Semantic search will be available after the first commit.";
+            } else if (indexed) {
+              text = locallyIndexed && !selected.apiIndexed ? "Project index is ready (local state). Semantic search is available." : "Project index is ready. Semantic search is available.";
+            } else {
+              text = 'Project index not found. Run project(action="ingest_local", path="<folder>") to start indexing.';
+            }
+            const ageDisplay = typeof ageHours === "number" ? `${ageHours}h` : "unknown";
+            text += ` Freshness: ${freshness} (${ageDisplay}). Confidence: ${confidenceLevel}.`;
+            if (confidenceLevel !== "high") {
+              text += ` ${confidenceReason}`;
+            }
+            if (freshness === "stale" || freshness === "missing") {
+              const ingestPath = folderPath || "<folder>";
+              text += ` Refresh with project(action="ingest_local", path="${ingestPath}").`;
+            }
             return {
               content: [{ type: "text", text: `${text}
 
@@ -26933,8 +27133,28 @@ ${formatContent(response)}` }],
               page: input.page,
               limit: input.page_size
             });
+            const count = indexHistoryEntryCount(result);
+            const response = result && typeof result === "object" ? Array.isArray(result) ? [...result] : { ...result } : result;
+            if (response && typeof response === "object" && !Array.isArray(response)) {
+              response.entries_count = count;
+              if (response.data && typeof response.data === "object") {
+                response.data = {
+                  ...response.data,
+                  entries_count: count
+                };
+              }
+            }
+            const structuredHistory = response && typeof response === "object" && !Array.isArray(response) ? response : void 0;
             return {
-              content: [{ type: "text", text: formatContent(result) }]
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${count} index history entries.
+
+${formatContent(response)}`
+                }
+              ],
+              ...structuredHistory ? { structuredContent: structuredHistory } : {}
             };
           }
           case "ingest_local": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.62",
+  "version": "0.4.63",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",