@windsland52/maa-log-tools 0.0.1 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Windsland52
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -9,6 +9,7 @@ Node tools package for Maa log analysis.
   - `analyzeZipBuffer`
   - `analyzeZipFile`
   - `analyzeDirectory`
+- Extract MaaFramework runtime sessions and version evidence from core Logger headers
 - Provide CLI entry (`mla-log-tools`)
 
 `analyzeLogContent` is delegated to `@windsland52/maa-log-runtime` with a local parser/statistics adapter.
@@ -21,16 +22,48 @@ The concrete adapter is provided by `@windsland52/maa-log-adapter`.
   - `analyzeZipBuffer`
   - `analyzeZipFile`
   - `analyzeDirectory`
+  - `loadFrameworkLogSources`
+  - `extractFrameworkSessions`
+  - `resolveFrameworkSessionForTimestamp`
   - `DEFAULT_CORE_PARSE_OPTIONS`
 - `@windsland52/maa-log-tools/node-input`
   - Node file/zip/folder extraction helpers
+  - `LogBundleFocus`
 - `@windsland52/maa-log-tools/cli`
   - CLI entry module
 
+## Focused Loading
+
+`analyzeZipBuffer`, `analyzeZipFile`, `analyzeDirectory`, `extractZipContentFromNodeBuffer`, `extractZipContentFromNodeFile`, and `loadNodeLogDirectory` all accept an optional `focus` selector:
+
+```ts
+{
+  keywords?: string[]
+  started_after?: string
+  started_before?: string
+}
+```
+
+When `focus` is provided, the helpers scan candidate primary and history log files and only merge files whose content matches the keywords and/or timestamp boundaries. If `focus` is omitted, the previous default loading behavior is preserved.
+
 ## CLI
 
 ```bash
-pnpm kernel:cli <path> [--pretty] [--no-events]
+pnpm kernel:cli <path> [--pretty] [--no-events] [--preflight]
 ```
 
 `<path>` can be a log file, a zip file, or a log directory.
+
+The `--preflight` option emits a compact `mla-preflight/v1` compatibility result. It exits
+with 0 when Notify events produce at least one task lifecycle, 3 for an unsupported log format,
+and 2 when the input contains no analyzable log content.
+
+Preflight also emits `frameworkVersionSummary` and `frameworkSessions`. A session starts at an
+exact `[Logger] MAA Process Start` header and gets its version only from `[Logger] Version ...`
+evidence in that session. Every boundary and version occurrence retains its source reference and
+line number. Multiple versions are preserved instead of collapsed, conflicts produce warnings,
+and content before a process-start marker is explicitly marked as a partial file segment.
+
+Use the session containing the relevant failure timestamp when selecting version-matched source.
+`resolveFrameworkSessionForTimestamp` returns a session only when exactly one resolved,
+process-start-bounded interval contains the timestamp; otherwise it returns `null`.

package/dist/cli.d.ts

@@ -1,2 +1,20 @@
 #!/usr/bin/env node
-export {};
+import type { KernelOutput } from '@windsland52/maa-log-kernel/protocol';
+import { type FrameworkSession, type FrameworkSessionExtraction, type FrameworkVersionSummary } from './frameworkVersion';
+export declare const MLA_PREFLIGHT_SCHEMA_VERSION = "mla-preflight/v1";
+export type PreflightReason = 'notify_events_parsed' | 'empty_log' | 'no_notify_events' | 'no_task_lifecycle' | 'no_analyzable_content';
+export interface PreflightOutput {
+    schemaVersion: typeof MLA_PREFLIGHT_SCHEMA_VERSION;
+    status: 'supported' | 'unsupported';
+    reason: PreflightReason;
+    parserVersion: string | null;
+    taskCount: number;
+    eventCount: number;
+    nodeStatisticCount: number;
+    recognitionStatisticCount: number;
+    frameworkVersionSummary: FrameworkVersionSummary;
+    frameworkSessions: FrameworkSession[];
+    warnings: string[];
+}
+export declare const buildPreflightOutput: (output: KernelOutput | null, framework?: FrameworkSessionExtraction) => PreflightOutput;
+export declare const main: () => Promise<void>;

package/dist/cli.js

@@ -2,16 +2,19 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { loadFrameworkLogSources } from './frameworkInput.js';
+import { extractFrameworkSessions, } from './frameworkVersion.js';
 import { readNodeTextFileContent } from './nodeInput.js';
 import { analyzeLogContent, analyzeDirectory, analyzeZipFile, } from './index.js';
 const printUsage = () => {
-    console.error('Usage: mla-log-tools <path> [--pretty] [--no-events]');
+    console.error('Usage: mla-log-tools <path> [--pretty] [--no-events] [--preflight]');
     console.error('  <path>: log file path, zip path, or log directory path');
 };
 const parseArgs = (argv) => {
     let targetPath = null;
     let pretty = false;
     let noEvents = false;
+    let preflight = false;
     for (const arg of argv) {
         if (arg === '--pretty') {
             pretty = true;
@@ -21,6 +24,10 @@ const parseArgs = (argv) => {
             noEvents = true;
             continue;
         }
+        if (arg === '--preflight') {
+            preflight = true;
+            continue;
+        }
         if (arg === '--help' || arg === '-h') {
             printUsage();
             process.exit(0);
@@ -29,7 +36,7 @@ const parseArgs = (argv) => {
             targetPath = arg;
         }
     }
-    return { targetPath, pretty, noEvents };
+    return { targetPath, pretty, noEvents, preflight };
 };
 const renderOutput = (output, pretty, noEvents) => {
     const payload = noEvents
@@ -37,14 +44,60 @@ const renderOutput = (output, pretty, noEvents) => {
         : output;
     return JSON.stringify(payload, null, pretty ? 2 : 0);
 };
-const main = async () => {
-    const { targetPath, pretty, noEvents } = parseArgs(process.argv.slice(2));
+export const MLA_PREFLIGHT_SCHEMA_VERSION = 'mla-preflight/v1';
+const EMPTY_FRAMEWORK_EXTRACTION = {
+    sessions: [],
+    summary: { status: 'none', versions: [] },
+    warnings: [],
+};
+export const buildPreflightOutput = (output, framework = EMPTY_FRAMEWORK_EXTRACTION) => {
+    if (!output) {
+        return {
+            schemaVersion: MLA_PREFLIGHT_SCHEMA_VERSION,
+            status: 'unsupported',
+            reason: 'no_analyzable_content',
+            parserVersion: null,
+            taskCount: 0,
+            eventCount: 0,
+            nodeStatisticCount: 0,
+            recognitionStatisticCount: 0,
+            frameworkVersionSummary: framework.summary,
+            frameworkSessions: framework.sessions,
+            warnings: framework.warnings,
+        };
+    }
+    const reason = output.events.length > 0
+        ? output.tasks.length > 0
+            ? 'notify_events_parsed'
+            : 'no_task_lifecycle'
+        : output.warnings.includes('Empty log content.')
+            ? 'empty_log'
+            : 'no_notify_events';
+    return {
+        schemaVersion: MLA_PREFLIGHT_SCHEMA_VERSION,
+        status: reason === 'notify_events_parsed' ? 'supported' : 'unsupported',
+        reason,
+        parserVersion: output.meta.parserVersion,
+        taskCount: output.tasks.length,
+        eventCount: output.events.length,
+        nodeStatisticCount: output.stats.nodes.length,
+        recognitionStatisticCount: output.stats.recognitionActions.length,
+        frameworkVersionSummary: framework.summary,
+        frameworkSessions: framework.sessions,
+        warnings: [...output.warnings, ...framework.warnings],
+    };
+};
+export const main = async () => {
+    const { targetPath, pretty, noEvents, preflight, } = parseArgs(process.argv.slice(2));
     if (!targetPath) {
         printUsage();
         process.exit(1);
     }
     const resolvedPath = path.resolve(targetPath);
     const targetStat = await stat(resolvedPath);
+    const framework = preflight
+        ? extractFrameworkSessions(await loadFrameworkLogSources(resolvedPath))
+        : EMPTY_FRAMEWORK_EXTRACTION;
     let result = null;
     if (targetStat.isDirectory()) {
         result = await analyzeDirectory({ directoryPath: resolvedPath });
@@ -57,9 +110,22 @@ const main = async () => {
         result = await analyzeLogContent({ content });
     }
     if (!result) {
+        if (preflight) {
+            process.stdout.write(JSON.stringify(buildPreflightOutput(null, framework), null, pretty ? 2 : 0));
+            process.stdout.write('\n');
+        }
         console.error('No analyzable log content found in the provided path.');
         process.exit(2);
     }
+    if (preflight) {
+        const output = buildPreflightOutput(result, framework);
+        process.stdout.write(JSON.stringify(output, null, pretty ? 2 : 0));
+        process.stdout.write('\n');
+        if (output.status === 'unsupported') {
+            process.exit(3);
+        }
+        return;
+    }
     process.stdout.write(renderOutput(result, pretty, noEvents));
     process.stdout.write('\n');
 };

package/dist/frameworkInput.d.ts

@@ -0,0 +1,2 @@
+import type { FrameworkLogSource } from './frameworkVersion';
+export declare const loadFrameworkLogSources: (targetPath: string) => Promise<FrameworkLogSource[]>;

package/dist/frameworkInput.js

@@ -0,0 +1,124 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { unzipSync } from 'fflate';
+import { readNodeTextFileContent } from './nodeInput.js';
+const MAIN_LOG_NAMES = ['maafw.log', 'maa.log'];
+const BAK_LOG_NAMES = ['maafw.bak.log', 'maa.bak.log'];
+const toPosixPath = (value) => value.replace(/\\/g, '/');
+const decodeBytes = (bytes) => {
+    for (const encoding of ['utf-8', 'gbk', 'gb18030', 'gb2312']) {
+        try {
+            return new TextDecoder(encoding, { fatal: true }).decode(bytes);
+        }
+        catch {
+            continue;
+        }
+    }
+    return new TextDecoder('utf-8').decode(bytes);
+};
+const findEntryPath = (paths, target) => {
+    const normalizedTarget = toPosixPath(target).toLowerCase();
+    return paths.find((candidate) => toPosixPath(candidate).toLowerCase() === normalizedTarget) ?? null;
+};
+const findZipBasePath = (paths) => {
+    for (const candidate of paths) {
+        const normalized = toPosixPath(candidate);
+        const lowerName = path.posix.basename(normalized).toLowerCase();
+        if (!MAIN_LOG_NAMES.includes(lowerName))
+            continue;
+        const parent = path.posix.dirname(normalized);
+        return parent === '.' ? '' : parent;
+    }
+    return null;
+};
+const loadZipSources = async (zipPath) => {
+    const files = unzipSync(new Uint8Array(await readFile(zipPath)));
+    const paths = Object.keys(files);
+    const basePath = findZipBasePath(paths);
+    if (basePath == null)
+        return [];
+    const selected = [];
+    for (const name of [...BAK_LOG_NAMES, ...MAIN_LOG_NAMES]) {
+        const candidate = findEntryPath(paths, basePath ? `${basePath}/${name}` : name);
+        if (candidate && !selected.includes(candidate))
+            selected.push(candidate);
+        if (candidate && MAIN_LOG_NAMES.includes(name))
+            break;
+    }
+    return selected.flatMap((entryPath) => {
+        const bytes = files[entryPath];
+        if (!bytes)
+            return [];
+        const normalized = toPosixPath(entryPath);
+        return [{
+                path: normalized,
+                name: path.posix.basename(normalized),
+                content: decodeBytes(bytes),
+                reference: `zip:${toPosixPath(zipPath)}#${normalized}`,
+            }];
+    });
+};
+const pathExists = async (candidate) => {
+    try {
+        await stat(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const findDebugDirectory = async (root) => {
+    for (const name of MAIN_LOG_NAMES) {
+        if (await pathExists(path.join(root, name)))
+            return root;
+    }
+    const directDebug = path.join(root, 'debug');
+    for (const name of MAIN_LOG_NAMES) {
+        if (await pathExists(path.join(directDebug, name)))
+            return directDebug;
+    }
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const found = await findDebugDirectory(path.join(root, entry.name));
+        if (found)
+            return found;
+    }
+    return null;
+};
+const firstExisting = async (root, names) => {
+    for (const name of names) {
+        const candidate = path.join(root, name);
+        if (await pathExists(candidate))
+            return candidate;
+    }
+    return null;
+};
+const loadDirectorySources = async (directoryPath) => {
+    const debugPath = await findDebugDirectory(directoryPath);
+    if (!debugPath)
+        return [];
+    const selected = [
+        await firstExisting(debugPath, BAK_LOG_NAMES),
+        await firstExisting(debugPath, MAIN_LOG_NAMES),
+    ].filter((candidate) => candidate != null);
+    return Promise.all(selected.map(async (absolutePath) => ({
+        path: toPosixPath(path.relative(debugPath, absolutePath)),
+        name: path.basename(absolutePath),
+        content: await readNodeTextFileContent(absolutePath),
+        reference: `file:${toPosixPath(absolutePath)}`,
+    })));
+};
+export const loadFrameworkLogSources = async (targetPath) => {
+    const targetStat = await stat(targetPath);
+    if (targetStat.isDirectory())
+        return loadDirectorySources(targetPath);
+    if (targetPath.toLowerCase().endsWith('.zip'))
+        return loadZipSources(targetPath);
+    return [{
+            path: toPosixPath(targetPath),
+            name: path.basename(targetPath),
+            content: await readNodeTextFileContent(targetPath),
+            reference: `file:${toPosixPath(targetPath)}`,
+        }];
+};

package/dist/frameworkVersion.d.ts

@@ -0,0 +1,36 @@
+export interface FrameworkLogSource {
+    path: string;
+    name: string;
+    content: string;
+    reference: string;
+}
+export interface FrameworkLogPosition {
+    source: string;
+    path: string;
+    line: number;
+    timestamp: string | null;
+}
+export interface FrameworkVersionEvidence extends FrameworkLogPosition {
+    version: string;
+}
+export interface FrameworkSession {
+    sessionId: string;
+    startKind: 'process_start' | 'partial_file';
+    status: 'resolved' | 'missing_version' | 'conflict';
+    version: string | null;
+    versions: string[];
+    start: FrameworkLogPosition;
+    end: FrameworkLogPosition;
+    versionEvidence: FrameworkVersionEvidence[];
+}
+export interface FrameworkVersionSummary {
+    status: 'none' | 'single' | 'multiple' | 'conflict';
+    versions: string[];
+}
+export interface FrameworkSessionExtraction {
+    sessions: FrameworkSession[];
+    summary: FrameworkVersionSummary;
+    warnings: string[];
+}
+export declare const extractFrameworkSessions: (sources: readonly FrameworkLogSource[]) => FrameworkSessionExtraction;
+export declare const resolveFrameworkSessionForTimestamp: (extraction: FrameworkSessionExtraction, timestamp: string) => FrameworkSession | null;

package/dist/frameworkVersion.js

@@ -0,0 +1,126 @@
+const PROCESS_START_PATTERN = /\]\[Logger\]\s+MAA Process Start(?:\s|$)/;
+const VERSION_PATTERN = /\]\[Logger\]\s+Version\s+(v\d+(?:\.\d+)+(?:[-+][0-9A-Za-z.-]+)?)(?:\s|$)/;
+const TIMESTAMP_PATTERN = /^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\]/;
+const splitLines = (content) => {
+    const lines = content.split(/\r?\n/);
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+};
+const timestampOf = (line) => {
+    if (!line)
+        return null;
+    return line.match(TIMESTAMP_PATTERN)?.[1] ?? null;
+};
+const position = (source, lines, lineIndex) => ({
+    source: source.reference,
+    path: source.path,
+    line: lineIndex + 1,
+    timestamp: timestampOf(lines[lineIndex]),
+});
+const findTimestamp = (lines, startIndex, endIndex, direction) => {
+    for (let index = direction === 1 ? startIndex : endIndex; index >= startIndex && index <= endIndex; index += direction) {
+        const timestamp = timestampOf(lines[index]);
+        if (timestamp)
+            return timestamp;
+    }
+    return null;
+};
+const buildSession = (source, lines, startIndex, endIndex, startKind, sessionIndex) => {
+    const versionEvidence = [];
+    for (let index = startIndex; index <= endIndex; index += 1) {
+        const match = lines[index]?.match(VERSION_PATTERN);
+        const version = match?.[1];
+        if (!version)
+            continue;
+        versionEvidence.push({
+            ...position(source, lines, index),
+            version,
+        });
+    }
+    const versions = [...new Set(versionEvidence.map((item) => item.version))];
+    const status = versions.length === 0
+        ? 'missing_version'
+        : versions.length === 1
+            ? 'resolved'
+            : 'conflict';
+    const start = position(source, lines, startIndex);
+    start.timestamp = findTimestamp(lines, startIndex, endIndex, 1);
+    const end = position(source, lines, endIndex);
+    end.timestamp = findTimestamp(lines, startIndex, endIndex, -1);
+    return {
+        sessionId: `framework-session-${sessionIndex}`,
+        startKind,
+        status,
+        version: status === 'resolved' ? (versions[0] ?? null) : null,
+        versions,
+        start,
+        end,
+        versionEvidence,
+    };
+};
+export const extractFrameworkSessions = (sources) => {
+    const sessions = [];
+    for (const source of sources) {
+        const lines = splitLines(source.content);
+        if (lines.length === 0)
+            continue;
+        const processStarts = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            if (PROCESS_START_PATTERN.test(lines[index] ?? ''))
+                processStarts.push(index);
+        }
+        const firstProcessStart = processStarts[0];
+        const hasPartialPrefix = firstProcessStart != null
+            && firstProcessStart > 0
+            && lines.slice(0, firstProcessStart).some((line) => (VERSION_PATTERN.test(line) || line.includes('!!!OnEventNotify!!!')));
+        const boundaries = processStarts.length === 0 || hasPartialPrefix
+            ? [0, ...processStarts]
+            : processStarts;
+        for (let index = 0; index < boundaries.length; index += 1) {
+            const startIndex = boundaries[index];
+            if (startIndex == null)
+                continue;
+            const nextStart = boundaries[index + 1];
+            const endIndex = nextStart == null ? lines.length - 1 : nextStart - 1;
+            const isProcessStart = processStarts.includes(startIndex);
+            sessions.push(buildSession(source, lines, startIndex, endIndex, isProcessStart ? 'process_start' : 'partial_file', sessions.length + 1));
+        }
+    }
+    const versions = [...new Set(sessions.flatMap((session) => session.versions))];
+    const hasConflict = sessions.some((session) => session.status === 'conflict');
+    const summary = {
+        status: hasConflict
+            ? 'conflict'
+            : versions.length === 0
+                ? 'none'
+                : versions.length === 1
+                    ? 'single'
+                    : 'multiple',
+        versions,
+    };
+    const warnings = [];
+    if (summary.status === 'multiple') {
+        warnings.push(`Multiple MaaFramework versions found in selected logs: ${versions.join(', ')}.`);
+    }
+    if (summary.status === 'conflict') {
+        warnings.push('Conflicting MaaFramework version headers found within a runtime session.');
+    }
+    if (sessions.some((session) => session.startKind === 'partial_file')) {
+        warnings.push('Some core log content starts without a MAA Process Start marker; its session boundary is partial.');
+    }
+    if (sessions.some((session) => session.status === 'missing_version')) {
+        warnings.push('Some MaaFramework runtime sessions do not contain a Logger version header.');
+    }
+    return { sessions, summary, warnings };
+};
+export const resolveFrameworkSessionForTimestamp = (extraction, timestamp) => {
+    const candidates = extraction.sessions.filter((session) => {
+        if (session.status !== 'resolved' || session.startKind !== 'process_start')
+            return false;
+        const start = session.start.timestamp;
+        const end = session.end.timestamp;
+        return start != null && end != null && timestamp >= start && timestamp <= end;
+    });
+    return candidates.length === 1 ? (candidates[0] ?? null) : null;
+};

package/dist/index.d.ts

@@ -1,19 +1,23 @@
 import type { KernelOutput } from '@windsland52/maa-log-kernel';
 import type { AnalyzeLogContentInput, ParseFileOptions } from '@windsland52/maa-log-runtime';
+import { type LogBundleFocus } from './nodeInput';
 type ParseOptions = ParseFileOptions;
 export interface AnalyzeZipBufferInput {
     zipData: Uint8Array;
     sourceRef?: string;
+    focus?: LogBundleFocus;
     parseOptions?: ParseOptions;
     parserVersion?: string;
 }
 export interface AnalyzeZipFileInput {
     zipFilePath: string;
+    focus?: LogBundleFocus;
     parseOptions?: ParseOptions;
     parserVersion?: string;
 }
 export interface AnalyzeDirectoryInput {
     directoryPath: string;
+    focus?: LogBundleFocus;
     parseOptions?: ParseOptions;
     parserVersion?: string;
 }
@@ -24,3 +28,5 @@ export declare const analyzeDirectory: (input: AnalyzeDirectoryInput) => Promise
 export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
 export type { AnalyzeLogContentInput, ParseFileOptions } from '@windsland52/maa-log-runtime';
 export * from './nodeInput';
+export * from './frameworkInput';
+export * from './frameworkVersion';

package/dist/index.js

@@ -8,7 +8,9 @@ export const analyzeLogContent = async (input) => {
     });
 };
 export const analyzeZipBuffer = async (input) => {
-    const extracted = extractZipContentFromNodeBuffer(input.zipData, input.sourceRef);
+    const extracted = extractZipContentFromNodeBuffer(input.zipData, input.sourceRef, {
+        focus: input.focus,
+    });
     if (!extracted)
         return null;
     return analyzeLogContent({
@@ -21,7 +23,9 @@ export const analyzeZipBuffer = async (input) => {
     });
 };
 export const analyzeZipFile = async (input) => {
-    const extracted = await extractZipContentFromNodeFile(input.zipFilePath);
+    const extracted = await extractZipContentFromNodeFile(input.zipFilePath, {
+        focus: input.focus,
+    });
     if (!extracted)
         return null;
     return analyzeLogContent({
@@ -34,7 +38,9 @@ export const analyzeZipFile = async (input) => {
     });
 };
 export const analyzeDirectory = async (input) => {
-    const extracted = await loadNodeLogDirectory(input.directoryPath);
+    const extracted = await loadNodeLogDirectory(input.directoryPath, {
+        focus: input.focus,
+    });
     if (!extracted)
         return null;
     return analyzeLogContent({
@@ -48,3 +54,5 @@ export const analyzeDirectory = async (input) => {
 };
 export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
 export * from './nodeInput.js';
+export * from './frameworkInput.js';
+export * from './frameworkVersion.js';

package/dist/nodeExecutionTimeline.js

@@ -3,7 +3,7 @@ import { sortNodesByGlobalExecutionOrder } from './taskExecutionOrder.js';
 const isNodeActionFailed = (node) => {
     if (node.action_details && node.action_details.success === false)
         return true;
-    return (node.node_flow || []).some((item) => item.type === 'action' && item.status === 'failed');
+    return (node.node_flow || []).some((item) => (item.type === 'action' || item.type === 'action_node') && item.status === 'failed');
 };
 export const buildNodeExecutionTimeline = (nodes, options = {}) => {
     const originalIndexByNode = new Map();

package/dist/nodeInput.d.ts

@@ -11,7 +11,18 @@ export interface NodeExtractedLogContent {
     waitFreezesImages: Map<string, string>;
     textFiles: KernelTextFile[];
 }
+export interface LogBundleFocus {
+    keywords?: string[];
+    started_after?: string;
+    started_before?: string;
+}
+export interface ExtractZipContentOptions {
+    focus?: LogBundleFocus;
+}
+export interface LoadNodeLogDirectoryOptions {
+    focus?: LogBundleFocus;
+}
 export declare const readNodeTextFileContent: (filePath: string) => Promise<string>;
-export declare const extractZipContentFromNodeBuffer: (zipData: Uint8Array, sourceRef?: string) => NodeExtractedLogContent | null;
-export declare const extractZipContentFromNodeFile: (zipFilePath: string) => Promise<NodeExtractedLogContent | null>;
-export declare const loadNodeLogDirectory: (inputDirectoryPath: string) => Promise<NodeExtractedLogContent | null>;
+export declare const extractZipContentFromNodeBuffer: (zipData: Uint8Array, sourceRef?: string, options?: ExtractZipContentOptions) => NodeExtractedLogContent | null;
+export declare const extractZipContentFromNodeFile: (zipFilePath: string, options?: ExtractZipContentOptions) => Promise<NodeExtractedLogContent | null>;
+export declare const loadNodeLogDirectory: (inputDirectoryPath: string, options?: LoadNodeLogDirectoryOptions) => Promise<NodeExtractedLogContent | null>;

package/dist/nodeInput.js

@@ -4,16 +4,24 @@ import { unzipSync } from 'fflate';
 const MAIN_LOG_NAMES = ['maa.log', 'maafw.log'];
 const BAK_LOG_NAMES = ['maa.bak.log', 'maafw.bak.log'];
 const SEARCH_TEXT_EXTENSIONS = ['.log', '.txt', '.jsonl'];
-const PRIMARY_LOG_NAME_SET = new Set([
-    ...MAIN_LOG_NAMES,
-    ...BAK_LOG_NAMES,
-].map((name) => name.toLowerCase()));
+const MAIN_LOG_NAME_SET = new Set(MAIN_LOG_NAMES.map((name) => name.toLowerCase()));
+const HISTORY_LOG_NAME_PATTERNS = [
+    /^maa\.bak(?:\..+)?\.log$/i,
+    /^maafw\.bak(?:\..+)?\.log$/i,
+];
 const toPosixPath = (value) => value.replace(/\\/g, '/');
 const normalizeLowerPath = (value) => toPosixPath(value).toLowerCase();
 const isSearchTextFile = (normalizedPath) => {
     const lower = normalizedPath.toLowerCase();
     return SEARCH_TEXT_EXTENSIONS.some((ext) => lower.endsWith(ext));
 };
+const isHistoryLogName = (fileName) => {
+    return HISTORY_LOG_NAME_PATTERNS.some((pattern) => pattern.test(fileName));
+};
+const isCoreLogName = (fileName) => {
+    const lower = fileName.toLowerCase();
+    return MAIN_LOG_NAME_SET.has(lower) || isHistoryLogName(lower);
+};
 const decodeNodeBytes = (bytes) => {
     const encodings = ['utf-8', 'gbk', 'gb18030', 'gb2312'];
     for (const encoding of encodings) {
@@ -84,13 +92,11 @@ const isNeededZipEntry = (entryPath) => {
     const name = lower.slice(lower.lastIndexOf('/') + 1);
     if (isSearchTextFile(lower))
         return true;
-    if (MAIN_LOG_NAMES.includes(name))
+    if (isCoreLogName(name))
         return true;
-    if (BAK_LOG_NAMES.includes(name))
+    if ((lower.includes('/on_error/') || lower.startsWith('on_error/')) && lower.endsWith('.png'))
         return true;
-    if (lower.includes('/on_error/') && lower.endsWith('.png'))
-        return true;
-    if (lower.includes('/vision/') && lower.endsWith('.jpg'))
+    if ((lower.includes('/vision/') || lower.startsWith('vision/')) && lower.endsWith('.jpg'))
         return true;
     return false;
 };
@@ -100,11 +106,132 @@ const toZipReference = (sourceRef, entryPath) => {
 const toFileReference = (absolutePath) => {
     return `file:${toPosixPath(absolutePath)}`;
 };
+const isRelativeImagePath = (relativePath, directory, extension) => {
+    const normalized = relativePath.toLowerCase();
+    return normalized === `${directory}${extension}`
+        || normalized.startsWith(`${directory}/`)
+        || normalized.includes(`/${directory}/`);
+};
+const normalizeTimestampBoundary = (value) => {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    return trimmed.includes('.') ? trimmed : `${trimmed}.000`;
+};
+const extractTimestamps = (content) => {
+    const matches = content.match(/\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\]/g) ?? [];
+    return matches
+        .map((item) => item.slice(1, -1))
+        .map((item) => normalizeTimestampBoundary(item) ?? item);
+};
+const contentMatchesFocus = (content, focus) => {
+    const keywords = (focus.keywords ?? []).filter((keyword) => keyword.trim().length > 0);
+    if (keywords.length > 0 && !keywords.some((keyword) => content.includes(keyword))) {
+        return false;
+    }
+    const startedAfter = normalizeTimestampBoundary(focus.started_after);
+    const startedBefore = normalizeTimestampBoundary(focus.started_before);
+    if (!startedAfter && !startedBefore) {
+        return true;
+    }
+    return extractTimestamps(content).some((timestamp) => {
+        if (startedAfter && timestamp < startedAfter) {
+            return false;
+        }
+        if (startedBefore && timestamp > startedBefore) {
+            return false;
+        }
+        return true;
+    });
+};
+const joinMergedContent = (chunks) => {
+    return chunks.reduce((result, chunk) => {
+        if (chunk.length === 0)
+            return result;
+        if (result.length === 0)
+            return chunk;
+        return result.endsWith('\n') ? `${result}${chunk}` : `${result}\n${chunk}`;
+    }, '');
+};
+const rankLogPath = (filePath) => {
+    const baseName = path.basename(filePath).toLowerCase();
+    if (baseName === 'maafw.bak.log' || baseName.startsWith('maafw.bak.')) {
+        return 0;
+    }
+    if (baseName === 'maa.bak.log' || baseName.startsWith('maa.bak.')) {
+        return 1;
+    }
+    if (baseName === 'maafw.log') {
+        return 2;
+    }
+    if (baseName === 'maa.log') {
+        return 3;
+    }
+    return 10;
+};
+const sortLogPaths = (paths) => {
+    return [...paths].sort((left, right) => {
+        const rankDiff = rankLogPath(left) - rankLogPath(right);
+        if (rankDiff !== 0)
+            return rankDiff;
+        return left.localeCompare(right);
+    });
+};
+const collectFocusedFileContents = async (logPaths, focus) => {
+    const chunks = [];
+    for (const logPath of sortLogPaths(logPaths)) {
+        const content = await readNodeTextFileContent(logPath);
+        if (!contentMatchesFocus(content, focus))
+            continue;
+        chunks.push(content);
+    }
+    return joinMergedContent(chunks);
+};
+const collectFocusedZipContents = (entries, paths, basePath, focus) => {
+    const normalizedBasePath = normalizeLowerPath(basePath);
+    const candidatePaths = sortLogPaths(paths.filter((entryPath) => {
+        const normalizedPath = toPosixPath(entryPath);
+        const lastSlash = normalizedPath.lastIndexOf('/');
+        const parentPath = lastSlash === -1 ? '' : normalizedPath.slice(0, lastSlash);
+        if (normalizeLowerPath(parentPath) !== normalizedBasePath) {
+            return false;
+        }
+        const fileName = normalizedPath.slice(lastSlash + 1);
+        return isCoreLogName(fileName);
+    }));
+    const chunks = [];
+    for (const entryPath of candidatePaths) {
+        const bytes = entries[entryPath];
+        if (!bytes)
+            continue;
+        const content = decodeNodeBytes(bytes);
+        if (!contentMatchesFocus(content, focus))
+            continue;
+        chunks.push(content);
+    }
+    return joinMergedContent(chunks);
+};
+const buildDefaultZipContent = (entries, paths, basePath) => {
+    const bakLogName = BAK_LOG_NAMES.find((name) => findZipEntry(entries, paths, joinPath(basePath, name)));
+    const mainLogName = MAIN_LOG_NAMES.find((name) => findZipEntry(entries, paths, joinPath(basePath, name)));
+    const bakData = bakLogName ? findZipEntry(entries, paths, joinPath(basePath, bakLogName)) : null;
+    const mainData = mainLogName ? findZipEntry(entries, paths, joinPath(basePath, mainLogName)) : null;
+    const chunks = [];
+    if (bakData) {
+        chunks.push(decodeNodeBytes(bakData));
+    }
+    if (mainData) {
+        chunks.push(decodeNodeBytes(mainData));
+    }
+    return joinMergedContent(chunks);
+};
 export const readNodeTextFileContent = async (filePath) => {
     const bytes = await readFile(filePath);
     return decodeNodeBytes(new Uint8Array(bytes));
 };
-export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip') => {
+export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip', options = {}) => {
     const files = unzipSync(zipData, {
         filter: (entry) => isNeededZipEntry(entry.name),
     });
@@ -112,19 +239,9 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
     const basePath = findBaseDirectory(paths);
     if (basePath == null)
         return null;
-    const bakLogName = BAK_LOG_NAMES.find((name) => findZipEntry(files, paths, joinPath(basePath, name)));
-    const mainLogName = MAIN_LOG_NAMES.find((name) => findZipEntry(files, paths, joinPath(basePath, name)));
-    const bakData = bakLogName ? findZipEntry(files, paths, joinPath(basePath, bakLogName)) : null;
-    const mainData = mainLogName ? findZipEntry(files, paths, joinPath(basePath, mainLogName)) : null;
-    let content = '';
-    if (bakData) {
-        content += decodeNodeBytes(bakData);
-    }
-    if (mainData) {
-        if (content && !content.endsWith('\n'))
-            content += '\n';
-        content += decodeNodeBytes(mainData);
-    }
+    const content = options.focus
+        ? collectFocusedZipContents(files, paths, basePath, options.focus)
+        : buildDefaultZipContent(files, paths, basePath);
     if (!content)
         return null;
     const errorImages = new Map();
@@ -153,24 +270,26 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
                 waitFreezesImages.set(waitKey, toZipReference(sourceRef, normalizedPath));
             }
         }
-        if (isSearchTextFile(normalizedPath)) {
-            const fileData = files[currentPath];
-            if (!fileData)
-                continue;
-            textFiles.push({
-                path: normalizedPath,
-                name: fileName,
-                content: decodeNodeBytes(fileData),
-                reference: toZipReference(sourceRef, normalizedPath),
-            });
-        }
+        if (!isSearchTextFile(normalizedPath))
+            continue;
+        if (isCoreLogName(fileName))
+            continue;
+        const fileData = files[currentPath];
+        if (!fileData)
+            continue;
+        textFiles.push({
+            path: normalizedPath,
+            name: fileName,
+            content: decodeNodeBytes(fileData),
+            reference: toZipReference(sourceRef, normalizedPath),
+        });
     }
     textFiles.sort((a, b) => a.path.localeCompare(b.path));
     return { content, errorImages, visionImages, waitFreezesImages, textFiles };
 };
-export const extractZipContentFromNodeFile = async (zipFilePath) => {
+export const extractZipContentFromNodeFile = async (zipFilePath, options = {}) => {
     const bytes = await readFile(zipFilePath);
-    return extractZipContentFromNodeBuffer(new Uint8Array(bytes), zipFilePath);
+    return extractZipContentFromNodeBuffer(new Uint8Array(bytes), zipFilePath, options);
 };
 const pathExists = async (targetPath) => {
     try {
@@ -244,22 +363,26 @@ const pickPrimaryLogPath = async (debugPath, allFiles, candidates) => {
     }
     return null;
 };
-export const loadNodeLogDirectory = async (inputDirectoryPath) => {
-    const debugPath = await resolveDebugDirectory(inputDirectoryPath);
-    if (!debugPath)
-        return null;
-    const allFiles = await collectFilesRecursively(debugPath);
+const buildDefaultDirectoryContent = async (debugPath, allFiles) => {
     const bakLogPath = await pickPrimaryLogPath(debugPath, allFiles, BAK_LOG_NAMES);
     const mainLogPath = await pickPrimaryLogPath(debugPath, allFiles, MAIN_LOG_NAMES);
-    let content = '';
+    const chunks = [];
     if (bakLogPath) {
-        content += await readNodeTextFileContent(bakLogPath);
+        chunks.push(await readNodeTextFileContent(bakLogPath));
     }
     if (mainLogPath) {
-        if (content && !content.endsWith('\n'))
-            content += '\n';
-        content += await readNodeTextFileContent(mainLogPath);
+        chunks.push(await readNodeTextFileContent(mainLogPath));
     }
+    return joinMergedContent(chunks);
+};
+export const loadNodeLogDirectory = async (inputDirectoryPath, options = {}) => {
+    const debugPath = await resolveDebugDirectory(inputDirectoryPath);
+    if (!debugPath)
+        return null;
+    const allFiles = await collectFilesRecursively(debugPath);
+    const content = options.focus
+        ? await collectFocusedFileContents(allFiles.filter((filePath) => isCoreLogName(path.basename(filePath))), options.focus)
+        : await buildDefaultDirectoryContent(debugPath, allFiles);
     if (!content)
         return null;
     const errorImages = new Map();
@@ -270,14 +393,13 @@ export const loadNodeLogDirectory = async (inputDirectoryPath) => {
         const relativePath = toPosixPath(path.relative(debugPath, absolutePath));
         const lowerRelativePath = relativePath.toLowerCase();
         const fileName = path.basename(absolutePath);
-        const lowerFileName = fileName.toLowerCase();
-        if (lowerRelativePath.includes('/on_error/') && lowerRelativePath.endsWith('.png')) {
+        if (isRelativeImagePath(lowerRelativePath, 'on_error', '.png')) {
             const key = parseErrorImageKey(fileName);
             if (key) {
                 errorImages.set(key, toFileReference(absolutePath));
             }
         }
-        if (lowerRelativePath.includes('/vision/') && lowerRelativePath.endsWith('.jpg')) {
+        if (isRelativeImagePath(lowerRelativePath, 'vision', '.jpg')) {
             const visionKey = parseVisionImageKey(fileName);
             if (visionKey) {
                 visionImages.set(visionKey, toFileReference(absolutePath));
@@ -289,7 +411,7 @@ export const loadNodeLogDirectory = async (inputDirectoryPath) => {
         }
         if (!isSearchTextFile(relativePath))
             continue;
-        if (PRIMARY_LOG_NAME_SET.has(lowerFileName))
+        if (isCoreLogName(fileName))
             continue;
         textFiles.push({
             path: relativePath,

package/package.json

@@ -1,13 +1,8 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "0.0.1",
+  "version": "1.1.0",
   "type": "module",
   "private": false,
-  "scripts": {
-    "typecheck": "tsc -p ./tsconfig.json",
-    "build": "pnpm run clean && tsc -p ./tsconfig.build.json && node ../../scripts/fix-esm-imports.mjs ./dist",
-    "clean": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\""
-  },
   "bin": {
     "mla-log-tools": "./dist/cli.js"
   },
@@ -46,11 +41,11 @@
     }
   },
   "dependencies": {
-    "@windsland52/maa-log-adapter": "workspace:*",
-    "@windsland52/maa-log-kernel": "workspace:*",
-    "@windsland52/maa-log-parser": "workspace:*",
-    "@windsland52/maa-log-runtime": "workspace:*",
-    "fflate": "^0.8.2"
+    "fflate": "^0.8.2",
+    "@windsland52/maa-log-kernel": "1.0.0",
+    "@windsland52/maa-log-parser": "1.0.0",
+    "@windsland52/maa-log-runtime": "1.0.0",
+    "@windsland52/maa-log-adapter": "1.0.0"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -61,5 +56,15 @@
   "files": [
     "dist",
     "README.md"
-  ]
-}
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MaaXYZ/MaaLogAnalyzer",
+    "directory": "packages/maa-log-tools"
+  },
+  "scripts": {
+    "typecheck": "tsc -p ./tsconfig.json",
+    "build": "pnpm run clean && tsc -p ./tsconfig.build.json && node ../../scripts/fix-esm-imports.mjs ./dist",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\""
+  }
+}