@double_seven/swpm 1.0.2

package/dist/winget/parser.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseList = parseList;
+exports.parseSearch = parseSearch;
+exports.parseUpgrade = parseUpgrade;
+const HEADER_MAPS = {
+    en: { Name: "name", Id: "id", Version: "version", Available: "available", Match: "match", Source: "source" },
+    zh: { "名称": "name", "ID": "id", "版本": "version", "可用": "available", "匹配": "match", "源": "source" },
+};
+function detectLang(header) {
+    const checks = ["zh", "en"];
+    for (const lang of checks) {
+        const map = HEADER_MAPS[lang];
+        let hit = 0;
+        for (const key of Object.keys(map)) {
+            if (header.includes(key))
+                hit++;
+        }
+        if (hit >= 3)
+            return lang;
+    }
+    return null;
+}
+function cleanOutput(output) {
+    return output
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "")
+        .split("\n");
+}
+function parseList(output) {
+    return parseTableOutput(output);
+}
+function parseSearch(output) {
+    return parseTableOutput(output);
+}
+function parseUpgrade(output) {
+    return parseTableOutput(output);
+}
+function parseTableOutput(output) {
+    const lines = cleanOutput(output);
+    const results = [];
+    let lang = null;
+    let columns = [];
+    let positions = {};
+    for (const line of lines) {
+        if (!lang) {
+            lang = detectLang(line);
+            if (lang) {
+                const offset = findHeaderStart(line, lang);
+                columns = getColumnOrder(line, lang, offset);
+                positions = computePositions(line, lang, offset);
+            }
+            continue;
+        }
+        if (!line.trim() || /^[\s─-]+$/.test(line))
+            continue;
+        const pkg = parseDataLine(line, columns, positions);
+        if (pkg.name && pkg.id) {
+            results.push(pkg);
+        }
+    }
+    return results;
+}
+function findHeaderStart(line, lang) {
+    const map = HEADER_MAPS[lang];
+    let minPos = Infinity;
+    for (const key of Object.keys(map)) {
+        const pos = line.indexOf(key);
+        if (pos !== -1 && pos < minPos)
+            minPos = pos;
+    }
+    return minPos === Infinity ? 0 : minPos;
+}
+function getColumnOrder(header, lang, offset) {
+    const map = HEADER_MAPS[lang];
+    return Object.entries(map)
+        .map(([col, logical]) => ({ logical, pos: header.indexOf(col) - offset }))
+        .filter((c) => c.pos >= 0)
+        .sort((a, b) => a.pos - b.pos)
+        .map((e) => e.logical);
+}
+function computePositions(header, lang, offset) {
+    const positions = {};
+    const map = HEADER_MAPS[lang];
+    const sorted = Object.entries(map)
+        .map(([col, logical]) => ({ logical, pos: header.indexOf(col) - offset }))
+        .filter((c) => c.pos >= 0)
+        .sort((a, b) => a.pos - b.pos);
+    for (let i = 0; i < sorted.length; i++) {
+        const end = i < sorted.length - 1 ? sorted[i + 1].pos : undefined;
+        positions[sorted[i].logical] = {
+            start: sorted[i].pos,
+            end: end ?? Infinity,
+        };
+    }
+    return positions;
+}
+function parseDataLine(line, columns, positions) {
+    // Collect candidates from each strategy
+    const candidates = [];
+    // Strategy 1: split by 2+ spaces, with match-pattern splitting
+    const wideParts = splitWide(line);
+    if (wideParts.length === columns.length) {
+        candidates.push(buildPackage(wideParts, columns));
+    }
+    if (wideParts.length < columns.length && columns.length - wideParts.length <= 2) {
+        const filled = fillEmptyColumns(line, wideParts, columns.length);
+        if (filled.length === columns.length) {
+            candidates.push(buildPackage(filled, columns));
+        }
+    }
+    // Strategy 2: fixed-width using header positions
+    candidates.push(extractFixedWidth(line, positions));
+    // Strategy 3: right-to-left token parsing
+    const tokens = line.trim().split(/\s+/);
+    candidates.push(parseTokensRTL(tokens, columns));
+    // Pick the best candidate
+    return bestCandidate(candidates);
+}
+function bestCandidate(candidates) {
+    let best = null;
+    let bestScore = -1;
+    for (const c of candidates) {
+        const score = scoreCandidate(c);
+        if (score > bestScore) {
+            bestScore = score;
+            best = c;
+        }
+    }
+    return best || { name: "", id: "", version: "", source: "" };
+}
+function scoreCandidate(pkg) {
+    let score = 0;
+    if (pkg.id && isValidId(pkg.id))
+        score += 100;
+    if (pkg.id && !isValidId(pkg.id))
+        score -= 50; // corrupt id is worse than no id
+    if (pkg.name && pkg.name.length > 0)
+        score += 10;
+    if (pkg.version && isVersion(pkg.version))
+        score += 20;
+    if (pkg.source && /^[a-zA-Z]+$/.test(pkg.source))
+        score += 10;
+    return score;
+}
+// Split by 2+ spaces, then split match patterns (Moniker:/Tag:) that merged with version
+function splitWide(line) {
+    const parts = line.split(/\s{2,}/);
+    const result = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        const subParts = trimmed.split(/\s+(?=(?:Moniker|Tag):)/);
+        for (const sp of subParts) {
+            if (sp.trim())
+                result.push(sp.trim());
+        }
+    }
+    return result;
+}
+function buildPackage(parts, columns) {
+    const pkg = { name: "", id: "", version: "", source: "" };
+    for (let i = 0; i < columns.length && i < parts.length; i++) {
+        const val = parts[i].trim();
+        switch (columns[i]) {
+            case "name":
+                pkg.name = val;
+                break;
+            case "id":
+                pkg.id = val;
+                break;
+            case "version":
+                pkg.version = val;
+                break;
+            case "available":
+                pkg.available = val || undefined;
+                break;
+            case "source":
+                pkg.source = val;
+                break;
+        }
+    }
+    return pkg;
+}
+// Insert empty strings at the widest gaps to handle empty columns (e.g. no update available)
+function fillEmptyColumns(line, parts, expectedCount) {
+    const gaps = [];
+    let pos = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const idx = line.indexOf(parts[i], pos);
+        if (idx < 0)
+            return parts;
+        if (i > 0)
+            gaps.push(idx - pos);
+        pos = idx + parts[i].length;
+    }
+    gaps.push(line.length - pos);
+    const result = [...parts];
+    while (result.length < expectedCount && gaps.length > 0) {
+        let maxIdx = 0;
+        for (let i = 1; i < gaps.length; i++) {
+            if (gaps[i] > gaps[maxIdx])
+                maxIdx = i;
+        }
+        result.splice(maxIdx + 1, 0, "");
+        gaps.splice(maxIdx, 1, 0, 0);
+    }
+    return result;
+}
+function extractFixedWidth(line, positions) {
+    const extract = (col) => {
+        const p = positions[col];
+        if (!p)
+            return "";
+        return line.slice(p.start, Math.min(p.end, line.length)).trim();
+    };
+    return {
+        name: extract("name"),
+        id: extract("id"),
+        version: extract("version"),
+        available: extract("available") || undefined,
+        source: extract("source"),
+    };
+}
+function isValidId(id) {
+    // Valid winget IDs: publisher.package (contains dot, no spaces)
+    // ARP entries: contain backslashes
+    if (id.includes("\\") || /^[A-Za-z0-9_.+-]+\.[A-Za-z0-9_.+-]+$/.test(id)) {
+        return true;
+    }
+    // Reject IDs with spaces (sign of corrupted column extraction)
+    if (/\s/.test(id))
+        return false;
+    return id.includes(".");
+}
+function parseTokensRTL(tokens, columns) {
+    const hasAvailable = columns.includes("available");
+    const remain = [...tokens];
+    const result = { name: "", id: "", version: "", source: "" };
+    // Pop source from right
+    result.source = remain.pop() || "";
+    // Find ID first (rightmost dotted/backslash token, not a version-only token)
+    let idIdx = -1;
+    for (let i = remain.length - 1; i >= 0; i--) {
+        if (isId(remain[i])) {
+            idIdx = i;
+            break;
+        }
+    }
+    // Everything to the left of ID is the name
+    if (idIdx >= 0) {
+        result.name = remain.slice(0, idIdx).join(" ");
+        result.id = remain[idIdx];
+    }
+    else {
+        result.name = remain.join(" ");
+    }
+    // Find version(s) in tokens between id+1 and end
+    if (idIdx >= 0) {
+        const rightTokens = remain.slice(idIdx + 1);
+        const versionTokens = [];
+        const nonVersionTokens = [];
+        for (const t of rightTokens) {
+            if (isVersion(t))
+                versionTokens.push(t);
+            else
+                nonVersionTokens.push(t);
+        }
+        if (hasAvailable && versionTokens.length >= 2) {
+            // Rightmost two version tokens
+            result.available = versionTokens[versionTokens.length - 1];
+            result.version = versionTokens[versionTokens.length - 2];
+        }
+        else if (versionTokens.length >= 1) {
+            result.version = versionTokens[versionTokens.length - 1];
+            result.available = undefined;
+        }
+    }
+    else {
+        // No ID found, try old right-to-left version detection
+        const lastIsVer = remain.length > 0 && isVersion(remain[remain.length - 1]);
+        const secondLastIsVer = remain.length > 1 && isVersion(remain[remain.length - 2]);
+        if (hasAvailable && lastIsVer && secondLastIsVer) {
+            result.available = remain.pop();
+            result.version = remain.pop();
+        }
+        else if (hasAvailable && lastIsVer) {
+            result.version = remain.pop();
+            result.available = undefined;
+        }
+        else if (lastIsVer) {
+            result.version = remain.pop();
+        }
+    }
+    return result;
+}
+function isVersion(s) {
+    return /^\d+\.\d+/.test(s);
+}
+function isId(s) {
+    return (s.includes(".") || s.includes("\\")) && !/^\d+\.\d+/.test(s);
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@double_seven/swpm",
+  "version": "1.0.2",
+  "description": "A winget-based Windows software package manager CLI with batch upgrade, export, and sync support",
+  "bin": {
+    "swpm": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "winget",
+    "windows",
+    "package-manager",
+    "cli",
+    "software",
+    "installer",
+    "upgrade",
+    "export",
+    "sync"
+  ],
+  "author": "Dengjiansheng",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dengjiansheng/swpm.git"
+  },
+  "homepage": "https://github.com/Dengjiansheng/swpm#readme",
+  "bugs": {
+    "url": "https://github.com/Dengjiansheng/swpm/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "win32"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.6.1",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "js-yaml": "^4.1.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.13.0",
+    "@vitest/coverage-v8": "^4.1.7",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.7"
+  }
+}