ghcr-manager 0.0.4 → 0.9.0

package/dist/db/_snapshot-repository.d.ts

@@ -7,18 +7,18 @@ export declare class SnapshotRepository {
         packageName: string;
         scanCompletedAt: string;
     };
-    getTaggedDigests(scanId: number): Set<string>;
-    getDigestsForTags(scanId: number, tags: string[]): Set<string>;
-    getChildDigests(scanId: number, parentDigests: Iterable<string>): string[];
-    getVersionsCreatedBefore(scanId: number, cutoffTimestamp: string): Array<{
-        versionId: number;
-        digest: string;
-    }>;
-    getTaggedVersionIds(scanId: number): number[];
     countPackageVersions(scanId: number): number;
     countTaggedVersions(scanId: number): number;
     countTags(scanId: number): number;
     countManifests(scanId: number): number;
     countManifestEdges(scanId: number): number;
-    listPackageVersionDigests(scanId: number): string[];
+    listManifestDigests(scanId: number): string[];
+    listManifestPayloads(scanId: number): Array<{
+        digest: string;
+        rawJson: string;
+    }>;
+    listPackageVersionManifestRefs(scanId: number): Array<{
+        versionId: number;
+        digest: string;
+    }>;
 }

package/dist/db/_snapshot-repository.js

@@ -23,50 +23,6 @@ export class SnapshotRepository {
             scanCompletedAt: row.scan_completed_at
         };
     }
-    getTaggedDigests(scanId) {
-        return _getDigestSet(this.#database.prepare("SELECT DISTINCT digest FROM tags WHERE scan_id = ?").all(scanId), "digest");
-    }
-    getDigestsForTags(scanId, tags) {
-        if (tags.length === 0) {
-            return new Set();
-        }
-        const placeholders = tags.map(() => "?").join(", ");
-        const rows = this.#database
-            .prepare(`SELECT DISTINCT digest FROM tags WHERE scan_id = ? AND tag IN (${placeholders})`)
-            .all(scanId, ...tags);
-        return _getDigestSet(rows, "digest");
-    }
-    getChildDigests(scanId, parentDigests) {
-        const digestList = [...parentDigests];
-        if (digestList.length === 0) {
-            return [];
-        }
-        const placeholders = digestList.map(() => "?").join(", ");
-        const rows = this.#database
-            .prepare(`SELECT child_digest FROM manifest_edges WHERE scan_id = ? AND parent_digest IN (${placeholders})`)
-            .all(scanId, ...digestList);
-        return rows.map((row) => row.child_digest);
-    }
-    getVersionsCreatedBefore(scanId, cutoffTimestamp) {
-        const rows = this.#database
-            .prepare(`
-          SELECT version_id, digest
-          FROM package_versions
-          WHERE scan_id = ? AND created_at < ?
-          ORDER BY version_id
-        `)
-            .all(scanId, cutoffTimestamp);
-        return rows.map((row) => ({
-            versionId: row.version_id,
-            digest: row.digest
-        }));
-    }
-    getTaggedVersionIds(scanId) {
-        const rows = this.#database
-            .prepare("SELECT DISTINCT version_id FROM tags WHERE scan_id = ? ORDER BY version_id")
-            .all(scanId);
-        return rows.map((row) => row.version_id);
-    }
     countPackageVersions(scanId) {
         return _count(this.#database, "SELECT COUNT(*) AS total FROM package_versions WHERE scan_id = ?", "total", scanId);
     }
@@ -82,17 +38,49 @@ export class SnapshotRepository {
     countManifestEdges(scanId) {
         return _count(this.#database, "SELECT COUNT(*) AS total FROM manifest_edges WHERE scan_id = ?", "total", scanId);
     }
-    listPackageVersionDigests(scanId) {
+    listManifestDigests(scanId) {
         const rows = this.#database
-            .prepare("SELECT digest FROM package_versions WHERE scan_id = ? ORDER BY version_id")
+            .prepare("SELECT digest FROM manifests WHERE scan_id = ? ORDER BY digest")
             .all(scanId);
         return rows.map((row) => row.digest);
     }
-}
-function _getDigestSet(rows, key) {
-    return new Set(rows.map((row) => row[key]));
+    listManifestPayloads(scanId) {
+        const rows = this.#database
+            .prepare(`
+          SELECT digest, raw_json
+          FROM manifest_payloads
+          WHERE scan_id = ?
+          ORDER BY digest
+        `)
+            .all(scanId);
+        return rows.map((row) => ({
+            digest: row.digest,
+            rawJson: row.raw_json
+        }));
+    }
+    listPackageVersionManifestRefs(scanId) {
+        const rows = this.#database
+            .prepare(`
+          SELECT version_id, raw_json
+          FROM package_version_payloads
+          WHERE scan_id = ?
+          ORDER BY version_id
+        `)
+            .all(scanId);
+        return rows.map((row) => ({
+            versionId: row.version_id,
+            digest: _parsePackageVersionDigest(row.version_id, row.raw_json)
+        }));
+    }
 }
 function _count(database, sql, field, ...params) {
     const row = database.prepare(sql).get(...params);
     return row[field];
 }
+function _parsePackageVersionDigest(versionId, rawJson) {
+    const payload = JSON.parse(rawJson);
+    if (typeof payload.name !== "string" || payload.name.length === 0) {
+        throw new Error(`package version payload for version_id=${versionId} did not include digest name`);
+    }
+    return payload.name;
+}

package/dist/db/_sql-placeholders.d.ts

@@ -0,0 +1,2 @@
+export declare function buildInClausePlaceholders(valueCount: number): string;
+export declare function buildTuplePlaceholders(rowCount: number, columnCount: number): string;

package/dist/db/_sql-placeholders.js

@@ -0,0 +1,16 @@
+export function buildInClausePlaceholders(valueCount) {
+    if (valueCount <= 0) {
+        throw new Error("valueCount must be greater than 0");
+    }
+    return Array.from({ length: valueCount }, () => "?").join(", ");
+}
+export function buildTuplePlaceholders(rowCount, columnCount) {
+    if (rowCount <= 0) {
+        throw new Error("rowCount must be greater than 0");
+    }
+    if (columnCount <= 0) {
+        throw new Error("columnCount must be greater than 0");
+    }
+    const tuple = `(${Array.from({ length: columnCount }, () => "?").join(", ")})`;
+    return Array.from({ length: rowCount }, () => tuple).join(", ");
+}

package/dist/db/index.d.ts

@@ -1,4 +1,9 @@
 import Database from "better-sqlite3";
 export { ScanWriter } from "./_scan-writer.js";
+export { CleanupRunWriter } from "./_cleanup-run-writer.js";
+export { DbMergeRepository } from "./_db-merge-repository.js";
+export { PlannerRepository } from "./planner/index.js";
 export { SnapshotRepository } from "./_snapshot-repository.js";
+export type { DeletePlan } from "./planner/index.js";
+export type { DbMergeSourceSummary } from "./_db-merge-repository.js";
 export declare function openDatabase(databasePath: string): Database.Database;

package/dist/db/index.js

@@ -1,6 +1,9 @@
 import Database from "better-sqlite3";
 import { initializeSchema } from "./_schema.js";
 export { ScanWriter } from "./_scan-writer.js";
+export { CleanupRunWriter } from "./_cleanup-run-writer.js";
+export { DbMergeRepository } from "./_db-merge-repository.js";
+export { PlannerRepository } from "./planner/index.js";
 export { SnapshotRepository } from "./_snapshot-repository.js";
 export function openDatabase(databasePath) {
     const database = new Database(databasePath);

package/dist/db/planner/_planner-delete-tag-root-targets.d.ts

@@ -0,0 +1,7 @@
+import { PlannerSql } from "./_planner-sql.js";
+import { type DeletePlanRoot } from "./_planner-types.js";
+export declare class PlannerDeleteTagRootTargets {
+    #private;
+    constructor(sql: PlannerSql);
+    list(scanId: number, deleteTags: string[], excludeTags: string[], useRegex: boolean, keepCount?: number, cutoffTimestamp?: string): DeletePlanRoot[];
+}

package/dist/db/planner/_planner-delete-tag-root-targets.js

@@ -0,0 +1,130 @@
+import { buildTagSelectorPredicate } from "./_planner-tag-selectors.js";
+import { mapPlanRootRow } from "./_planner-types.js";
+export class PlannerDeleteTagRootTargets {
+    #sql;
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    list(scanId, deleteTags, excludeTags, useRegex, keepCount, cutoffTimestamp) {
+        const selectedTagPredicate = buildTagSelectorPredicate(this.#sql.database, "st.tag", deleteTags, useRegex);
+        const excludedTagPredicate = excludeTags.length > 0
+            ? buildTagSelectorPredicate(this.#sql.database, "xt.tag", excludeTags, useRegex)
+            : undefined;
+        const excludedVersionsCte = excludedTagPredicate
+            ? `
+        excluded_versions AS (
+          SELECT DISTINCT xt.version_id
+          FROM tags xt
+          WHERE xt.scan_id = ?
+            AND (${excludedTagPredicate.sql})
+        ),
+      `
+            : "";
+        const excludedJoinSql = excludedTagPredicate
+            ? `
+        LEFT JOIN excluded_versions ev
+          ON ev.version_id = st.version_id
+      `
+            : "";
+        const excludedWhereSql = excludedTagPredicate ? "AND ev.version_id IS NULL" : "";
+        const cutoffSql = cutoffTimestamp ? "AND pv.created_at < ?" : "";
+        const keepSql = keepCount !== undefined ? "WHERE recency_rank > ?" : "";
+        const params = [scanId, ...selectedTagPredicate.params];
+        if (excludedTagPredicate) {
+            params.push(scanId, ...excludedTagPredicate.params);
+        }
+        if (cutoffTimestamp) {
+            params.push(cutoffTimestamp);
+        }
+        params.push(scanId);
+        const tailParams = [keepCount !== undefined ? 1 : 0];
+        if (keepCount !== undefined) {
+            tailParams.push(keepCount);
+        }
+        const sql = `
+      WITH selected_tags AS (
+        SELECT st.scan_id, st.version_id, st.tag
+        FROM tags st
+        WHERE st.scan_id = ?
+          AND (${selectedTagPredicate.sql})
+      ),
+      ${excludedVersionsCte}
+      matched_candidate_roots AS (
+        SELECT DISTINCT
+          st.version_id AS version_id,
+          m.digest AS root_digest,
+          m.manifest_kind AS root_manifest_kind,
+          pv.created_at
+        FROM selected_tags st
+        JOIN manifests m
+          ON m.scan_id = st.scan_id
+         AND m.version_id = st.version_id
+        JOIN package_versions pv
+          ON pv.scan_id = st.scan_id
+         AND pv.version_id = st.version_id
+        ${excludedJoinSql}
+        WHERE 1 = 1
+          ${excludedWhereSql}
+          ${cutoffSql}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM manifest_reachability mr
+            WHERE mr.scan_id = st.scan_id
+              AND mr.descendant_digest = m.digest
+              AND mr.min_distance > 0
+          )
+      ),
+      matched_roots AS (
+        SELECT
+          mcr.version_id,
+          mcr.root_digest,
+          mcr.root_manifest_kind,
+          mcr.created_at,
+          COUNT(t.tag) AS total_tag_count,
+          COUNT(st.tag) AS matched_tag_count
+        FROM matched_candidate_roots mcr
+        JOIN tags t
+          ON t.scan_id = ?
+         AND t.version_id = mcr.version_id
+        LEFT JOIN selected_tags st
+          ON st.scan_id = t.scan_id
+         AND st.version_id = t.version_id
+         AND st.tag = t.tag
+        GROUP BY mcr.version_id, mcr.root_digest, mcr.root_manifest_kind, mcr.created_at
+        HAVING matched_tag_count > 0
+      ),
+      ranked_roots AS (
+        SELECT
+          version_id,
+          root_digest,
+          root_manifest_kind,
+          total_tag_count,
+          matched_tag_count,
+          ROW_NUMBER() OVER (
+            ORDER BY created_at DESC, version_id DESC, root_digest DESC
+          ) AS recency_rank
+        FROM matched_roots
+      )
+      SELECT
+        version_id,
+        root_digest,
+        root_manifest_kind,
+        CASE
+          WHEN total_tag_count = matched_tag_count AND ? = 1
+            THEN 'keep-n-tagged-overflow'
+          WHEN total_tag_count = matched_tag_count
+            THEN 'delete-tags-all-tags-selected'
+          ELSE 'delete-tags-partial-tag-match'
+        END AS direct_target_reason,
+        CASE
+          WHEN total_tag_count = matched_tag_count
+            THEN 'delete-root'
+          ELSE 'untag-only'
+        END AS selection_mode
+      FROM ranked_roots
+      ${keepSql}
+      ORDER BY root_digest
+    `;
+        return this.#sql.all(sql, [...params, ...tailParams]).map(mapPlanRootRow);
+    }
+}

package/dist/db/planner/_planner-direct-target-tags.d.ts

@@ -0,0 +1,6 @@
+import { PlannerSql } from "./_planner-sql.js";
+export declare class PlannerDirectTargetTags {
+    #private;
+    constructor(sql: PlannerSql);
+    listDeleteTagDirectTargetTags(scanId: number, deleteTags: string[], excludeTags: string[], useRegex: boolean, cutoffTimestamp?: string): string[];
+}

package/dist/db/planner/_planner-direct-target-tags.js

@@ -0,0 +1,47 @@
+import { buildTagSelectorPredicate } from "./_planner-tag-selectors.js";
+import { mapPlanTagRows } from "./_planner-types.js";
+export class PlannerDirectTargetTags {
+    #sql;
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    listDeleteTagDirectTargetTags(scanId, deleteTags, excludeTags, useRegex, cutoffTimestamp) {
+        if (deleteTags.length === 0) {
+            return [];
+        }
+        const selectedTagPredicate = buildTagSelectorPredicate(this.#sql.database, "t.tag", deleteTags, useRegex);
+        const params = [scanId, ...selectedTagPredicate.params];
+        let excludedRootSql = "";
+        let olderThanSql = "";
+        if (excludeTags.length > 0) {
+            const excludedTagPredicate = buildTagSelectorPredicate(this.#sql.database, "xt.tag", excludeTags, useRegex);
+            excludedRootSql = `
+        AND NOT EXISTS (
+          SELECT 1
+          FROM tags xt
+          WHERE xt.scan_id = t.scan_id
+            AND xt.version_id = t.version_id
+            AND (${excludedTagPredicate.sql})
+        )
+      `;
+            params.push(...excludedTagPredicate.params);
+        }
+        if (cutoffTimestamp) {
+            olderThanSql = "AND pv.created_at < ?";
+            params.push(cutoffTimestamp);
+        }
+        const sql = `
+      SELECT DISTINCT tag AS target_tag
+      FROM tags t
+      JOIN package_versions pv
+        ON pv.scan_id = t.scan_id
+       AND pv.version_id = t.version_id
+      WHERE t.scan_id = ?
+        AND (${selectedTagPredicate.sql})
+        ${excludedRootSql}
+        ${olderThanSql}
+      ORDER BY tag
+    `;
+        return mapPlanTagRows(this.#sql.all(sql, params));
+    }
+}

package/dist/db/planner/_planner-keep-tagged-root-targets.d.ts

@@ -0,0 +1,7 @@
+import { PlannerSql } from "./_planner-sql.js";
+import { type DeletePlanRoot } from "./_planner-types.js";
+export declare class PlannerKeepTaggedRootTargets {
+    #private;
+    constructor(sql: PlannerSql);
+    list(scanId: number, excludeTags: string[], useRegex: boolean, keepCount?: number, cutoffTimestamp?: string): DeletePlanRoot[];
+}

package/dist/db/planner/_planner-keep-tagged-root-targets.js

@@ -0,0 +1,74 @@
+import { buildTagSelectorPredicate } from "./_planner-tag-selectors.js";
+import { mapPlanRootRow } from "./_planner-types.js";
+export class PlannerKeepTaggedRootTargets {
+    #sql;
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    list(scanId, excludeTags, useRegex, keepCount, cutoffTimestamp) {
+        const excludedTagPredicate = excludeTags.length > 0
+            ? buildTagSelectorPredicate(this.#sql.database, "xt.tag", excludeTags, useRegex)
+            : undefined;
+        const excludedRootSql = excludedTagPredicate
+            ? `
+        AND NOT EXISTS (
+          SELECT 1
+          FROM tags xt
+          WHERE xt.scan_id = pv.scan_id
+            AND xt.version_id = pv.version_id
+            AND (${excludedTagPredicate.sql})
+        )
+      `
+            : "";
+        const cutoffSql = cutoffTimestamp ? "AND pv.created_at < ?" : "";
+        const keepSql = keepCount !== undefined ? "WHERE recency_rank > ?" : "";
+        const params = [scanId, ...(excludedTagPredicate?.params ?? [])];
+        if (cutoffTimestamp) {
+            params.push(cutoffTimestamp);
+        }
+        if (keepCount !== undefined) {
+            params.push(keepCount);
+        }
+        const sql = `
+      WITH eligible_tagged_roots AS (
+        SELECT
+          pv.version_id AS version_id,
+          m.digest AS root_digest,
+          m.manifest_kind AS root_manifest_kind,
+          ROW_NUMBER() OVER (
+            ORDER BY pv.created_at DESC, pv.version_id DESC, m.digest DESC
+          ) AS recency_rank
+        FROM package_versions pv
+        JOIN manifests m
+          ON m.scan_id = pv.scan_id
+         AND m.version_id = pv.version_id
+        WHERE pv.scan_id = ?
+          AND EXISTS (
+            SELECT 1
+            FROM tags t
+            WHERE t.scan_id = pv.scan_id
+              AND t.version_id = pv.version_id
+          )
+          ${excludedRootSql}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM manifest_reachability mr
+            WHERE mr.scan_id = pv.scan_id
+              AND mr.descendant_digest = m.digest
+              AND mr.min_distance > 0
+          )
+          ${cutoffSql}
+      )
+      SELECT
+        version_id,
+        root_digest,
+        root_manifest_kind,
+        'keep-n-tagged-overflow' AS direct_target_reason,
+        'delete-root' AS selection_mode
+      FROM eligible_tagged_roots
+      ${keepSql}
+      ORDER BY root_digest
+    `;
+        return this.#sql.all(sql, params).map(mapPlanRootRow);
+    }
+}

package/dist/db/planner/_planner-output.d.ts

@@ -0,0 +1,5 @@
+import type { DeletePlan, DeletePlanBlockedRoot, DeletePlanProtectedRoot, DeletePlanRoot, DeletePlanRootDecision, PlanArtifacts } from "./_planner-types.js";
+export declare function buildPlanOutputs(directTargetTags: string[], directTargetRoots: DeletePlanRoot[], planArtifacts: PlanArtifacts): Pick<DeletePlan, "validationSummary" | "directTargetTags" | "directTargetRoots" | "rootDecisions" | "protectedRoots" | "closureManifests" | "blockedRoots" | "fullyDeletableRoots" | "collateralTags">;
+export declare function buildRootDecisions(directTargetRoots: DeletePlanRoot[], planArtifacts: PlanArtifacts): DeletePlanRootDecision[];
+export declare function buildProtectedRoots(blockedRoots: DeletePlanBlockedRoot[]): DeletePlanProtectedRoot[];
+export declare function buildBlockedValidationReason(blockedRoot?: DeletePlanBlockedRoot): string;

package/dist/db/planner/_planner-output.js

@@ -0,0 +1,101 @@
+export function buildPlanOutputs(directTargetTags, directTargetRoots, planArtifacts) {
+    const rootDecisions = buildRootDecisions(directTargetRoots, planArtifacts);
+    const protectedRoots = buildProtectedRoots(planArtifacts.blockedRoots);
+    const deleteRootCandidateCount = directTargetRoots.filter((root) => root.selectionMode === "delete-root").length;
+    const untagOnlyRootCount = directTargetRoots.length - deleteRootCandidateCount;
+    return {
+        validationSummary: {
+            directTargetTagCount: directTargetTags.length,
+            directTargetRootCount: directTargetRoots.length,
+            deleteRootCandidateCount,
+            untagOnlyRootCount,
+            fullyDeletableRootCount: planArtifacts.fullyDeletableRoots.length,
+            blockedDeleteRootCount: rootDecisions.filter((decision) => decision.validationStatus === "blocked").length,
+            protectedRootCount: protectedRoots.length
+        },
+        directTargetTags,
+        directTargetRoots,
+        rootDecisions,
+        protectedRoots,
+        closureManifests: planArtifacts.closureManifests,
+        blockedRoots: planArtifacts.blockedRoots,
+        fullyDeletableRoots: planArtifacts.fullyDeletableRoots,
+        collateralTags: []
+    };
+}
+export function buildRootDecisions(directTargetRoots, planArtifacts) {
+    const fullyDeletableDigests = new Set(planArtifacts.fullyDeletableRoots.map((root) => root.digest));
+    const blockedRootByDigest = new Map();
+    for (const blockedRoot of planArtifacts.blockedRoots) {
+        if (!blockedRootByDigest.has(blockedRoot.blockedDigest)) {
+            blockedRootByDigest.set(blockedRoot.blockedDigest, blockedRoot);
+        }
+    }
+    return directTargetRoots.map((root) => {
+        if (root.selectionMode === "untag-only") {
+            return {
+                versionId: root.versionId,
+                digest: root.digest,
+                manifestKind: root.manifestKind,
+                selectionMode: root.selectionMode,
+                selectionReason: root.reason,
+                validationStatus: "untag-only",
+                validationReasonCode: "untag-only-partial-tag-match",
+                validationReason: "matched tags cover only part of this root's tag set, so the version is retained and only those tags can be detached"
+            };
+        }
+        if (fullyDeletableDigests.has(root.digest)) {
+            return {
+                versionId: root.versionId,
+                digest: root.digest,
+                manifestKind: root.manifestKind,
+                selectionMode: root.selectionMode,
+                selectionReason: root.reason,
+                validationStatus: "fully-deletable",
+                validationReasonCode: "fully-deletable-no-retained-overlap",
+                validationReason: "selected tags cover the whole root and its manifest closure does not overlap any retained root"
+            };
+        }
+        const blockedRoot = blockedRootByDigest.get(root.digest);
+        return {
+            versionId: root.versionId,
+            digest: root.digest,
+            manifestKind: root.manifestKind,
+            selectionMode: root.selectionMode,
+            selectionReason: root.reason,
+            validationStatus: "blocked",
+            validationReasonCode: "blocked-overlap-with-retained-root",
+            validationReason: buildBlockedValidationReason(blockedRoot),
+            blockingVersionId: blockedRoot?.blockingVersionId,
+            blockingDigest: blockedRoot?.blockingDigest,
+            overlapDigest: blockedRoot?.overlapDigest,
+            overlapManifestKind: blockedRoot?.overlapManifestKind
+        };
+    });
+}
+export function buildProtectedRoots(blockedRoots) {
+    const protectedRoots = new Map();
+    for (const blockedRoot of blockedRoots) {
+        const key = `${blockedRoot.blockingVersionId}:${blockedRoot.blockingDigest}`;
+        const current = protectedRoots.get(key) ?? {
+            versionId: blockedRoot.blockingVersionId,
+            digest: blockedRoot.blockingDigest,
+            blocks: []
+        };
+        current.blocks.push({
+            blockedVersionId: blockedRoot.blockedVersionId,
+            blockedDigest: blockedRoot.blockedDigest,
+            blockReasonCode: blockedRoot.reason,
+            overlapDigest: blockedRoot.overlapDigest,
+            overlapManifestKind: blockedRoot.overlapManifestKind
+        });
+        protectedRoots.set(key, current);
+    }
+    return [...protectedRoots.values()].sort((left, right) => left.digest.localeCompare(right.digest));
+}
+export function buildBlockedValidationReason(blockedRoot) {
+    if (!blockedRoot) {
+        return "root closure overlaps manifest members still required by a retained root";
+    }
+    return `blocked because retained root ${blockedRoot.blockingDigest} still requires shared manifest ${blockedRoot.overlapDigest}`;
+}

package/dist/db/planner/_planner-plan-artifacts.d.ts

@@ -0,0 +1,7 @@
+import { PlannerSql } from "./_planner-sql.js";
+import { type DeletePlanRoot, type PlanArtifacts } from "./_planner-types.js";
+export declare class PlannerPlanArtifacts {
+    #private;
+    constructor(sql: PlannerSql);
+    build(scanId: number, directTargetRoots: DeletePlanRoot[]): PlanArtifacts;
+}