modwright 0.1.2 → 0.1.4

package/dist/core/logs/scan.js

@@ -37,14 +37,14 @@ function parseScanKey(key) {
 }
 export async function scanSource(source, signatures, scope, ctx) {
     if (!source.exists) {
-        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [], attributions: [] };
     }
     let stat;
     try {
         stat = await fs.stat(source.path);
     }
     catch {
-        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [] };
+        return { status: { source, linesScanned: 0, findingCount: 0 }, findings: [], attributions: [] };
     }
     const sizeBytes = stat.size;
     const modifiedAt = stat.mtime;
@@ -63,7 +63,7 @@ export async function scanSource(source, signatures, scope, ctx) {
         };
         if (stale !== undefined)
             status.stale = stale;
-        return { status, findings: [] };
+        return { status, findings: [], attributions: [] };
     }
     const birthtimeMs = Math.round(stat.birthtimeMs);
     const mtimeMs = Math.round(stat.mtimeMs);
@@ -125,7 +125,7 @@ export async function scanSource(source, signatures, scope, ctx) {
             };
             if (stale !== undefined)
                 status.stale = stale;
-            return { status, findings: [] };
+            return { status, findings: [], attributions: [] };
         }
     }
     if (startOffset === 0 && text.charCodeAt(0) === 0xfeff)
@@ -133,14 +133,18 @@ export async function scanSource(source, signatures, scope, ctx) {
     let lines = splitLines(text);
     if (clipped && lines.length > 0)
         lines.shift();
+    let headTrimmed = clipped;
     if ((!hadOffset || rotated) && lines.length > maxLines) {
         lines = lines.slice(lines.length - maxLines);
+        headTrimmed = true;
     }
     const sinceDate = scope.since ? new Date(scope.since) : undefined;
     let anyTimestampSeen = false;
     let lastTimestamp;
     const findingsBySignature = new Map();
     const findings = [];
+    const attributions = [];
+    const context = {};
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (sinceDate) {
@@ -157,6 +161,39 @@ export async function scanSource(source, signatures, scope, ctx) {
             const match = sig.pattern.exec(line);
             if (!match)
                 continue;
+            const spec = sig.attribution;
+            if (spec) {
+                const group = (name) => name === undefined ? undefined : match.groups?.[name];
+                if (spec.setsContext) {
+                    const subject = group(spec.subject);
+                    const actor = group(spec.actor);
+                    if (subject !== undefined)
+                        context.subject = subject;
+                    if (actor !== undefined)
+                        context.actor = actor;
+                    continue;
+                }
+                const subject = group(spec.subject) ?? group(spec.subjectFallback) ?? spec.subjectLabel ?? context.subject;
+                if (subject !== undefined) {
+                    const record = {
+                        sourceId: source.id,
+                        signatureId: sig.id,
+                        kind: spec.kind,
+                        subject,
+                        actor: group(spec.actor) ?? context.actor ?? "?",
+                        lineNumber: i + 1,
+                    };
+                    const via = group(spec.via);
+                    if (via !== undefined)
+                        record.via = via;
+                    const detail = group(spec.detail);
+                    if (detail !== undefined)
+                        record.detail = detail;
+                    attributions.push(record);
+                }
+                if (!spec.alsoFinding)
+                    continue;
+            }
             const existing = findingsBySignature.get(sig.id);
             if (existing) {
                 existing.repeats = (existing.repeats ?? 0) + 1;
@@ -207,5 +244,7 @@ export async function scanSource(source, signatures, scope, ctx) {
         status.rewritten = true;
     if (sinceDate && !anyTimestampSeen)
         status.timestamps = false;
-    return { status, findings };
+    if (headTrimmed)
+        status.headTrimmed = true;
+    return { status, findings, attributions };
 }

package/dist/core/logs/triage.js

@@ -3,7 +3,9 @@ import { findRunningProcesses } from "../process.js";
 import { resolveLogs } from "../surfaceutil.js";
 import { scanSource } from "./scan.js";
 const FINDINGS_CAP = 200;
-export async function triageLogs(surface, install, registry, scope = {}) {
+const ATTRIBUTION_SUBJECT_CAP = 150;
+const ATTRIBUTION_ACTOR_CAP = 100;
+export async function triageLogs(surface, install, registry, scope = {}, options = {}) {
     const sources = await resolveLogs(surface, install);
     const processResult = await findRunningProcesses(surface.processNames ?? []);
     const gameRunning = processResult.checked ? processResult.running.length > 0 : undefined;
@@ -34,15 +36,17 @@ export async function triageLogs(surface, install, registry, scope = {}) {
     }
     const statuses = [];
     const allFindings = [];
+    const allAttributions = [];
     const offsets = {};
     const offsetKeys = {};
     for (const source of sources) {
         const signatures = registry.forSource(surface.id, source.id);
-        const { status, findings } = await scanSource(source, signatures, scope, { lastLaunch });
+        const { status, findings, attributions } = await scanSource(source, signatures, scope, { lastLaunch });
         if (!source.exists && missingReasons[source.id])
             status.missingReason = missingReasons[source.id];
         statuses.push(status);
         allFindings.push(...findings);
+        allAttributions.push(...attributions);
         if (status.endOffset !== undefined)
             offsets[source.id] = status.endOffset;
         if (status.key !== undefined)
@@ -104,8 +108,81 @@ export async function triageLogs(surface, install, registry, scope = {}) {
         verdict.truncated = true;
     if (Object.keys(systemNotes).length > 0)
         verdict.systemNotes = systemNotes;
+    if (allAttributions.length > 0) {
+        verdict.attribution = buildAttributionReport(allAttributions, statuses, options.attributionFor);
+    }
     return verdict;
 }
+export function buildAttributionReport(records, statuses, filter) {
+    const needle = filter?.trim().toLowerCase();
+    const kept = needle
+        ? records.filter((r) => [r.subject, r.actor, r.via].some((v) => v !== undefined && v.toLowerCase().includes(needle)))
+        : records;
+    const bySubject = new Map();
+    for (const record of kept) {
+        let entry = bySubject.get(record.subject);
+        if (!entry) {
+            entry = { subject: record.subject, kinds: [], actors: [], order: bySubject.size };
+            bySubject.set(record.subject, entry);
+        }
+        if (!entry.kinds.includes(record.kind))
+            entry.kinds.push(record.kind);
+        const same = entry.actors.find((a) => a.actor === record.actor && a.via === record.via && a.kind === record.kind && a.detail === record.detail);
+        if (same) {
+            same.count++;
+            continue;
+        }
+        const actor = {
+            actor: record.actor,
+            kind: record.kind,
+            sourceId: record.sourceId,
+            firstLine: record.lineNumber,
+            count: 1,
+        };
+        if (record.via !== undefined)
+            actor.via = record.via;
+        if (record.detail !== undefined)
+            actor.detail = record.detail;
+        entry.actors.push(actor);
+    }
+    const distinctActors = (subject) => new Set(subject.actors.map((a) => `${a.actor}\u0000${a.via ?? ""}`)).size;
+    const isContested = (subject) => !subject.kinds.every((k) => k === "read-order") && distinctActors(subject) > 1;
+    const all = [...bySubject.values()];
+    const contested = all.filter(isContested).length;
+    all.sort((a, b) => Number(isContested(b)) - Number(isContested(a)) || a.order - b.order);
+    const subjects = all.slice(0, ATTRIBUTION_SUBJECT_CAP).map(({ order: _order, ...subject }) => {
+        if (subject.actors.length <= ATTRIBUTION_ACTOR_CAP)
+            return subject;
+        return {
+            ...subject,
+            actors: subject.actors.slice(0, ATTRIBUTION_ACTOR_CAP),
+            omittedActors: subject.actors.length - ATTRIBUTION_ACTOR_CAP,
+        };
+    });
+    const report = {
+        records: records.length,
+        contested,
+        subjects,
+        note: "Straight from the logs: each actor is who the log line itself names, listed in the order " +
+            "the log shows them acting, so for edits and reads the later actor applied last. Only what " +
+            "the frameworks chose to log is here; a mod that changes something without the loader " +
+            "logging it will not appear.",
+    };
+    if (needle)
+        report.filter = filter.trim();
+    if (all.length > ATTRIBUTION_SUBJECT_CAP)
+        report.omittedSubjects = all.length - ATTRIBUTION_SUBJECT_CAP;
+    const partial = statuses
+        .filter((st) => st.headTrimmed && records.some((r) => r.sourceId === st.source.id))
+        .map((st) => st.source.id);
+    if (partial.length > 0) {
+        report.partialSources = partial;
+        report.note +=
+            ` The start of ${partial.join(", ")} was not read (tail cap), so earlier attribution lines ` +
+                "are missing; pass a larger maxLines (up to 20000) for the whole run.";
+    }
+    return report;
+}
 function buildHeadline(sources, statuses, findings, systems) {
     if (sources.length === 0) {
         return "No log sources are declared for this game; triage has nothing to read.";

package/dist/core/managers/mo2.js

@@ -0,0 +1,121 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { localAppData, pathExists } from "../fsutil.js";
+import { parseIni } from "../ini.js";
+function iniPath(value) {
+    return value.replace(/\\\\/g, "\\");
+}
+function samePath(a, b) {
+    const norm = (p) => path.resolve(iniPath(p)).replace(/[\\/]+$/, "").toLowerCase();
+    return norm(a) === norm(b);
+}
+export async function readMo2Instance(iniFile, portable) {
+    let ini;
+    try {
+        ini = parseIni(await fs.readFile(iniFile, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const instanceDir = path.dirname(iniFile);
+    const general = ini.get("general");
+    const settings = ini.get("settings");
+    const base = iniPath(settings?.get("base_directory") ?? instanceDir);
+    const configured = (key, fallback) => path.resolve(instanceDir, iniPath(settings?.get(key) ?? `%BASE_DIR%/${fallback}`).replace(/%BASE_DIR%/gi, base));
+    const profileName = general?.get("selected_profile") ?? "Default";
+    const profilesDir = configured("profiles_directory", "profiles");
+    const gamePath = general?.get("gamepath");
+    const instance = {
+        instanceDir,
+        iniPath: iniFile,
+        portable,
+        profileName,
+        profileDir: path.join(profilesDir, profileName),
+        modsDir: configured("mod_directory", "mods"),
+        overwriteDir: configured("overwrite_directory", "overwrite"),
+        downloadsDir: configured("download_directory", "downloads"),
+    };
+    if (gamePath)
+        instance.gamePath = iniPath(gamePath);
+    return instance;
+}
+export async function findMo2Instance(install, options = {}) {
+    if (options.instancePath) {
+        const iniFile = options.instancePath.toLowerCase().endsWith(".ini")
+            ? options.instancePath
+            : path.join(options.instancePath, "ModOrganizer.ini");
+        if (await pathExists(iniFile))
+            return readMo2Instance(iniFile, true);
+        return undefined;
+    }
+    const root = options.instancesRoot ?? localAppData("ModOrganizer");
+    let names;
+    try {
+        names = await fs.readdir(root);
+    }
+    catch {
+        return undefined;
+    }
+    for (const name of names) {
+        const iniFile = path.join(root, name, "ModOrganizer.ini");
+        if (!(await pathExists(iniFile)))
+            continue;
+        const instance = await readMo2Instance(iniFile, false);
+        if (instance?.gamePath && samePath(instance.gamePath, install.root))
+            return instance;
+    }
+    return undefined;
+}
+export function parseMo2Modlist(text) {
+    const lines = [];
+    const seen = new Set();
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/^/, "");
+        if (!line.trim() || line.startsWith("#"))
+            continue;
+        const marker = line[0];
+        const hasMarker = marker === "+" || marker === "-" || marker === "*";
+        const name = (hasMarker ? line.slice(1) : line).trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        lines.push({ name, enabled: marker !== "-", foreign: marker === "*" });
+    }
+    return lines.map((entry, index) => ({
+        ...entry,
+        separator: entry.name.endsWith("_separator"),
+        priority: lines.length - index,
+    }));
+}
+export async function readMo2Modlist(profileDir) {
+    try {
+        return parseMo2Modlist(await fs.readFile(path.join(profileDir, "modlist.txt"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readMo2ModMeta(modDir) {
+    let ini;
+    try {
+        ini = parseIni(await fs.readFile(path.join(modDir, "meta.ini"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+    const general = ini.get("general");
+    const meta = {};
+    const modId = Number(general?.get("modid"));
+    if (Number.isInteger(modId) && modId > 0)
+        meta.nexusModId = modId;
+    const version = general?.get("version");
+    if (version)
+        meta.version = version;
+    const installationFile = general?.get("installationfile");
+    if (installationFile)
+        meta.installationFile = installationFile;
+    const gameName = general?.get("gamename");
+    if (gameName)
+        meta.gameName = gameName;
+    return meta;
+}

package/dist/core/managers/vortex.js

@@ -0,0 +1,52 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+const MANIFEST = /^vortex\.deployment\.(?:(?<type>[^.]+)\.)?json$/i;
+export async function readVortexManifests(dir) {
+    const manifests = [];
+    const unreadable = [];
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return { manifests, unreadable };
+    }
+    for (const name of names.sort()) {
+        const match = MANIFEST.exec(name);
+        if (!match)
+            continue;
+        const file = path.join(dir, name);
+        try {
+            const raw = JSON.parse(await fs.readFile(file, "utf8"));
+            if (!Array.isArray(raw.files))
+                throw new Error("no files array");
+            const files = [];
+            for (const entry of raw.files) {
+                if (typeof entry?.relPath !== "string" || typeof entry.source !== "string")
+                    continue;
+                const deployed = { relPath: entry.relPath, source: entry.source };
+                if (Array.isArray(entry.merged))
+                    deployed.merged = entry.merged.filter((m) => typeof m === "string");
+                if (typeof entry.target === "string" && entry.target)
+                    deployed.target = entry.target;
+                if (typeof entry.time === "number")
+                    deployed.time = entry.time;
+                files.push(deployed);
+            }
+            const manifest = { file, deployDir: dir, modType: match.groups?.type ?? "", files };
+            if (typeof raw.gameId === "string")
+                manifest.gameId = raw.gameId;
+            if (typeof raw.deploymentMethod === "string")
+                manifest.deploymentMethod = raw.deploymentMethod;
+            if (typeof raw.deploymentTime === "number")
+                manifest.deploymentTime = raw.deploymentTime;
+            if (typeof raw.stagingPath === "string")
+                manifest.stagingPath = raw.stagingPath;
+            manifests.push(manifest);
+        }
+        catch (error) {
+            unreadable.push({ file, error: error.message });
+        }
+    }
+    return { manifests, unreadable };
+}