pkgmgr-kunrunic 0.1.1.dev0__py3-none-any.whl

pkgmgr/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import print_function
+"""
+Modernized pkg manager scaffold.
+This package will grow to replace the legacy single-file script.
+"""
+
+__all__ = [
+    "cli",
+    "config",
+    "snapshot",
+    "release",
+    "gitcollect",
+    "watch",
+    "points",
+]
+
+__version__ = "0.1.1.dev0"

pkgmgr/__main__.py

@@ -0,0 +1,5 @@
+from __future__ import print_function
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pkgmgr/cli.py

@@ -0,0 +1,278 @@
+from __future__ import print_function
+"""CLI entrypoint scaffold for the pkg manager."""
+
+import sys
+
+try:
+    import argparse
+except Exception:
+    argparse = None
+
+from . import config, snapshot, release, gitcollect, watch, __version__
+
+
+def _add_make_config(sub):
+    p = sub.add_parser("make-config", help="create a pkgmgr.yaml template to edit")
+    p.add_argument(
+        "-o",
+        "--output",
+        default=config.DEFAULT_MAIN_CONFIG,
+        help="path to write the main config (default: %(default)s)",
+    )
+    p.set_defaults(func=_handle_make_config)
+
+
+def _add_install(sub):
+    p = sub.add_parser("install", help="prepare environment and collect initial baseline")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_install)
+
+
+def _add_snapshot(sub):
+    p = sub.add_parser(
+        "snapshot", help="take a snapshot (baseline update after install)"
+    )
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_snapshot)
+
+def _add_actions(sub):
+    p = sub.add_parser("actions", help="run one or more configured actions")
+    p.add_argument("names", nargs="+", help="action names to run")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_actions)
+
+
+def _add_create_pkg(sub):
+    p = sub.add_parser("create-pkg", help="create a pkg folder and template")
+    p.add_argument("pkg_id", help="package identifier (e.g. 20240601)")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_create_pkg)
+
+
+def _add_update_pkg(sub):
+    p = sub.add_parser("update-pkg", help="collect git keyword hits and checksums for a pkg")
+    p.add_argument("pkg_id", help="package identifier to update")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_update_pkg)
+
+
+def _add_close_pkg(sub):
+    p = sub.add_parser("close-pkg", help="mark a pkg as closed and stop watching")
+    p.add_argument("pkg_id", help="package identifier to close")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_close_pkg)
+
+
+def _add_watch(sub):
+    p = sub.add_parser("watch", help="start watcher/daemon to monitor pkgs")
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.add_argument(
+        "--once",
+        action="store_true",
+        help="run a single poll iteration then exit (useful for cron)",
+    )
+    p.add_argument("--pkg", help="package id to scope watch/points (optional)")
+    p.add_argument(
+        "--auto-point",
+        action="store_true",
+        help="create a checkpoint automatically after changes are handled",
+    )
+    p.add_argument(
+        "--point-label",
+        help="label to use when auto-creating a checkpoint (default: watch-auto)",
+    )
+    p.set_defaults(func=_handle_watch)
+
+
+def _add_collect(sub):
+    p = sub.add_parser("collect", help="run collectors for a pkg")
+    p.add_argument("--pkg", required=True, help="package identifier")
+    p.add_argument(
+        "--collector",
+        action="append",
+        dest="collectors",
+        help="specific collectors to run (default: all enabled)",
+    )
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_collect)
+
+def _add_point(sub):
+    p = sub.add_parser("point", help="create or list checkpoints for a pkg")
+    p.add_argument("--pkg", required=True, help="package identifier")
+    p.add_argument("--label", help="optional label for this point")
+    p.add_argument(
+        "--actions-run",
+        action="append",
+        dest="actions_run",
+        help="actions that were executed before creating this point",
+    )
+    p.add_argument(
+        "--list",
+        action="store_true",
+        help="list existing points instead of creating a new one",
+    )
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_point)
+
+
+def _add_export(sub):
+    p = sub.add_parser("export", help="export pkg data (excel/word/etc)")
+    p.add_argument("--pkg", required=True, help="package identifier")
+    p.add_argument("--format", choices=["excel", "word", "json"], required=True)
+    p.add_argument(
+        "--config",
+        default=None,
+        help="config file path (default: auto-discover under %s)" % config.BASE_DIR,
+    )
+    p.set_defaults(func=_handle_export)
+
+
+def build_parser():
+    if argparse is None:
+        raise RuntimeError("argparse not available; install argparse")
+    parser = argparse.ArgumentParser(prog="pkgmgr", description="Pkg manager CLI scaffold")
+    # keep %(prog)s for argparse's mapping and append package version
+    parser.add_argument("-V", "--version", action="version", version="%(prog)s " + __version__)
+    sub = parser.add_subparsers(dest="command")
+
+    _add_make_config(sub)
+    _add_install(sub)
+    _add_snapshot(sub)
+    _add_create_pkg(sub)
+    _add_update_pkg(sub)
+    _add_close_pkg(sub)
+    _add_watch(sub)
+    _add_collect(sub)
+    _add_export(sub)
+    _add_actions(sub)
+    _add_point(sub)
+    return parser
+
+
+def _handle_make_config(args):
+    config.write_template(args.output)
+    return 0
+
+
+def _handle_install(args):
+    cfg = config.load_main(args.config)
+    print("[install] step 1/2: shell integration")
+    release.ensure_environment()
+    print("[install] step 2/2: baseline snapshot")
+    progress = snapshot.ProgressReporter("scan")
+    snapshot.create_baseline(cfg, prompt_overwrite=True, progress=progress)
+    return 0
+
+
+def _handle_snapshot(args):
+    cfg = config.load_main(args.config)
+    snapshot.create_snapshot(cfg)
+    return 0
+
+
+def _handle_create_pkg(args):
+    cfg = config.load_main(args.config)
+    release.create_pkg(cfg, args.pkg_id)
+    return 0
+
+def _handle_update_pkg(args):
+    cfg = config.load_main(args.config)
+    release.update_pkg(cfg, args.pkg_id)
+    return 0
+
+
+def _handle_close_pkg(args):
+    cfg = config.load_main(args.config)
+    release.close_pkg(cfg, args.pkg_id)
+    return 0
+
+
+def _handle_watch(args):
+    cfg = config.load_main(args.config)
+    watch.run(
+        cfg,
+        run_once=args.once,
+        pkg_id=args.pkg,
+        auto_point=args.auto_point,
+        point_label=args.point_label,
+    )
+    return 0
+
+
+def _handle_collect(args):
+    cfg = config.load_main(args.config)
+    release.collect_for_pkg(cfg, args.pkg, args.collectors)
+    return 0
+
+
+def _handle_export(args):
+    cfg = config.load_main(args.config)
+    release.export_pkg(cfg, args.pkg, args.format)
+    return 0
+
+
+def _handle_actions(args):
+    cfg = config.load_main(args.config)
+    release.run_actions(cfg, args.names)
+    return 0
+
+def _handle_point(args):
+    cfg = config.load_main(args.config)
+    if args.list:
+        release.list_points(cfg, args.pkg)
+        return 0
+    release.create_point(cfg, args.pkg, label=args.label, actions_run=args.actions_run)
+    return 0
+
+
+def main(argv=None):
+    argv = argv if argv is not None else sys.argv[1:]
+    parser = build_parser()
+    if not argv:
+        parser.print_help()
+        return 0
+    args = parser.parse_args(argv)
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pkgmgr/collectors/__init__.py

@@ -0,0 +1,5 @@
+"""Collectors package."""
+
+from . import base, checksums
+
+__all__ = ["base", "checksums"]

pkgmgr/collectors/base.py

@@ -0,0 +1,15 @@
+from __future__ import print_function
+"""Collector interface definitions."""
+
+
+class CollectorResult(dict):
+    """Lightweight result mapping for collector outputs."""
+
+
+class Collector:
+    """Base collector contract."""
+
+    name = "base"
+
+    def run(self, pkg_ctx, cfg):
+        raise NotImplementedError

pkgmgr/collectors/checksums.py

@@ -0,0 +1,35 @@
+from __future__ import print_function
+"""Checksum collector stub."""
+
+import hashlib
+import os
+
+from .base import Collector, CollectorResult
+
+
+class ChecksumsCollector(Collector):
+    name = "checksums"
+
+    def run(self, pkg_ctx, cfg):
+        """
+        Placeholder: walk pkg_ctx['paths'] and compute sha256.
+        pkg_ctx is expected to contain 'paths' list of absolute file paths.
+        """
+        res = CollectorResult()
+        paths = pkg_ctx.get("paths", [])
+        for path in paths:
+            if not os.path.exists(path):
+                continue
+            res[path] = sha256_of_file(path)
+        return res
+
+
+def sha256_of_file(path, chunk=1024 * 1024):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(chunk)
+            if not b:
+                break
+            h.update(b)
+    return h.hexdigest()