@iderouter/index-mcp 0.2.0-beta.1

package/src/resume-seed.js

@@ -0,0 +1,9 @@
+export function shouldTreatAsResumePartialSeed({
+  canReuseFileChunks = false,
+  existingIndexComplete = null,
+  hasResumeSeed = false,
+}) {
+  if (!canReuseFileChunks) return false;
+  if (Boolean(hasResumeSeed)) return true;
+  return existingIndexComplete === false;
+}

package/src/semantic-first-checkpoint.js

@@ -0,0 +1,8 @@
+export function shouldForceFirstSemanticCheckpoint({
+  isResumePartialSeed = false,
+  previousEmbeddedCount = 0,
+  embeddedCount = 0,
+}) {
+  if (!isResumePartialSeed) return false;
+  return Number(previousEmbeddedCount || 0) === 0 && Number(embeddedCount || 0) > 0;
+}

package/src/semantic-slow-path.js

@@ -0,0 +1,10 @@
+export function shouldMarkSingleSemanticSlowPath({
+  jobStatus = "",
+  totalChunks = 0,
+  embeddedCount = 0,
+  currentStep = "",
+}) {
+  if (String(jobStatus || "") !== "indexing") return false;
+  if (!String(currentStep || "").toLowerCase().includes("embedding batch")) return false;
+  return Number(totalChunks || 0) === 1 && Number(embeddedCount || 0) === 0;
+}

package/src/single-chunk-attempt-timeout.js

@@ -0,0 +1,13 @@
+export function resumedSingleChunkAttemptTimeoutMs({
+  source = "",
+  attemptTimeoutMs = 0,
+  priorityTimeoutMs = 0,
+}) {
+  const sourceText = String(source || "");
+  const attemptMs = Math.max(0, Number(attemptTimeoutMs || 0));
+  const priorityMs = Math.max(0, Number(priorityTimeoutMs || 0));
+  if (sourceText.startsWith("previous_failure_fallback_deferred_resume")) {
+    return Math.max(attemptMs, Math.min(attemptMs + 1000, 6000));
+  }
+  return Math.max(attemptMs * 2, priorityMs);
+}

package/src/single-chunk-embedding-content.js

@@ -0,0 +1,26 @@
+export function compactEmbeddingContentForSingleResumeChunk(chunk) {
+  const content = String(chunk?.content || "").trim();
+  if (!content) return content;
+  const lines = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const signature = lines[0] || "";
+  const hintLines = lines
+    .slice(1)
+    .filter((line) => /stream|safety|obfuscation|billing|expr|price|quota|settle|memory|request|model|handler|relay/i.test(line))
+    .slice(0, 2);
+  const compact = [signature, ...hintLines].filter(Boolean).join("\n");
+  if (compact.length <= 96) return compact;
+  return compact.slice(0, 96);
+}
+
+export function shouldUseCompactSingleChunkEmbeddingContent({
+  source = "",
+  chunkCount = 0,
+}) {
+  const sourceText = String(source || "");
+  if (Number(chunkCount || 0) > 1) return false;
+  return sourceText.startsWith("previous_failure_fallback_deferred_resume") ||
+    sourceText.startsWith("priority_usable_strategy");
+}

package/src/single-chunk-embedding-policy.js

@@ -0,0 +1,18 @@
+export function normalizeSingleChunkEmbeddingRequest({
+  source = "",
+  chunkCount = 0,
+  timeoutMs = 0,
+  maxRetries = 0,
+}) {
+  const sourceText = String(source || "");
+  if (sourceText.startsWith("previous_failure_fallback_deferred_resume") && Number(chunkCount || 0) <= 1) {
+    return {
+      timeoutMs: Math.max(Number(timeoutMs || 0), 6000),
+      maxRetries: Math.min(1, Math.max(Number(maxRetries || 0), 0)),
+    };
+  }
+  return {
+    timeoutMs,
+    maxRetries,
+  };
+}

package/src/single-chunk-provider-order.js

@@ -0,0 +1,12 @@
+export function preferredSingleChunkResumeModelFromHealth({
+  candidates = [],
+  cachedHealthModel = "",
+}) {
+  const list = Array.isArray(candidates) ? candidates.filter(Boolean) : [];
+  const cached = String(cachedHealthModel || "").trim();
+  if (cached && list.includes(cached)) {
+    return cached;
+  }
+  const preferred = list.find((candidate) => candidate === "openai/text-embedding-3-small");
+  return preferred || list[0] || null;
+}

package/src/single-chunk-provider-policy.js

@@ -0,0 +1,63 @@
+import { preferredSingleChunkResumeModelFromHealth } from "./single-chunk-provider-order.js";
+
+export function preferredSingleChunkResumeModel({
+  source = "",
+  chunkCount = 0,
+  candidates = [],
+  cachedHealthModel = "",
+  preferredModel = "",
+}) {
+  const sourceText = String(source || "");
+  if (!sourceText.startsWith("previous_failure_fallback_deferred_resume")) return null;
+  if (Number(chunkCount || 0) > 1) return null;
+  const explicitPreferred = String(preferredModel || "").trim();
+  if (explicitPreferred && Array.isArray(candidates) && candidates.includes(explicitPreferred)) {
+    return explicitPreferred;
+  }
+  return preferredSingleChunkResumeModelFromHealth({
+    candidates,
+    cachedHealthModel,
+  });
+}
+
+export function buildSingleChunkResumeAttemptPlan({
+  source = "",
+  chunkCount = 0,
+  candidates = [],
+  preferredModel = "",
+  cachedHealthModel = "",
+  cachedHealthOk = true,
+  cachedHealthLatencyMs = 0,
+  baseTimeoutMs = 0,
+  baseMaxRetries = 0,
+}) {
+  const sourceText = String(source || "");
+  if (!sourceText.startsWith("previous_failure_fallback_deferred_resume")) return [];
+  if (Number(chunkCount || 0) > 1) return [];
+  const list = Array.isArray(candidates) ? candidates.filter(Boolean) : [];
+  if (list.length === 0) return [];
+  const primaryModel = preferredModel || list[0];
+  const secondaryModel = list.find((candidate) => candidate !== primaryModel) || primaryModel;
+  const firstTimeoutMs = Math.min(Math.max(5000, Math.round(Number(baseTimeoutMs || 0) * 0.08)), 5000);
+  const secondTimeoutMs = Math.min(Math.max(6000, Math.round(Number(baseTimeoutMs || 0) * 0.1)), 6000);
+  const attempts = [
+    {
+      model: primaryModel,
+      timeoutMs: firstTimeoutMs,
+      maxRetries: 0,
+    },
+  ];
+  if (
+    secondaryModel !== primaryModel &&
+    String(cachedHealthModel || "").trim() === secondaryModel &&
+    cachedHealthOk !== false &&
+    Math.max(0, Number(cachedHealthLatencyMs || 0)) > 0
+  ) {
+    attempts.push({
+      model: secondaryModel,
+      timeoutMs: secondTimeoutMs,
+      maxRetries: Math.min(1, Math.max(0, Number(baseMaxRetries || 0))),
+    });
+  }
+  return attempts;
+}

package/src/worker-lock-retry.js

@@ -0,0 +1,24 @@
+export function isRetryableIndexLockError(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  return message.includes("Index lock already held for ");
+}
+
+export function shouldRetryWorkerIndexLock({
+  error,
+  retryAttempt = 0,
+  maxRetries = 0,
+}) {
+  if (!isRetryableIndexLockError(error)) return false;
+  return Math.max(0, Number(retryAttempt) || 0) <= Math.max(0, Number(maxRetries) || 0);
+}
+
+export function workerLockRetryDelayMs({
+  retryAttempt = 1,
+  baseMs = 250,
+  maxMs = 4000,
+}) {
+  const attempt = Math.max(1, Number(retryAttempt) || 1);
+  const base = Math.max(1, Number(baseMs) || 1);
+  const cap = Math.max(base, Number(maxMs) || base);
+  return Math.min(cap, base * (2 ** (attempt - 1)));
+}