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

pkgmgr/shell_integration.py

@@ -0,0 +1,120 @@
+from __future__ import print_function
+"""Shell integration helpers: print PATH/alias instructions per shell."""
+
+import os
+
+from . import config
+
+
+def ensure_path_and_alias(script_dir, alias_name="pkg", command="pkgmgr"):
+    """
+    Print PATH/alias instructions for the current shell.
+    script_dir: directory where the pkgmgr console script lives (e.g. venv/bin).
+    """
+    if not script_dir:
+        print("[install] script_dir not provided; skip shell integration")
+        return
+    shell = os.environ.get("SHELL", "")
+    shell_name = os.path.basename(shell) if shell else ""
+
+    try:
+        lines = _instructions_for_shell(shell_name, script_dir, alias_name, command)
+    except Exception as e:
+        print("[install] shell integration failed for %s: %s" % (shell_name, str(e)))
+        return
+
+    if not lines:
+        print("[install] unknown shell '%s'; skipping rc update" % (shell_name or ""))
+        return
+
+    if not _path_contains_dir(script_dir):
+        print("[install] PATH missing: %s" % script_dir)
+        print("[install] add to PATH, for example:")
+        for line in _path_only_instructions(shell_name, script_dir):
+            print("  " + line)
+
+    header = "[install] To use pkgmgr, add these lines to your shell rc:"
+    for line in _emit_lines_with_header(header, lines):
+        print(line)
+    readme_path = _write_readme(_emit_lines_with_header(header, lines))
+    if readme_path:
+        print("[install] Reference saved to: %s" % readme_path)
+
+
+def _instructions_for_shell(shell_name, script_dir, alias_name, command):
+    if shell_name == "bash":
+        lines = [
+            'export PATH="%s:$PATH"' % script_dir,
+            'alias %s="%s"' % (alias_name, command),
+        ]
+        return lines
+    if shell_name == "zsh":
+        lines = [
+            'export PATH="%s:$PATH"' % script_dir,
+            'alias %s="%s"' % (alias_name, command),
+        ]
+        return lines
+    if shell_name in ("csh", "tcsh"):
+        lines = [
+            "set path = (%s $path)" % script_dir,
+            "alias %s %s" % (alias_name, command),
+        ]
+        return lines
+    if shell_name == "fish":
+        lines = [
+            "set -U fish_user_paths %s $fish_user_paths" % script_dir,
+            "alias %s %s" % (alias_name, command),
+        ]
+        return lines
+    return None
+
+
+def _path_only_instructions(shell_name, script_dir):
+    if shell_name == "bash":
+        return ['export PATH="%s:$PATH"' % script_dir]
+    if shell_name == "zsh":
+        return ['export PATH="%s:$PATH"' % script_dir]
+    if shell_name in ("csh", "tcsh"):
+        return ["set path = (%s $path)" % script_dir]
+    if shell_name == "fish":
+        return ["set -U fish_user_paths %s $fish_user_paths" % script_dir]
+    return ['export PATH="%s:$PATH"' % script_dir]
+
+
+def _path_contains_dir(path):
+    if not path:
+        return False
+    try:
+        target = os.path.realpath(os.path.abspath(os.path.expanduser(path)))
+    except Exception:
+        target = path
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        try:
+            entry_path = os.path.realpath(os.path.abspath(os.path.expanduser(entry)))
+        except Exception:
+            entry_path = entry
+        if entry_path == target:
+            return True
+    return False
+
+
+def _emit_lines_with_header(header, lines):
+    out = [header]
+    out.extend(lines)
+    return out
+
+
+def _write_readme(lines):
+    readme_path = os.path.join(config.BASE_DIR, "README.txt")
+    try:
+        base_dir = os.path.dirname(readme_path)
+        if base_dir and not os.path.exists(base_dir):
+            os.makedirs(base_dir)
+        with open(readme_path, "w") as f:
+            for line in lines:
+                f.write(line + "\n")
+        return readme_path
+    except Exception:
+        return None

pkgmgr/snapshot.py

@@ -0,0 +1,306 @@
+from __future__ import print_function
+"""Snapshot utilities: hashing and state persistence."""
+
+import os
+import hashlib
+import json
+import fnmatch
+import time
+import sys
+
+from . import config
+
+STATE_DIR = config.DEFAULT_STATE_DIR
+
+
+class DuplicateBaselineError(RuntimeError):
+    """Raised when attempting to create a baseline that already exists."""
+
+
+class ProgressReporter(object):
+    """TTY-friendly one-line progress reporter (no-op when stdout is not a TTY)."""
+
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self._is_tty = sys.stdout.isatty()
+        self._last_len = 0
+        self._label = None
+        self._total = 0
+        self._current = 0
+
+    def start(self, label, total):
+        if not self._is_tty:
+            return
+        self._label = label
+        self._total = int(total or 0)
+        self._current = 0
+        self._render()
+
+    def advance(self, step=1):
+        if not self._is_tty:
+            return
+        self._current += int(step or 0)
+        if self._current > self._total:
+            self._current = self._total
+        self._render()
+
+    def finish(self):
+        if not self._is_tty:
+            return
+        if self._total == 0:
+            self._current = 0
+        else:
+            self._current = self._total
+        self._render(final=True)
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+    def _render(self, final=False):
+        total = self._total
+        current = self._current
+        denom = total if total > 0 else 1
+        pct = int((float(current) / float(denom)) * 100)
+        if total == 0 and final:
+            pct = 100
+        bar_len = 30
+        filled = int((float(current) / float(denom)) * bar_len)
+        bar = "#" * filled + "-" * (bar_len - filled)
+        label = self._label or ""
+        line = "[%s] %s %d/%d %3d%% [%s]" % (
+            self.prefix,
+            label,
+            current,
+            total,
+            pct,
+            bar,
+        )
+        pad = " " * max(0, self._last_len - len(line))
+        sys.stdout.write("\r" + line + pad)
+        sys.stdout.flush()
+        self._last_len = len(line)
+
+
+def _ensure_state_dir():
+    if not os.path.exists(STATE_DIR):
+        os.makedirs(STATE_DIR)
+
+
+def _sha256(path, chunk=1024 * 1024):
+    h = hashlib.sha256()
+    f = open(path, "rb")
+    try:
+        while True:
+            b = f.read(chunk)
+            if not b:
+                break
+            h.update(b)
+    finally:
+        f.close()
+    return h.hexdigest()
+
+
+def _should_skip(relpath, patterns):
+    for p in patterns or []:
+        if fnmatch.fnmatch(relpath, p):
+            return True
+    return False
+
+
+def _count_files(root_abs, exclude):
+    total = 0
+    for base, _, files in os.walk(root_abs):
+        for name in files:
+            abspath = os.path.join(base, name)
+            rel = os.path.relpath(abspath, root_abs).replace("\\", "/")
+            if _should_skip(rel, exclude):
+                continue
+            total += 1
+    return total
+
+
+def _scan(root, exclude, progress=None, label=None):
+    res = {}
+    root_abs = os.path.abspath(os.path.expanduser(root))
+    if not os.path.exists(root_abs):
+        print("[snap] skip missing root: %s" % root_abs)
+        return res
+    if progress and label:
+        total = _count_files(root_abs, exclude)
+        progress.start(label, total)
+    for base, _, files in os.walk(root_abs):
+        for name in files:
+            abspath = os.path.join(base, name)
+            rel = os.path.relpath(abspath, root_abs).replace("\\", "/")
+            if _should_skip(rel, exclude):
+                continue
+            try:
+                st = os.stat(abspath)
+                res[rel] = {
+                    "hash": _sha256(abspath),
+                    "size": int(st.st_size),
+                    "mtime": int(st.st_mtime),
+                }
+            except Exception as e:
+                print("[snap] warn skip %s: %s" % (abspath, str(e)))
+            if progress:
+                progress.advance()
+    if progress and label:
+        progress.finish()
+    return res
+
+
+def _maybe_keep_existing_baseline(path, prompt_overwrite):
+    """
+    When prompt_overwrite=True and baseline exists, ask user (if tty) whether to overwrite.
+    Raises DuplicateBaselineError when overwrite is declined or non-interactive.
+    """
+    if not prompt_overwrite:
+        return None
+    if not os.path.exists(path):
+        return None
+
+    if not sys.stdin.isatty():
+        msg = "[baseline] existing baseline at %s; non-tty -> refusing overwrite" % path
+        raise DuplicateBaselineError(msg)
+
+    ans = input("[baseline] existing baseline at %s; overwrite? [y/N]: " % path).strip().lower()
+    if ans not in ("y", "yes"):
+        msg = "[baseline] keeping existing baseline; skipped overwrite"
+        raise DuplicateBaselineError(msg)
+    return None
+
+
+def _scan_artifacts(cfg, progress=None):
+    """
+    Scan artifact roots/targets similar to sources.
+    artifacts.root: base path (optional)
+    artifacts.targets: names or absolute paths
+    artifacts.exclude: patterns
+    """
+    artifacts_cfg = cfg.get("artifacts") or {}
+    art_root = artifacts_cfg.get("root")
+    art_targets = artifacts_cfg.get("targets") or []
+    art_exclude = artifacts_cfg.get("exclude") or []
+
+    result = {}
+    base_root = os.path.abspath(os.path.expanduser(art_root)) if art_root else None
+    for t in art_targets:
+        target_str = str(t)
+        if base_root and not os.path.isabs(target_str):
+            target_path = os.path.join(base_root, target_str)
+        else:
+            target_path = target_str
+        target_path = os.path.abspath(os.path.expanduser(target_path))
+        label = "artifact %s" % target_path
+        result[target_path] = _scan(target_path, art_exclude, progress=progress, label=label)
+    return result
+
+
+def create_baseline(cfg, prompt_overwrite=False, progress=None):
+    """
+    Collect initial baseline snapshot.
+    Scans sources and artifacts (if configured).
+    """
+    _ensure_state_dir()
+    sources = cfg.get("sources", []) or []
+    src_exclude = (cfg.get("source") or {}).get("exclude", []) or []
+
+    snapshot_data = {
+        "meta": {
+            "ts": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()),
+            "type": "baseline",
+        },
+        "sources": {},
+        "artifacts": {},
+    }
+
+    for root in sources:
+        label = "source %s" % root
+        snapshot_data["sources"][root] = _scan(
+            root, src_exclude, progress=progress, label=label
+        )
+
+    snapshot_data["artifacts"] = _scan_artifacts(cfg, progress=progress)
+
+    path = os.path.join(STATE_DIR, "baseline.json")
+    existing = _maybe_keep_existing_baseline(path, prompt_overwrite)
+    if existing is not None:
+        return existing
+
+    f = open(path, "w")
+    try:
+        json.dump(snapshot_data, f, ensure_ascii=False, indent=2, sort_keys=True)
+    finally:
+        f.close()
+    print("[baseline] saved to %s" % path)
+    return snapshot_data
+
+
+def create_snapshot(cfg, progress=None):
+    """
+    Collect a fresh snapshot (for updates).
+    """
+    _ensure_state_dir()
+    sources = cfg.get("sources", []) or []
+    src_exclude = (cfg.get("source") or {}).get("exclude", []) or []
+
+    snapshot_data = {
+        "meta": {
+            "ts": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()),
+            "type": "snapshot",
+        },
+        "sources": {},
+        "artifacts": {},
+    }
+
+    for root in sources:
+        label = "source %s" % root
+        snapshot_data["sources"][root] = _scan(
+            root, src_exclude, progress=progress, label=label
+        )
+
+    snapshot_data["artifacts"] = _scan_artifacts(cfg, progress=progress)
+
+    path = os.path.join(STATE_DIR, "snapshot.json")
+    f = open(path, "w")
+    try:
+        json.dump(snapshot_data, f, ensure_ascii=False, indent=2, sort_keys=True)
+    finally:
+        f.close()
+    print("[snap] snapshot saved to %s" % path)
+    return snapshot_data
+
+
+def diff_snapshots(base, latest):
+    """Diff two snapshot dicts."""
+    added = []
+    modified = []
+    deleted = []
+
+    def _diff_map(a, b):
+        a_keys = set(a.keys())
+        b_keys = set(b.keys())
+        for k in b_keys - a_keys:
+            added.append(k)
+        for k in a_keys - b_keys:
+            deleted.append(k)
+        for k in a_keys & b_keys:
+            if a[k].get("hash") != b[k].get("hash"):
+                modified.append(k)
+
+    # flatten per-root
+    def _flatten_section(snap, section):
+        flat = {}
+        for root, entries in (snap or {}).get(section, {}).items():
+            for rel, meta in (entries or {}).items():
+                flat[root + "/" + rel] = meta
+        return flat
+
+    a_flat = {}
+    b_flat = {}
+    for section in ("sources", "artifacts"):
+        a_flat.update(_flatten_section(base or {}, section))
+        b_flat.update(_flatten_section(latest or {}, section))
+    _diff_map(a_flat, b_flat)
+
+    return {"added": sorted(added), "modified": sorted(modified), "deleted": sorted(deleted)}

pkgmgr/templates/pkg.yaml.sample

@@ -0,0 +1,16 @@
+pkg:
+  id: "<pkg-id>"
+  root: "/path/to/release/<pkg-id>"
+  status: "open"
+
+include:
+  releases: []
+
+git:
+  repo_root: null  # optional override; default is git rev-parse from cwd
+  keywords: []
+  since: null
+  until: null
+
+collectors:
+  enabled: ["checksums"]

pkgmgr/templates/pkgmgr.yaml.sample

@@ -0,0 +1,51 @@
+pkg_release_root: ~/PKG/RELEASE
+sources:
+  - /path/to/source-A
+  - /path/to/source-B
+  
+source:
+  # 소스 스캔 제외 (glob 지원)
+  exclude:
+    - "**/build/**"
+    - "**/*.tmp"
+    - "**/bk"
+    - "**/*.sc*"
+    - "**/unit_test/**"
+    - "Jamrules*"
+    - "Jamfile*"
+    - "**/Jamrules*"
+    - "**/Jamfile*"
+
+artifacts:
+  root: ~/HOME
+  targets: [bin, lib, data]
+  # 배포/설치 영역 제외 (glob/패턴)
+  exclude:
+    - log                # 정확히 log 디렉터리
+    - tmp/**             # tmp 이하 전체
+    - "*.bak"            # 확장자 패턴
+    - "**/*.tmp"         # 모든 하위에서 .tmp
+
+watch:
+  interval_sec: 60
+  on_change: []   # 변경 발생 시 실행할 action 이름 리스트
+
+collectors:
+  enabled: ["checksums"]
+
+actions:
+  # 각 액션은 하나 이상의 커맨드를 가질 수 있음.
+  # 필드: cmd (필수, 보통 cwd 기준 경로), cwd(선택), env(선택; 이 커맨드에만 적용)
+  export_cksum:
+    - cmd: python export_cksum.py --pkg-dir /path/to/pkg --excel /path/to/template.xlsx
+      cwd: /app/script             # 선택: 작업 디렉터리
+      env: { APP_ENV: dev }        # 선택: 이 명령에만 적용할 환경변수
+  export_world_dev:
+    - cmd: python dev_world.py
+      cwd: /app/script
+  export_world_security:
+    - cmd: python security_world.py
+      cwd: /app/script
+  noti_email:
+    - cmd: sh noti_email.sh
+      cwd: /app/script

pkgmgr/watch.py

@@ -0,0 +1,79 @@
+from __future__ import print_function
+"""Watcher/daemon scaffold."""
+
+import json
+import os
+import time
+
+from . import snapshot, release, points
+
+
+def run(cfg, run_once=False, pkg_id=None, auto_point=False, point_label=None):
+    """
+    Basic poller:
+      - loads last point snapshot (if pkg_id provided) or baseline
+      - takes new snapshot
+      - if diff exists, run watch.on_change actions
+      - optionally create a point after actions
+    """
+    interval = cfg.get("watch", {}).get("interval_sec", 60)
+    print("[watch] starting poller interval=%ss once=%s pkg=%s auto_point=%s" % (interval, run_once, pkg_id, auto_point))
+    if run_once:
+        _tick(cfg, pkg_id=pkg_id, auto_point=auto_point, point_label=point_label)
+        return
+    while True:
+        _tick(cfg, pkg_id=pkg_id, auto_point=auto_point, point_label=point_label)
+        time.sleep(interval)
+
+
+def _load_json(path):
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def _previous_snapshot(pkg_id):
+    """Return previous snapshot data for diff: latest point snapshot if available, else baseline."""
+    if pkg_id:
+        _, snap = points.load_latest_point(pkg_id)
+        if snap:
+            return snap
+    baseline_path = os.path.join(snapshot.STATE_DIR, "baseline.json")
+    return _load_json(baseline_path)
+
+
+def _tick(cfg, pkg_id=None, auto_point=False, point_label=None):
+    if pkg_id and release.pkg_is_closed(pkg_id):
+        print("[watch] pkg=%s is closed; skipping poll" % pkg_id)
+        return
+    prev_snap = _previous_snapshot(pkg_id)
+    current_snap = snapshot.create_snapshot(cfg)
+    if prev_snap:
+        diff = snapshot.diff_snapshots(prev_snap, current_snap)
+        if not any(diff.values()):
+            print("[watch] no changes since last point/baseline")
+            return
+        print("[watch] changes detected: added=%d modified=%d deleted=%d" % (len(diff["added"]), len(diff["modified"]), len(diff["deleted"])))
+    else:
+        print("[watch] no previous snapshot; treating as initial run")
+        diff = None
+
+    actions_to_run = (cfg.get("watch") or {}).get("on_change", []) or []
+    results = []
+    if actions_to_run:
+        results = release.run_actions(cfg, actions_to_run)
+    else:
+        print("[watch] no watch.on_change actions configured")
+
+    if auto_point and pkg_id:
+        label = point_label or "watch-auto"
+        release.create_point(
+            cfg,
+            pkg_id,
+            label=label,
+            actions_run=actions_to_run,
+            actions_result=results,
+            snapshot_data=current_snap,
+        )