@lark-apaas/fullstack-cli 1.1.69 → 1.1.70-alpha.20261026131749

package/dist/index.js

@@ -7911,6 +7911,101 @@ function hasErrorInStdLines(lines) {
   return lines.some((line) => classifyStdLine(line) === "error");
 }
 
+// src/commands/read-logs/type-check.ts
+var TYPE_CHECK_SCAN_LINES = 2e3;
+var TYPE_CHECK_PREFIX_MAX_LINES = 40;
+var ANSI_PATTERN2 = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+var LEADING_TIMESTAMP_PATTERN = /^\[[^\]]*\]\s?/;
+var SESSION_START_PATTERN = /\bdev:server\b/;
+var CHECKER_INIT_PATTERN = /\bTSC\s+Initializing type checker/;
+var RESULT_PATTERN = /\bTSC\s+Found (\d+) (?:errors?|issues)\b|\bFound (\d+) errors?\. Watching for file changes/;
+var DIAGNOSTIC_PATTERN = /^\S.*\berror TS\d+:/;
+function contentOf(line) {
+  return line.replace(ANSI_PATTERN2, "").replace(LEADING_TIMESTAMP_PATTERN, "");
+}
+function isContinuation(content) {
+  return !content.trim() || /^\s/.test(content) || /^\d+\s/.test(content);
+}
+function findLatestTypeCheck(lines) {
+  let sessionStart = 0;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (SESSION_START_PATTERN.test(contentOf(lines[index] ?? ""))) {
+      sessionStart = index;
+      break;
+    }
+  }
+  let windowStart = sessionStart;
+  let latest = { status: "none" };
+  let previousContent = "";
+  for (let index = sessionStart; index < lines.length; index += 1) {
+    const content = contentOf(lines[index] ?? "");
+    const match = content.match(RESULT_PATTERN);
+    if (!match) {
+      if (content.trim()) previousContent = content;
+      continue;
+    }
+    const errorCount = Number(match[1] ?? match[2]);
+    const isInitSnapshot = errorCount === 0 && CHECKER_INIT_PATTERN.test(previousContent);
+    previousContent = content;
+    if (isInitSnapshot) continue;
+    const blocks = extractDiagnosticBlocks(lines, windowStart, index);
+    latest = errorCount > 0 && blocks.length > 0 ? {
+      status: "failed",
+      errorCount,
+      blocks: blocks.map((block) => ({
+        level: "error",
+        lines: block.lines
+      })),
+      resultLine: lines[index] ?? "",
+      firstLineIndex: blocks[0]?.startIndex ?? index
+    } : { status: "none" };
+    windowStart = index + 1;
+  }
+  return latest;
+}
+function extractDiagnosticBlocks(lines, from, to) {
+  const blocks = [];
+  for (let index = from; index < to; index += 1) {
+    if (!DIAGNOSTIC_PATTERN.test(contentOf(lines[index] ?? ""))) continue;
+    const blockLines = [lines[index] ?? ""];
+    const startIndex = index;
+    while (index + 1 < to) {
+      const next = contentOf(lines[index + 1] ?? "");
+      if (DIAGNOSTIC_PATTERN.test(next) || !isContinuation(next)) break;
+      blockLines.push(lines[index + 1] ?? "");
+      index += 1;
+    }
+    while (blockLines.length > 1 && !contentOf(blockLines[blockLines.length - 1] ?? "").trim()) {
+      blockLines.pop();
+    }
+    blocks.push({ startIndex, lines: blockLines });
+  }
+  return blocks;
+}
+function readServerStdTailForTypeCheck(filePath) {
+  const lines = readFileTailLines(filePath, TYPE_CHECK_SCAN_LINES).map(
+    stripPrefixFromStdLine
+  );
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function buildTypeCheckPrefix(state, totalLines, visibleLineCount) {
+  if (state.status !== "failed") return [];
+  const windowStart = totalLines - visibleLineCount;
+  if (state.firstLineIndex >= windowStart) return [];
+  const shown = [];
+  let shownBlocks = 0;
+  for (const block of state.blocks) {
+    const remaining = TYPE_CHECK_PREFIX_MAX_LINES - shown.length;
+    if (remaining <= 0) break;
+    if (block.lines.length > remaining && shownBlocks > 0) break;
+    shown.push(...block.lines.slice(0, remaining));
+    shownBlocks += 1;
+  }
+  const hint = shownBlocks < state.blocks.length ? `[Type check reported ${state.errorCount} error(s), showing the first ${shownBlocks}; fix them and read again to see the rest]` : `[Type check reported ${state.errorCount} error(s)]`;
+  return [hint, ...shown, state.resultLine];
+}
+
 // src/commands/read-logs/index.ts
 var LOG_TYPES = [
   "server",
@@ -8062,10 +8157,26 @@ async function readLatestLogLinesMeta(options) {
   }
   if (options.type === "server-std") {
     const requestedLevels = normalizeRequestedStdLevels(levels);
-    if (!requestedLevels)
-      return readServerStdSegment(filePath, maxLines, offset);
+    const tail = readServerStdTailForTypeCheck(filePath);
+    const typeCheck = findLatestTypeCheck(tail);
+    if (!requestedLevels) {
+      const segment2 = readServerStdSegment(filePath, maxLines, offset);
+      if (offset > 0) return segment2;
+      return {
+        ...segment2,
+        prefixLines: buildTypeCheckPrefix(
+          typeCheck,
+          tail.length,
+          Math.min(maxLines, segment2.totalLinesCount)
+        )
+      };
+    }
     const segment = readServerStdSegment(filePath, STD_LEVEL_SCAN_LINES, 0);
     const blocks = extractStdDiagnosticBlocks(segment.lines, requestedLevels);
+    const segmentStart = tail.length - Math.min(segment.totalLinesCount, tail.length);
+    if (requestedLevels.has("error") && typeCheck.status === "failed" && typeCheck.firstLineIndex < segmentStart) {
+      blocks.push(...typeCheck.blocks);
+    }
     return {
       lines: paginateStdDiagnosticBlocks(blocks, maxLines, offset),
       totalLinesCount: blocks.reduce(
@@ -8116,7 +8227,12 @@ async function readLatestLogLinesMeta(options) {
   return { lines: [], totalLinesCount: 0 };
 }
 async function readLogsJsonResult(options) {
-  const { lines, totalLinesCount, allLines } = await readLatestLogLinesMeta(options);
+  const {
+    lines,
+    totalLinesCount,
+    allLines,
+    prefixLines = []
+  } = await readLatestLogLinesMeta(options);
   if (options.type === "server-std" || options.type === "client-std" || options.type === "dev" || options.type === "dev-std" || options.type === "install-dep-std") {
     const linesForErrorCheck = allLines ?? lines;
     const stackTracePattern = /\bat\s+\S+\s+\([^)]+:\d+:\d+\)/;
@@ -8129,9 +8245,9 @@ async function readLogsJsonResult(options) {
     const start = Math.max(0, endExclusive - maxLines);
     const paginatedLogs = stdLevelFilteringActive ? lines : filteredLines.slice(start, endExclusive);
     return {
-      hasError: hasErrorInStdLines(linesForErrorCheck),
-      totalLinesCount: stdLevelFilteringActive ? totalLinesCount : filteredLines.length,
-      logs: paginatedLogs
+      hasError: hasErrorInStdLines(linesForErrorCheck) || hasErrorInStdLines(prefixLines),
+      totalLinesCount: (stdLevelFilteringActive ? totalLinesCount : filteredLines.length) + prefixLines.length,
+      logs: [...prefixLines, ...paginatedLogs]
     };
   }
   const logs = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.69",
+  "version": "1.1.70-alpha.20261026131749",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",