@danielblomma/cortex-mcp 2.1.0 → 2.1.4

package/scaffold/scripts/parsers/csharp.mjs

@@ -173,7 +173,8 @@ export function ensureCSharpParserPublished() {
       "-c", "Release",
       "-o", getPublishDir(),
       "--nologo",
-      "-v", "quiet"
+      "-v", "quiet",
+      "/p:UseAppHost=false"
     ],
     { encoding: "utf8", timeout: 180000 }
   );

package/scaffold/scripts/parsers/javascript/ast.mjs

@@ -35,6 +35,8 @@ base.Class = (node, st, visit) => {
 
 const tsNodeHandlers = {
   TSAsExpression(node, st, visit) { visit(node.expression, st); },
+  TSSatisfiesExpression(node, st, visit) { visit(node.expression, st); },
+  TSTypeAssertion(node, st, visit) { visit(node.expression, st); },
   TSTypeAnnotation(node, st, visit) {
     if (node.typeAnnotation) {
       visit(node.typeAnnotation, st);
@@ -63,15 +65,80 @@ const tsNodeHandlers = {
       visit(node.typeParameters, st);
     }
   },
-  TSInterfaceDeclaration() {},
-  TSTypeAliasDeclaration() {},
-  TSEnumDeclaration() {},
+  TSQualifiedName(node, st, visit) {
+    if (node.left) visit(node.left, st);
+    if (node.right) visit(node.right, st);
+  },
+  TSInterfaceDeclaration(node, st, visit) {
+    if (node.extends) {
+      for (const extendedType of node.extends) {
+        visit(extendedType, st);
+      }
+    }
+    if (node.body) {
+      visit(node.body, st);
+    }
+  },
+  TSInterfaceBody(node, st, visit) {
+    for (const member of node.body || []) {
+      visit(member, st);
+    }
+  },
+  TSTypeAliasDeclaration(node, st, visit) {
+    if (node.typeParameters) {
+      visit(node.typeParameters, st);
+    }
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSEnumDeclaration(node, st, visit) {
+    for (const member of node.members || []) {
+      visit(member, st);
+    }
+  },
+  TSEnumMember(node, st, visit) {
+    if (node.initializer) {
+      visit(node.initializer, st);
+    }
+  },
   TSModuleDeclaration() {},
   TSDeclareFunction() {},
-  TSPropertySignature() {},
-  TSMethodSignature() {},
-  TSIndexSignature() {},
-  TSTypeLiteral() {},
+  TSPropertySignature(node, st, visit) {
+    if (node.computed && node.key) {
+      visit(node.key, st);
+    }
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSMethodSignature(node, st, visit) {
+    if (node.computed && node.key) {
+      visit(node.key, st);
+    }
+    if (node.typeParameters) {
+      visit(node.typeParameters, st);
+    }
+    for (const param of node.params || []) {
+      visit(param, st);
+    }
+    if (node.returnType) {
+      visit(node.returnType, st);
+    }
+  },
+  TSIndexSignature(node, st, visit) {
+    for (const param of node.params || []) {
+      visit(param, st);
+    }
+    if (node.typeAnnotation) {
+      visit(node.typeAnnotation, st);
+    }
+  },
+  TSTypeLiteral(node, st, visit) {
+    for (const member of node.members || node.body || []) {
+      visit(member, st);
+    }
+  },
   TSUnionType(node, st, visit) {
     for (const typeNode of node.types || []) {
       visit(typeNode, st);
@@ -132,9 +199,94 @@ const tsNodeHandlers = {
     }
   },
   TSNonNullExpression(node, st, visit) { visit(node.expression, st); },
-  TSInstantiationExpression(node, st, visit) { visit(node.expression, st); }
+  TSInstantiationExpression(node, st, visit) { visit(node.expression, st); },
+  JSXElement(node, st, visit) {
+    if (node.openingElement) {
+      visit(node.openingElement, st);
+    }
+    for (const child of node.children || []) {
+      visit(child, st);
+    }
+    if (node.closingElement) {
+      visit(node.closingElement, st);
+    }
+  },
+  JSXFragment(node, st, visit) {
+    if (node.openingFragment) {
+      visit(node.openingFragment, st);
+    }
+    for (const child of node.children || []) {
+      visit(child, st);
+    }
+    if (node.closingFragment) {
+      visit(node.closingFragment, st);
+    }
+  },
+  JSXOpeningElement(node, st, visit) {
+    if (node.name) {
+      visit(node.name, st);
+    }
+    for (const attribute of node.attributes || []) {
+      visit(attribute, st);
+    }
+  },
+  JSXClosingElement(node, st, visit) {
+    if (node.name) {
+      visit(node.name, st);
+    }
+  },
+  JSXAttribute(node, st, visit) {
+    if (node.value) {
+      visit(node.value, st);
+    }
+  },
+  JSXExpressionContainer(node, st, visit) {
+    if (node.expression && node.expression.type !== "JSXEmptyExpression") {
+      visit(node.expression, st);
+    }
+  },
+  JSXSpreadAttribute(node, st, visit) {
+    if (node.argument) {
+      visit(node.argument, st);
+    }
+  },
+  JSXMemberExpression(node, st, visit) {
+    if (node.object) {
+      visit(node.object, st);
+    }
+  },
+  JSXNamespacedName(node, st, visit) {
+    if (node.namespace) {
+      visit(node.namespace, st);
+    }
+  }
 };
 
+for (const nodeType of [
+  "JSXClosingFragment",
+  "JSXEmptyExpression",
+  "JSXIdentifier",
+  "JSXOpeningFragment",
+  "JSXText",
+  "TSAnyKeyword",
+  "TSBigIntKeyword",
+  "TSBooleanKeyword",
+  "TSIntrinsicKeyword",
+  "TSNeverKeyword",
+  "TSNullKeyword",
+  "TSNumberKeyword",
+  "TSObjectKeyword",
+  "TSStringKeyword",
+  "TSSymbolKeyword",
+  "TSUndefinedKeyword",
+  "TSUnknownKeyword",
+  "TSVoidKeyword",
+  "TSThisType",
+  "TSLiteralType"
+]) {
+  tsNodeHandlers[nodeType] = () => {};
+}
+
 Object.assign(base, tsNodeHandlers);
 
 export const WALK_BASE = base;

package/scaffold/scripts/parsers/javascript/chunks.mjs

@@ -45,6 +45,18 @@ export function discoverChunks(ast, code, language = "javascript") {
         }
       },
 
+      TSInterfaceDeclaration(node) {
+        pushChunk(extractTypeDeclarationChunk(node, "interface", code));
+      },
+
+      TSTypeAliasDeclaration(node) {
+        pushChunk(extractTypeDeclarationChunk(node, "type", code));
+      },
+
+      TSEnumDeclaration(node) {
+        pushChunk(extractTypeDeclarationChunk(node, "enum", code));
+      },
+
       VariableDeclaration(node) {
         for (const declarator of node.declarations || []) {
           if (!declarator.id || declarator.id.type !== "Identifier" || !declarator.init) {
@@ -100,6 +112,15 @@ function collectExportedNames(ast) {
             exportedNames.add(node.declaration.id.name);
           }
 
+          if (
+            (node.declaration.type === "TSInterfaceDeclaration" ||
+              node.declaration.type === "TSTypeAliasDeclaration" ||
+              node.declaration.type === "TSEnumDeclaration") &&
+            node.declaration.id?.name
+          ) {
+            exportedNames.add(node.declaration.id.name);
+          }
+
           if (node.declaration.type === "VariableDeclaration") {
             for (const declarator of node.declaration.declarations || []) {
               if (declarator.id?.type === "Identifier") {
@@ -292,34 +313,120 @@ function extractClassMethods(classNode, code, language) {
   const className = classNode.id?.name || "UnknownClass";
 
   for (const member of classNode.body.body || []) {
-    if (member.type !== "MethodDefinition" || member.key.type !== "Identifier") {
-      continue;
-    }
+    const methodChunk =
+      member.type === "MethodDefinition"
+        ? extractClassMethodChunk(member, className, code, language)
+        : extractClassFieldFunctionChunk(member, className, code, language);
 
-    const params = (member.value.params || []).map(formatParameterName);
-    const isStatic = member.static === true;
-    const prefix = isStatic ? "static " : "";
-    const bodyStart = findLeadingCommentStart(code, member);
-
-    methods.push({
-      name: `${className}.${member.key.name}`,
-      kind: "method",
-      signature: `${prefix}${member.key.name}(${params.join(", ")})`,
-      body: code.slice(bodyStart, member.end),
-      startLine: member.loc.start.line,
-      endLine: member.loc.end.line,
-      callNode: member.value.body,
-      importNode: member,
-      static: isStatic,
-      async: member.value.async === true,
-      generator: member.value.generator === true,
-      language
-    });
+    if (methodChunk) {
+      methods.push(methodChunk);
+    }
   }
 
   return methods;
 }
 
+function extractClassMethodChunk(member, className, code, language) {
+  const methodName = getPropertyName(member.key, member.computed);
+  if (!methodName) {
+    return null;
+  }
+
+  const params = (member.value.params || []).map(formatParameterName);
+  const isStatic = member.static === true;
+  const prefix = isStatic ? "static " : "";
+  const bodyStart = findLeadingCommentStart(code, member);
+
+  return {
+    name: `${className}.${methodName}`,
+    kind: "method",
+    signature: `${prefix}${methodName}(${params.join(", ")})`,
+    body: code.slice(bodyStart, member.end),
+    startLine: member.loc.start.line,
+    endLine: member.loc.end.line,
+    callNode: member.value.body,
+    importNode: member,
+    static: isStatic,
+    async: member.value.async === true,
+    generator: member.value.generator === true,
+    language
+  };
+}
+
+function extractClassFieldFunctionChunk(member, className, code, language) {
+  if (member.type !== "PropertyDefinition" && member.type !== "FieldDefinition") {
+    return null;
+  }
+
+  const value = member.value;
+  const isFunctionField =
+    value?.type === "FunctionExpression" || value?.type === "ArrowFunctionExpression";
+  if (!isFunctionField) {
+    return null;
+  }
+
+  const fieldName = getPropertyName(member.key, member.computed);
+  if (!fieldName) {
+    return null;
+  }
+
+  const params = (value.params || []).map(formatParameterName);
+  const isStatic = member.static === true;
+  const prefix = isStatic ? "static " : "";
+  const bodyStart = findLeadingCommentStart(code, member);
+
+  return {
+    name: `${className}.${fieldName}`,
+    kind: "method",
+    signature: `${prefix}${fieldName}(${params.join(", ")})`,
+    body: code.slice(bodyStart, member.end),
+    startLine: member.loc.start.line,
+    endLine: member.loc.end.line,
+    callNode: value.body || value,
+    importNode: member,
+    static: isStatic,
+    async: value.async === true,
+    generator: value.generator === true,
+    field: true,
+    language
+  };
+}
+
+function extractTypeDeclarationChunk(node, kind, code) {
+  const name = node.id?.name;
+  if (!name) {
+    return null;
+  }
+
+  const bodyStart = findLeadingCommentStart(code, node);
+  return {
+    name,
+    kind,
+    signature: `${kind} ${name}`,
+    body: code.slice(bodyStart, node.end),
+    startLine: node.loc.start.line,
+    endLine: node.loc.end.line,
+    callNode: node,
+    importNode: node
+  };
+}
+
+function getPropertyName(key, computed = false) {
+  if (!key) {
+    return null;
+  }
+
+  if (!computed && key.type === "Identifier") {
+    return key.name;
+  }
+
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+
+  return null;
+}
+
 function findLeadingCommentStart(code, node) {
   let bodyStart = node.start;
   let lineStart = code.lastIndexOf("\n", node.start - 1) + 1;

package/scaffold/scripts/parsers/javascript/imports.mjs

@@ -103,16 +103,17 @@ function extractReferencedStaticImportSources(bodyNode, bindings) {
     fullAncestor(
       bodyNode,
       (node, state, ancestors) => {
-        if (node.type !== "Identifier") {
+        const localName = getReferencedImportName(node, ancestors);
+        if (!localName) {
           return;
         }
 
-        const source = importsByLocalName.get(node.name);
-        if (!source || !isReferenceIdentifier(node, ancestors)) {
+        const source = importsByLocalName.get(localName);
+        if (!source) {
           return;
         }
 
-        if (resolveIdentifier(node.name, ancestors, scopeGraph)) {
+        if (resolveIdentifier(localName, ancestors, scopeGraph)) {
           return;
         }
 
@@ -127,6 +128,39 @@ function extractReferencedStaticImportSources(bodyNode, bindings) {
   return [...sources].sort();
 }
 
+function getReferencedImportName(node, ancestors) {
+  if (node.type === "Identifier") {
+    return isReferenceIdentifier(node, ancestors) ? node.name : null;
+  }
+
+  if (node.type !== "JSXIdentifier" || isIntrinsicJsxName(node.name)) {
+    return null;
+  }
+
+  const parent = ancestors[ancestors.length - 2] ?? null;
+  if (!parent) {
+    return null;
+  }
+
+  if (parent.type === "JSXOpeningElement" && parent.name === node) {
+    return node.name;
+  }
+
+  if (parent.type === "JSXMemberExpression" && parent.object === node) {
+    return node.name;
+  }
+
+  if (parent.type === "JSXNamespacedName" && parent.namespace === node) {
+    return node.name;
+  }
+
+  return null;
+}
+
+function isIntrinsicJsxName(name) {
+  return /^[a-z]/.test(name);
+}
+
 function extractDynamicImports(bodyNode) {
   if (!bodyNode) {
     return [];

package/scaffold/scripts/parsers/vbnet.mjs

@@ -146,7 +146,8 @@ export function ensureVbNetParserPublished() {
       "-c", "Release",
       "-o", getPublishDir(),
       "--nologo",
-      "-v", "quiet"
+      "-v", "quiet",
+      "/p:UseAppHost=false"
     ],
     { encoding: "utf8", timeout: 180000 }
   );

package/scaffold/scripts/status.sh

@@ -255,23 +255,59 @@ try {
     return raw.split(/\r?\n/)[0].trim();
   };
 
-  const npmCache = path.join(cacheDir, "npm-cache");
-  let latestRaw = "";
+  // The latest-version lookup is a network call; cache it for a day so
+  // repeated bootstraps/status checks stay fast and offline-friendly.
+  const fs = require("node:fs");
+  const versionCheckCache = path.join(cacheDir, "version-check.json");
+  const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+  let latestVersion = null;
   try {
-    latestRaw = execSync("npm view github:DanielBlomma/cortex version --json", {
-      cwd: repoRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8",
-      timeout: 2500,
-      env: { ...process.env, NPM_CONFIG_CACHE: npmCache }
-    }).trim();
-  } catch (error) {
-    console.log(`[status] cortex_update_check=unavailable (${summarizeError(error)})`);
-    process.exit(0);
+    const cached = JSON.parse(fs.readFileSync(versionCheckCache, "utf8"));
+    const age = cached ? Date.now() - cached.checked_at : NaN;
+    if (
+      cached &&
+      typeof cached.latest === "string" &&
+      Number.isFinite(cached.checked_at) &&
+      age >= 0 &&
+      age < VERSION_CHECK_TTL_MS &&
+      parseVersion(cached.latest)
+    ) {
+      latestVersion = cached.latest;
+    }
+  } catch {
+    // No usable cache; fall through to the live lookup.
   }
 
-  const parsedLatest = JSON.parse(latestRaw);
-  const latestVersion = Array.isArray(parsedLatest) ? parsedLatest[parsedLatest.length - 1] : parsedLatest;
+  if (!latestVersion) {
+    const npmCache = path.join(cacheDir, "npm-cache");
+    let latestRaw = "";
+    try {
+      latestRaw = execSync("npm view github:DanielBlomma/cortex version --json", {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf8",
+        timeout: 2500,
+        env: { ...process.env, NPM_CONFIG_CACHE: npmCache }
+      }).trim();
+    } catch (error) {
+      console.log(`[status] cortex_update_check=unavailable (${summarizeError(error)})`);
+      process.exit(0);
+    }
+
+    const parsedLatest = JSON.parse(latestRaw);
+    latestVersion = Array.isArray(parsedLatest) ? parsedLatest[parsedLatest.length - 1] : parsedLatest;
+    if (parseVersion(latestVersion)) {
+      try {
+        fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(
+          versionCheckCache,
+          JSON.stringify({ checked_at: Date.now(), latest: latestVersion })
+        );
+      } catch {
+        // Cache write failures must never break status reporting.
+      }
+    }
+  }
 
   const localParsed = parseVersion(localVersion);
   const latestParsed = parseVersion(latestVersion);