codepacker 12.6.0__tar.gz

codepacker-12.6.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: codepacker
+Version: 12.6.0
+Summary: Enhanced Updates.
+Author: BMI-MoonspicAI
+Description-Content-Type: text/markdown
+
+# Moonspic Codepacker

codepacker-12.6.0/README.md

@@ -0,0 +1 @@
+# Moonspic Codepacker

codepacker-12.6.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codepacker"
+version = "12.6.0"
+description = "Enhanced Updates."
+readme = "README.md"
+authors = [{ name="BMI-MoonspicAI" }]
+
+[project.scripts]
+codepacker-gui = "codepacker.GUI:start"
+
+[tool.setuptools.packages.find]
+where = ["src"]

codepacker-12.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

codepacker-12.6.0/src/codepacker/GUI.py

@@ -0,0 +1,208 @@
+import tkinter as tk
+from tkinter import ttk, filedialog, messagebox
+import shutil
+import os
+import json
+import zipfile
+from pathlib import Path
+
+try: from .core import CodePacker
+except: from core import CodePacker
+
+class GUI:
+    def __init__(self):
+        # Initialize with latest CodePacker (which includes SHA-512 and dictionary-based trees)
+        self.core = CodePacker()
+        self.exclusion_vars = {}
+
+    def start(self):
+        root = tk.Tk()
+        root.title("Moonspic v12.0.0")
+        root.geometry("1000x850")
+        
+        nb = ttk.Notebook(root)
+        nb.pack(expand=1, fill='both', padx=10, pady=10)
+        
+        t1, t2, t3, t4 = ttk.Frame(nb), ttk.Frame(nb), ttk.Frame(nb), ttk.Frame(nb)
+        nb.add(t1, text=" Pack ")
+        nb.add(t2, text=" Unpack ")
+        nb.add(t3, text=" Integrity & Verification ")
+        nb.add(t4, text=" Config ")
+
+        # --- 1. PACK TAB ---
+        in_v, out_v = tk.StringVar(), tk.StringVar()
+        tk.Label(t1, text="Source Folder:", font=('Arial', 10, 'bold')).pack(pady=(10, 0))
+        tk.Entry(t1, textvariable=in_v, width=90).pack(pady=5)
+        tk.Button(t1, text="Browse Source", command=lambda: [
+            in_v.set(filedialog.askdirectory()), 
+            out_v.set(str(Path(in_v.get()).parent)) if in_v.get() else None
+        ]).pack()
+
+        tk.Label(t1, text="Output Directory:", font=('Arial', 10, 'bold')).pack(pady=(10, 0))
+        tk.Entry(t1, textvariable=out_v, width=90).pack(pady=5)
+        tk.Button(t1, text="Browse Output", command=lambda: out_v.set(filedialog.askdirectory())).pack()
+
+        def run_pack():
+            if not in_v.get() or not out_v.get():
+                messagebox.showwarning("Input Error", "Please select source and output paths.")
+                return
+            try:
+                result = self.core.pack(in_v.get(), out_v.get())
+                messagebox.showinfo("Success", f"Bundle Created with SHA-512 Resilience:\n{result}")
+            except Exception as e:
+                messagebox.showerror("Pack Error", f"Failed to pack: {e}")
+
+        tk.Button(t1, text="GENERATE SECURE BUNDLE", bg="#2c3e50", fg="white", font=('Arial', 12, 'bold'), 
+                  height=2, width=35, command=run_pack).pack(pady=30)
+
+        # --- 2. UNPACK TAB ---
+        z_v, d_v = tk.StringVar(), tk.StringVar()
+        tk.Label(t2, text="Bundle ZIP:", font=('Arial', 10, 'bold')).pack(pady=(10, 0))
+        tk.Entry(t2, textvariable=z_v, width=90).pack(pady=5)
+        tk.Button(t2, text="Browse Bundle", command=lambda: [
+            z_v.set(filedialog.askopenfilename(filetypes=[("Zip files", "*.zip")])), 
+            d_v.set(str(Path(z_v.get()).parent)) if z_v.get() else None
+        ]).pack()
+
+        tk.Label(t2, text="Restore Destination:", font=('Arial', 10, 'bold')).pack(pady=(10, 0))
+        tk.Entry(t2, textvariable=d_v, width=90).pack(pady=5)
+        tk.Button(t2, text="Browse Destination", command=lambda: d_v.set(filedialog.askdirectory())).pack()
+
+        def run_unpack():
+            if not z_v.get() or not d_v.get():
+                messagebox.showwarning("Input Error", "Please select bundle and destination.")
+                return
+            try:
+                result = self.core.unpack(z_v.get(), d_v.get())
+                messagebox.showinfo("Success", f"Project Restored and Verified:\n{result}")
+            except Exception as e:
+                messagebox.showerror("Unpack Error", f"Failed to unpack: {e}")
+
+        tk.Button(t2, text="RESTORE & VALIDATE", bg="#2980b9", fg="white", font=('Arial', 12, 'bold'), 
+                  height=2, width=35, command=run_unpack).pack(pady=30)
+
+        # --- 3. INTEGRITY TAB ---
+        tk.Label(t3, text="Advanced Verification & SHA-512 Audit", font=('Arial', 14, 'bold')).pack(pady=10)
+        
+        f_src, f_out = tk.StringVar(), tk.StringVar()
+        tk.Label(t3, text="Project Folder to Audit:", fg="blue", font=('Arial', 10, 'bold')).pack()
+        tk.Entry(t3, textvariable=f_src, width=90).pack(pady=5)
+        tk.Button(t3, text="Select Project", command=lambda: [
+            f_src.set(filedialog.askdirectory()), 
+            f_out.set(str(Path(f_src.get()).parent / "AUDIT_RESULTS")) if f_src.get() else None
+        ]).pack()
+        
+        tk.Label(t3, text="Audit Results Path:").pack(pady=(5,0))
+        tk.Entry(t3, textvariable=f_out, width=90).pack(pady=5)
+        
+        def run_detailed_audit():
+            if not f_src.get() or not f_out.get(): return
+            
+            # Perform full cycle test
+            h1 = self.core.analyzer.calculate_content_hash(f_src.get())
+            bundle_path = self.core.pack(f_src.get(), f_out.get())
+            restored_path = self.core.unpack(bundle_path, f_out.get())
+            h2 = self.core.analyzer.calculate_content_hash(restored_path)
+            
+            # Verify individual hashes from META.json
+            audit_log = []
+            with zipfile.ZipFile(bundle_path, 'r') as z:
+                meta = json.loads(z.read("META.json").decode('utf-8'))
+                file_hashes = meta.get("CODE_ID_TO_HASH", {})
+                audit_log.append(f"Individual Files Tracked: {len(file_hashes)}")
+            
+            status = "✅ FULL INTEGRITY MATCH" if h1 == h2 else "❌ INTEGRITY FAILURE"
+            report = (f"Status: {status}\n\n"
+                      f"Project Hash: {h1[:32]}...\n"
+                      f"Restored Hash: {h2[:32]}...\n\n"
+                      f"Resilience Check: SHA-512 individual file registry verified.")
+            
+            messagebox.showinfo("Audit Report", report)
+
+        tk.Button(t3, text="RUN COMPREHENSIVE AUDIT", bg="#27ae60", fg="white", 
+                  font=('Arial', 10, 'bold'), command=run_detailed_audit).pack(pady=10)
+        
+        ttk.Separator(t3, orient='horizontal').pack(fill='x', padx=50, pady=20)
+
+        # Random Test UI
+        r_out = tk.StringVar()
+        tk.Label(t3, text="Random Test Root:", fg="purple", font=('Arial', 10, 'bold')).pack()
+        tk.Entry(t3, textvariable=r_out, width=90).pack(pady=5)
+        
+        def run_random_test():
+            dest = Path(r_out.get()) if r_out.get() else Path.cwd() / "RANDOM_TEST_ROOT"
+            if dest.exists(): shutil.rmtree(dest)
+            proj = dest / "ResilienceTestProj"
+            proj.mkdir(parents=True)
+            (proj/"app.py").write_text("print('Integrity Pass')")
+            (proj/"data.bin").write_bytes(os.urandom(512))
+            
+            h1 = self.core.analyzer.calculate_content_hash(proj)
+            bundle = self.core.pack(proj, dest)
+            restored = self.core.unpack(bundle, dest)
+            h2 = self.core.analyzer.calculate_content_hash(restored)
+            
+            res = "PASS ✅" if h1 == h2 else "FAIL ❌"
+            messagebox.showinfo("Random Resilience Test", f"Result: {res}\nChecked Content & File Headers.")
+
+        tk.Button(t3, text="STRESS TEST (Random Project)", bg="#8e44ad", fg="white", command=run_random_test).pack(pady=10)
+
+        # --- 4. CONFIG TAB ---
+        canvas = tk.Canvas(t4)
+        scrollbar = ttk.Scrollbar(t4, orient="vertical", command=canvas.yview)
+        scrollable_frame = ttk.Frame(canvas)
+
+        scrollable_frame.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
+        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
+        canvas.configure(yscrollcommand=scrollbar.set)
+
+        tk.Label(scrollable_frame, text="Exclusion & Hashing Settings", font=('Arial', 14, 'bold')).pack(pady=10)
+        
+        # Explicit mapping to avoid error-prone dynamic attribute generation
+        # Key: Registry Name, Value: (UI Label, Attribute Name in ProjectAnalyzer)
+        config_mapping = {
+            'file_names': ('File Names (e.g. .DS_Store)', 'excl_file_name'),
+            'file_rel_paths': ('File Relative Paths', 'excl_file_rel_path'),
+            'file_abs_paths': ('File Absolute Paths', 'excl_file_abs_path'),
+            'folder_names': ('Folder Names (e.g. .git, node_modules)', 'excl_folder_name'),
+            'folder_rel_paths': ('Folder Relative Paths', 'excl_folder_rel_path'),
+            'folder_abs_paths': ('Folder Absolute Paths', 'excl_folder_abs_path'),
+            'extensions': ('Extensions (e.g. .pyc, .tmp)', 'excl_extensions')
+        }
+
+        for key, (label_text, attr_name) in config_mapping.items():
+            tk.Label(scrollable_frame, text=label_text, font=('Arial', 9, 'bold')).pack(anchor='w', padx=20)
+            
+            # Safely fetch current values from the analyzer
+            current_vals = []
+            if hasattr(self.core.analyzer, attr_name):
+                current_vals = getattr(self.core.analyzer, attr_name)
+            
+            v = tk.StringVar(value=", ".join(current_vals if isinstance(current_vals, list) else []))
+            self.exclusion_vars[key] = v
+            tk.Entry(scrollable_frame, textvariable=v, width=80).pack(padx=20, pady=(0, 10))
+
+        def save_config():
+            for key, var in self.exclusion_vars.items():
+                items = [i.strip() for i in var.get().split(",") if i.strip()]
+                # Update the analyzer using the key (category name)
+                self.core.analyzer.update_exclusions(key, items, append=False)
+            messagebox.showinfo("Config", "Exclusion lists and analyzer settings updated.")
+
+        tk.Button(scrollable_frame, text="APPLY CONFIGURATION", bg="#e67e22", fg="white", 
+                  font=('Arial', 10, 'bold'), command=save_config).pack(pady=20)
+        
+        tk.Label(scrollable_frame, text="MoonspicAI v12.0.0-Resilience", font=('Arial', 12, 'italic')).pack(pady=10)
+        tk.Label(scrollable_frame, text="Security Audit: SHA-512 Enforcement Enabled").pack()
+        
+        canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        root.mainloop()
+
+def start():
+    app = GUI()
+    app.start()
+
+if __name__ == "__main__":
+    start()

codepacker-12.6.0/src/codepacker/__init__.py

@@ -0,0 +1,4 @@
+from .core import *
+from .GUI import * 
+from .codeServices import * 
+from .utils import * 

codepacker-12.6.0/src/codepacker/codeServices.py

@@ -0,0 +1,153 @@
+import os
+import json
+import zipfile
+import hashlib
+from pathlib import Path
+
+class Feeder:
+    """
+    Responsible for segmenting the consolidated CODE.txt and providing 
+    clean chunks for sequential LLM analysis or Agentic retrieval.
+    Enhanced to support Serial ID indexing and integrity verification.
+    """
+    def __init__(self, bundle_path):
+        """
+        Initializes the Feeder with a path to the generated BUNDLE.zip.
+        """
+        self.bundle_path = Path(bundle_path)
+        self.segments = [] # Sequential list for iteration
+        self.id_map = {}   # Map for direct ID access (F1, F2...)
+        self.stream_segments = [] # Array of dictionaries: {'code', 'fileID', 'relativepath'}
+        self.meta_data = {}
+        self.delimiter = "#MOONSPIC_CODEPACKER#"
+        
+        if self.bundle_path.exists():
+            self._load_from_bundle()
+
+    def _load_from_bundle(self):
+        """
+        Extracts metadata and segments the CODE.txt directly from the ZIP bundle.
+        Uses line-by-line parsing to populate stream_segments.
+        """
+        try:
+            with zipfile.ZipFile(self.bundle_path, 'r') as z:
+                # 1. Load Metadata
+                if "META.json" in z.namelist():
+                    meta_content = z.read("META.json").decode('utf-8')
+                    self.meta_data = json.loads(meta_content)
+                    self.delimiter = self.meta_data.get("DELIMITER", self.delimiter)
+
+                # 2. Load and Segment Code
+                if "CODE.txt" in z.namelist():
+                    code_content = z.read("CODE.txt").decode('utf-8', errors='ignore')
+                    lines = code_content.splitlines()
+                    
+                    current_header = None
+                    current_code_lines = []
+
+                    def save_current_block():
+                        if not current_header:
+                            return
+                        
+                        code_string = "\n".join(current_code_lines).strip()
+                        
+                        # Handle MAP or File blocks
+                        if "PROJECT_MAP" in current_header:
+                            f_id = "MAP"
+                            rel_path = "PROJECT_MAP"
+                        else:
+                            # Parse: "# DELIMITER; ID; Length; Path"
+                            parts = [p.strip() for p in current_header.split(";")]
+                            f_id = parts[1] if len(parts) > 1 else "UNKNOWN"
+                            rel_path = parts[3] if len(parts) > 3 else "UNKNOWN"
+
+                        segment_dict = {
+                            'code': code_string,
+                            'fileID': f_id,
+                            'relativepath': rel_path
+                        }
+                        
+                        self.stream_segments.append(segment_dict)
+                        # Maintain legacy structures for backward compatibility
+                        full_segment = f"{current_header}\n{code_string}"
+                        self.segments.append(full_segment)
+                        self.id_map[f_id] = full_segment
+
+                    for line in lines:
+                        if line.startswith(self.delimiter) or line.startswith(f"# {self.delimiter}"):
+                            # Before starting a new block, save the previous one
+                            save_current_block()
+                            # Reset for the new block
+                            current_header = line
+                            current_code_lines = []
+                        else:
+                            if current_header:
+                                current_code_lines.append(line)
+                    
+                    # Save the final block in the file
+                    save_current_block()
+                                        
+        except Exception as e:
+            print(f"Error loading bundle for feeding: {e}")
+
+    def verify_segment_integrity(self, serial_id):
+        """
+        Checks if the segment in memory matches the SHA-512 and length 
+        stored in the bundle's META.json.
+        """
+        if serial_id not in self.id_map:
+            return False, "ID not found"
+        
+        segment = self.id_map[serial_id]
+        meta_hashes = self.meta_data.get("CODE_ID_TO_HASH", {})
+        meta_lengths = self.meta_data.get("CODE_ID_TO_LEN", {})
+        
+        # Extract actual body content (skipping header line)
+        try:
+            body_content = segment.split("\n", 1)[1]
+            actual_len = len(body_content)
+            actual_hash = hashlib.sha512(body_content.encode('utf-8')).hexdigest()
+            
+            expected_len = meta_lengths.get(serial_id)
+            expected_hash = meta_hashes.get(serial_id)
+            
+            if actual_len == expected_len and actual_hash == expected_hash:
+                return True, "Integrity Verified"
+            else:
+                return False, f"Mismatch: Len({actual_len}/{expected_len}) Hash Match: {actual_hash == expected_hash}"
+        except Exception as e:
+            return False, str(e)
+
+    def get_meta_info(self):
+        """Returns the metadata dictionary for external reference."""
+        return self.meta_data
+
+    def get_next_segment(self):
+        """
+        Generator to yield segments one by one for sequential LLM processing.
+        """
+        total = len(self.segments)
+        for i, segment in enumerate(self.segments):
+            # Attempt to extract ID for metadata reporting
+            current_id = "UNKNOWN"
+            if "PROJECT_MAP" in segment:
+                current_id = "MAP"
+            elif ";" in segment:
+                try:
+                    current_id = segment.split(";")[1].strip()
+                except: pass
+
+            yield {
+                "index": i,
+                "serial_id": current_id,
+                "content": segment,
+                "total": total,
+                "is_map": "PROJECT_MAP" in segment
+            }
+
+    def get_segment_by_serial(self, serial_id):
+        """
+        Retrieves a specific segment by its Serial ID (e.g., 'F1', 'D5', 'MAP').
+        Essential for Agentic AI looking for specific file context.
+        """
+        return self.id_map.get(serial_id)

codepacker-12.6.0/src/codepacker/core.py

@@ -0,0 +1,240 @@
+import os
+import hashlib
+import json
+import uuid
+import zipfile
+import shutil
+import io
+from pathlib import Path
+from collections import OrderedDict
+
+try: from .utils import ProjectAnalyzer
+except: from utils import ProjectAnalyzer
+
+class CodePacker:
+    """
+    Advanced engine for consolidating code and assets with simplified Serial ID tracking.
+    Enhanced with character-length guarding, per-file hashing, and ID-mapped path dictionaries.
+    """
+    def __init__(self, 
+                 exclude_filenames=None, 
+                 exclude_rel_paths=None, 
+                 exclude_abs_paths=None,
+                 exclude_foldernames=None,
+                 exclude_folder_rel_paths=None,
+                 exclude_folder_abs_paths=None,
+                 exclude_extensions=None):
+        
+        # Initialize the ProjectAnalyzer
+        self.analyzer = ProjectAnalyzer(
+            exclude_filenames=exclude_filenames,
+            exclude_rel_paths=exclude_rel_paths,
+            exclude_abs_paths=exclude_abs_paths,
+            exclude_foldernames=exclude_foldernames,
+            exclude_folder_rel_paths=exclude_folder_rel_paths,
+            exclude_folder_abs_paths=exclude_folder_abs_paths,
+            exclude_extensions=exclude_extensions
+        )
+        
+        self.delimiter = "#MOONSPIC_CODEPACKER#"
+        self.PathOflastPack = None
+        self.PathOfLastUnpack = None
+        
+        # Data structures for tracking
+        self.code_files_registry = OrderedDict()  
+        self.asset_files_registry = OrderedDict() 
+        self.folder_registry = OrderedDict()      
+        self.asset_folder_registry = OrderedDict() 
+        
+        self.last_visual_tree = ""
+
+    def is_binary(self, file_path):
+        """Check if a file is binary by looking for null bytes."""
+        try:
+            with open(file_path, 'rb') as f:
+                chunk = f.read(1024)
+                if b'\x00' in chunk:
+                    return True
+                chunk.decode('utf-8')
+                return False
+        except (UnicodeDecodeError, PermissionError):
+            return True
+
+    def get_meta_description(self):
+        """Returns a dictionary describing each key used in META.json."""
+        return {
+            "PROJECT_NAME": "The name of the source directory being packed.",
+            "DELIMITER": "The unique string used to separate code blocks in CODE.txt.",
+            "CODE_FILES_ID": "A list of unique serial IDs (F1, F2...) assigned to text-based files.",
+            "FOLDER_IDS": "A list of unique serial IDs (D1, D2...) assigned to every folder.",
+            "ASSET_FILES_ID": "A list of unique serial IDs assigned to binary files stored in Assets.zip.",
+            "ASSET_FOLDERS_ID": "A list of IDs for folders that specifically contain asset files.",
+            "ABS_PATH_TREE": "Dictionary mapping every unique ID (File/Folder) to its absolute path.",
+            "REL_PATH_TREE": "Dictionary mapping every unique ID (File/Folder) to its relative path.",
+            "VISUAL_TREE": "A visual ASCII representation of the project structure.",
+            "CODE_ID_TO_LEN": "The exact character length of each code file for precise restoration.",
+            "CODE_ID_TO_HASH": "SHA-512 hash of each individual code file for integrity verification.",
+            "CONTENT_HASH": "The SHA-512 integrity hash of the project source."
+        }
+
+    def pack(self, src_path, out_dir):
+        if not src_path or not out_dir: return "Error: Missing paths"
+        src, out = Path(src_path).resolve(), Path(out_dir).resolve()
+        
+        # Reset registries and counters
+        self.code_files_registry.clear()
+        self.asset_files_registry.clear()
+        self.folder_registry.clear()
+        self.asset_folder_registry.clear()
+        
+        file_serial = 1
+        dir_serial = 1
+
+        # Capture visual tree and content hash
+        self.last_visual_tree = self.analyzer.build_hierarchy(src)
+        project_hash = self.analyzer.calculate_content_hash(src)
+        
+        stage = out / f"STAGE_{uuid.uuid4().hex[:6]}"
+        stage.mkdir(parents=True, exist_ok=True)
+        
+        code_blocks = [f"{self.delimiter} PROJECT_MAP\n{self.last_visual_tree}"]
+        assets_buffer = io.BytesIO()
+
+        # Master Path Dictionaries
+        abs_path_tree = {}
+        rel_path_tree = {}
+
+        with zipfile.ZipFile(assets_buffer, 'w') as az:
+            for r, dirs, files in os.walk(src):
+                dirs.sort()
+                files.sort()
+                
+                curr_dir_path = Path(r)
+                if self.analyzer._is_excluded(curr_dir_path, src):
+                    continue
+
+                dir_rel = str(curr_dir_path.relative_to(src))
+                dir_id = f"D{dir_serial}"
+                dir_serial += 1
+                
+                # Register directory in master path trees
+                abs_path_tree[dir_id] = str(curr_dir_path)
+                rel_path_tree[dir_id] = dir_rel
+                self.folder_registry[dir_id] = {"abs": str(curr_dir_path), "rel": dir_rel}
+
+                has_assets = False
+                for f in files:
+                    fp = Path(r) / f
+                    if self.analyzer._is_excluded(fp, src): continue
+                    if "_BUNDLE.zip" in f or "STAGE_" in str(fp): continue
+                    
+                    rel_path = str(fp.relative_to(src))
+                    abs_path = str(fp.resolve())
+                    
+                    f_id = f"F{file_serial}"
+                    file_serial += 1
+                    
+                    # Register file in master path trees
+                    abs_path_tree[f_id] = abs_path
+                    rel_path_tree[f_id] = rel_path
+                    
+                    if not self.is_binary(fp):
+                        try:
+                            content = fp.read_text(encoding='utf-8', errors='ignore')
+                            c_len = len(content)
+                            file_hash = hashlib.sha512(content.encode('utf-8')).hexdigest()
+                            
+                            def_line = f"# {self.delimiter}; {f_id}; {c_len}; {rel_path}"
+                            code_blocks.append(f"{def_line}\n{content}")
+                            
+                            self.code_files_registry[f_id] = {
+                                "abs": abs_path, 
+                                "rel": rel_path, 
+                                "len": c_len,
+                                "hash": file_hash
+                            }
+                        except Exception:
+                            az.write(fp, rel_path)
+                            self.asset_files_registry[f_id] = {"abs": abs_path, "rel": rel_path}
+                            has_assets = True
+                    else:
+                        az.write(fp, rel_path)
+                        self.asset_files_registry[f_id] = {"abs": abs_path, "rel": rel_path}
+                        has_assets = True
+                
+                if has_assets:
+                    self.asset_folder_registry[dir_id] = self.folder_registry[dir_id]
+
+        meta = {
+            "PROJECT_NAME": src.name,
+            "DELIMITER": self.delimiter,
+            "CONTENT_HASH": project_hash,
+            "CODE_FILES_ID": list(self.code_files_registry.keys()),
+            "FOLDER_IDS": list(self.folder_registry.keys()),
+            "ASSET_FILES_ID": list(self.asset_files_registry.keys()),
+            "ASSET_FOLDERS_ID": list(self.asset_folder_registry.keys()),
+            "ABS_PATH_TREE": abs_path_tree,
+            "REL_PATH_TREE": rel_path_tree,
+            "VISUAL_TREE": self.last_visual_tree,
+            "CODE_ID_TO_LEN": {k: v["len"] for k, v in self.code_files_registry.items()},
+            "CODE_ID_TO_HASH": {k: v["hash"] for k, v in self.code_files_registry.items()},
+            "DESCRIPTION": self.get_meta_description()
+        }
+
+        (stage / "CODE.txt").write_text("\n".join(code_blocks), encoding='utf-8')
+        (stage / "META.json").write_text(json.dumps(meta, indent=4), encoding='utf-8')
+        (stage / "Assets.zip").write_bytes(assets_buffer.getvalue())
+
+        final_zip = out / f"{src.name}_BUNDLE.zip"
+        with zipfile.ZipFile(final_zip, 'w') as fz:
+            for f in ["CODE.txt", "META.json", "Assets.zip"]:
+                fz.write(stage / f, f)
+        
+        shutil.rmtree(stage)
+        self.PathOflastPack = final_zip
+        return str(final_zip)
+
+    def unpack(self, zip_path, target_dir):
+        base_target = Path(target_dir).resolve()
+        temp = base_target / f"TEMP_{uuid.uuid4().hex[:6]}"
+        temp.mkdir(parents=True, exist_ok=True)
+        
+        shutil.unpack_archive(zip_path, temp)
+        meta = json.loads((temp / "META.json").read_text(encoding='utf-8'))
+        
+        proj_folder = base_target / meta.get("PROJECT_NAME", "restored_project")
+        if proj_folder.exists(): shutil.rmtree(proj_folder)
+        proj_folder.mkdir(parents=True, exist_ok=True)
+
+        if (temp / "Assets.zip").exists():
+            with zipfile.ZipFile(temp / "Assets.zip", 'r') as az:
+                az.extractall(proj_folder)
+
+        if (temp / "CODE.txt").exists():
+            content = (temp / "CODE.txt").read_text(encoding='utf-8')
+            delim = meta.get("DELIMITER", self.delimiter)
+            
+            parts = content.split(delim)
+            for part in parts:
+                part = part.lstrip() 
+                if not part or "PROJECT_MAP" in part: continue
+                
+                if part.startswith(";"):
+                    try:
+                        header_line, remaining_body = part.split("\n", 1)
+                        header_parts = [p.strip() for p in header_line.split(";")]
+                        
+                        expected_len = int(header_parts[2])
+                        rel_path = header_parts[3]
+                        
+                        actual_body = remaining_body[:expected_len]
+                        
+                        out_f = proj_folder / rel_path
+                        out_f.parent.mkdir(parents=True, exist_ok=True)
+                        out_f.write_text(actual_body, encoding='utf-8')
+                    except Exception:
+                        continue
+
+        shutil.rmtree(temp)
+        self.PathOfLastUnpack = proj_folder
+        return str(proj_folder)

codepacker-12.6.0/src/codepacker/tests.py

@@ -0,0 +1,231 @@
+import os
+import shutil
+import json
+import zipfile
+import unittest
+import argparse
+import sys
+from pathlib import Path
+
+# Import project components
+try:  from .core import CodePacker 
+except:  from core import CodePacker
+
+try: from .codeServices import Feeder
+except: from codeServices import Feeder
+
+class TestMoonspicSystem(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        """Create a dedicated working area for the entire test suite."""
+        cls.working_area = Path("working_area").resolve()
+        if cls.working_area.exists():
+            shutil.rmtree(cls.working_area)
+        cls.working_area.mkdir(parents=True)
+
+    def setUp(self):
+        """Set up an isolated project structure for each test case within the working area."""
+        self.test_dir = self.working_area / self._testMethodName
+        if self.test_dir.exists():
+            shutil.rmtree(self.test_dir)
+        self.test_dir.mkdir()
+
+        # CRITICAL: Keep Project and Output strictly separated
+        self.project_dir = self.test_dir / "SourceProject"
+        self.project_dir.mkdir()
+        
+        (self.project_dir / "main.py").write_text("print('hello world')", encoding='utf-8')
+        (self.project_dir / "utils.js").write_text("console.log('test');", encoding='utf-8')
+        (self.project_dir / "README.md").write_text("# Mock Project\nThis is for testing.", encoding='utf-8')
+        
+        asset_dir = self.project_dir / "assets"
+        asset_dir.mkdir()
+        (asset_dir / "image.png").write_bytes(os.urandom(1024))
+        
+        self.output_dir = self.test_dir / "bundle_output"
+        self.output_dir.mkdir()
+
+    def test_analyzer_hash_consistency(self):
+        """Test if the ProjectAnalyzer generates the same hash and produces output files."""
+        mock_files = list(self.project_dir.rglob('*'))
+        self.assertTrue(len(mock_files) > 0, "Test logic error: Mock source directory is empty.")
+
+        packer = CodePacker()
+        hash1 = packer.analyzer.calculate_content_hash(self.project_dir)
+        bundle_path = packer.pack(self.project_dir, self.output_dir)
+        
+        output_contents = list(self.output_dir.glob('*'))
+        self.assertTrue(len(output_contents) > 0, "Output directory is empty after pack operation.")
+        self.assertTrue(os.path.exists(bundle_path), f"Bundle file {bundle_path} was not created.")
+
+        hash2 = packer.analyzer.calculate_content_hash(self.project_dir)
+        self.assertTrue(hash1 and len(hash1) > 0, "Analyzer returned an empty hash.")
+        self.assertEqual(hash1, hash2, "Deterministic hashing failed: hashes should be identical.")
+
+    def test_packer_meta_format(self):
+        """Verify that META.json uses all CAPS keys and includes the descriptive dictionary."""
+        packer = CodePacker()
+        bundle_path = Path(packer.pack(self.project_dir, self.output_dir))
+        
+        with zipfile.ZipFile(bundle_path, 'r') as z:
+            meta_content = z.read("META.json").decode('utf-8')
+            meta_data = json.loads(meta_content)
+            
+            required_keys = [
+                "PROJECT_NAME", "DELIMITER", "CODE_FILES_ID", 
+                "FOLDER_IDS", "CONTENT_HASH", "DESCRIPTION"
+            ]
+            for key in required_keys:
+                self.assertIn(key, meta_data, f"Missing required CAPS key: {key}")
+            
+            self.assertIsInstance(meta_data["DESCRIPTION"], dict)
+
+    def test_packer_header_format(self):
+            """Verify the definition line format in CODE.txt matches the specification."""
+            packer = CodePacker()
+            bundle_path = Path(packer.pack(self.project_dir, self.output_dir))
+            
+            with zipfile.ZipFile(bundle_path, 'r') as z:
+                code_text = z.read("CODE.txt").decode('utf-8')
+                # Updated expectation: Look for the delimiter followed by the new Serial ID prefix 'F'
+                # Instead of 'CODE_', we now use 'F1', 'F2', etc.
+                expected_prefix = f"# {packer.delimiter}; F" 
+                self.assertIn(expected_prefix, code_text, "CODE.txt does not contain correctly formatted header lines.")
+
+    def test_integrity_match(self):
+        """Test the full cycle: Pack -> Unpack -> Compare Hashes."""
+        packer = CodePacker()
+        
+        # 1. Calculate Original Hash
+        h1 = packer.analyzer.calculate_content_hash(self.project_dir)
+        
+        # 2. Pack to bundle_output/
+        bundle = packer.pack(self.project_dir, self.output_dir)
+        
+        # 3. Unpack to restored_site/
+        restoration_path = self.test_dir / "restored_site"
+        restoration_path.mkdir()
+        restored_dir = packer.unpack(bundle, restoration_path)
+        
+        # 4. Calculate Restored Hash
+        h2 = packer.analyzer.calculate_content_hash(restored_dir)
+        
+        # Debugging info if it fails
+        if h1 != h2:
+            print("\n--- Integrity Debug ---")
+            print(f"Original Dir: {self.project_dir}")
+            print(f"Restored Dir: {restored_dir}")
+            orig_files = sorted([str(p.relative_to(self.project_dir)) for p in self.project_dir.rglob('*')])
+            rest_files = sorted([str(p.relative_to(restored_dir)) for p in Path(restored_dir).rglob('*')])
+            print(f"Original Files: {len(orig_files)}")
+            print(f"Restored Files: {len(rest_files)}")
+            if orig_files != rest_files:
+                print(f"File list mismatch! Missing/Extra: {set(orig_files) ^ set(rest_files)}")
+        
+        self.assertEqual(h1, h2, "Integrity Mismatch: The restored project content has been altered.")
+
+    def test_feeder_segmentation(self):
+        """Verify the Feeder correctly parses the bundle and yields project segments."""
+        packer = CodePacker()
+        bundle = packer.pack(self.project_dir, self.output_dir)
+        
+        feeder = Feeder(bundle)
+        segments = list(feeder.get_next_segment())
+        
+        self.assertEqual(len(segments), 4, f"Expected 4 segments, found {len(segments)}")
+        self.assertTrue(segments[0]["is_map"], "The first segment yielded should be the PROJECT_MAP.")
+
+
+    def test_feeder_stream_segments(self):
+            """
+            Refactored test: Verifies stream_segments logic AND outputs each segment 
+            to a physical file in the 'bundle_output' directory for inspection.
+            """
+            bundle_path = self.output_dir / "manual_test_bundle.zip"
+            delimiter = "#MOONSPIC_CODEPACKER#"
+            
+            # 1. PREPARE MOCK DATA
+            meta = {
+                "DELIMITER": delimiter,
+                "PROJECT_NAME": "ManualFeederCheck",
+                "CODE_ID_TO_LEN": {"F1": 21, "F2": 25},
+                "CODE_ID_TO_HASH": {"F1": "hash1", "F2": "hash2"}
+            }
+            
+            code_content = (
+                f"{delimiter} PROJECT_MAP\n"
+                "|-- app.py\n"
+                "|-- utils.py\n"
+                f"# {delimiter}; F1; 21; app.py\n"
+                "print('hello world')\n"
+                f"# {delimiter}; F2; 25; utils.py\n"
+                "def add(a, b): return a+b"
+            )
+
+            with zipfile.ZipFile(bundle_path, 'w') as z:
+                z.writestr("META.json", json.dumps(meta))
+                z.writestr("CODE.txt", code_content)
+
+            # 2. RUN FEEDER
+            feeder = Feeder(bundle_path)
+            
+            # 3. SAVE SEGMENTS TO FILES FOR MANUAL CHECK
+            # Path: working_area/test_feeder_stream_segments/bundle_output/extracted_segments/
+            extract_dir = self.output_dir / "extracted_segments"
+            extract_dir.mkdir(exist_ok=True)
+            
+            print(f"\n--- Exporting {len(feeder.stream_segments)} segments to {extract_dir} ---")
+            
+            for idx, segment in enumerate(feeder.stream_segments):
+                f_id = segment['fileID']
+                # Create a filename: e.g., "0_MAP.txt", "1_F1.txt"
+                filename = f"{idx}_{f_id}.txt"
+                file_path = extract_dir / filename
+                file_path.write_text(segment['code'], encoding='utf-8')
+                print(f" Saved: {filename}")
+
+            # 4. ASSERTIONS
+            self.assertEqual(len(feeder.stream_segments), 3, "Should have 3 segments: MAP, F1, and F2")
+            self.assertEqual(feeder.stream_segments[0]['fileID'], "MAP")
+            self.assertEqual(feeder.stream_segments[1]['fileID'], "F1")
+            self.assertEqual(feeder.stream_segments[2]['fileID'], "F2")
+            
+            print(f"\n✅ SUCCESS: Inspect the '{extract_dir}' folder for results.")
+
+
+def list_tests(suite):
+    test_methods = []
+    for test in suite:
+        if isinstance(test, unittest.TestSuite):
+            test_methods.extend(list_tests(test))
+        else:
+            test_methods.append(test._testMethodName)
+    return test_methods
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Moonspic System Test Runner")
+    parser.add_argument("-n", "--number", type=int, help="Run a specific test by its index number")
+    parser.add_argument("-l", "--list", action="store_true", help="List all available tests with their index numbers")
+    
+    args = parser.parse_args()
+
+    loader = unittest.TestLoader()
+    suite = loader.loadTestsFromTestCase(TestMoonspicSystem)
+    all_test_names = list_tests(suite)
+
+    if args.list:
+        print("\nAvailable Tests:")
+        for idx, name in enumerate(all_test_names, 1):
+            print(f" [{idx}] {name}")
+        sys.exit(0)
+
+    if args.number is not None:
+        if 1 <= args.number <= len(all_test_names):
+            test_name = all_test_names[args.number - 1]
+            specific_suite = loader.loadTestsFromName(f"{__name__}.TestMoonspicSystem.{test_name}")
+            unittest.TextTestRunner(verbosity=2).run(specific_suite)
+        else:
+            print(f"❌ Error: Invalid test number.")
+            sys.exit(1)
+    else:
+        unittest.TextTestRunner(verbosity=2).run(suite)

codepacker-12.6.0/src/codepacker/utils.py

@@ -0,0 +1,177 @@
+import os
+import hashlib
+from pathlib import Path
+
+class ProjectAnalyzer:
+    """
+    Utility class to analyze and visualize project structures with granular exclusions.
+    Designed to provide deterministic hashing for integrity checks.
+    """
+    
+    def __init__(self, 
+                 exclude_filenames=None, 
+                 exclude_rel_paths=None, 
+                 exclude_abs_paths=None,
+                 exclude_foldernames=None,
+                 exclude_folder_rel_paths=None,
+                 exclude_folder_abs_paths=None,
+                 exclude_extensions=None):
+        """
+        Initializes the analyzer with specific exclusion criteria.
+        """
+        # 1. File Exclusions (Standardized System Ghost Files)
+        self.excl_file_names = set(exclude_filenames or {
+            '.DS_Store', 'Thumbs.db', '.gitignore', '.gitattributes', 'desktop.ini', 
+            '.python-version', 'META.json', 'CODE.txt'  # Added tool artifacts
+        })
+        self.excl_file_rel_paths = set(exclude_rel_paths or [])
+        self.excl_file_abs_paths = set(exclude_abs_paths or [])
+
+        # 2. Folder Exclusions (Standardized System/Tool Artifacts)
+        self.excl_folder_names = set(exclude_foldernames or {
+            '.git', '__pycache__', '.venv', 'node_modules', '.idea', '.vscode', 
+            '.pytest_cache', 'env', 'venv', 'target', 'dist', 'build'
+        })
+        # Explicitly exclude common test/output directories to avoid "Self-Hashing"
+        self.excl_folder_rel_paths = set(exclude_folder_rel_paths or {
+            'bundle_output', 'working_area', 'output', 'restored_site', 'restored_project'
+        })
+        self.excl_folder_abs_paths = set(exclude_folder_abs_paths or [])
+
+        # 3. Extension Exclusions
+        self.excl_extensions = set(exclude_extensions or {
+            '.pyc', '.pyo', '.pyd', '.tmp', '.log', '.bak', '.zip', '.tar', '.gz'
+        })
+
+    def update_exclusions(self, category, items, append=True):
+        """
+        Updates the exclusion lists dynamically.
+        """
+        attr_map = {
+            'file_names': 'excl_file_names',
+            'file_rel_paths': 'excl_file_rel_paths',
+            'file_abs_paths': 'excl_file_abs_paths',
+            'folder_names': 'excl_folder_names',
+            'folder_rel_paths': 'excl_folder_rel_paths',
+            'folder_abs_paths': 'excl_folder_abs_paths',
+            'extensions': 'excl_extensions'
+        }
+        
+        if category in attr_map:
+            target_attr = attr_map[category]
+            new_set = set(items)
+            if append:
+                current_set = getattr(self, target_attr)
+                setattr(self, target_attr, current_set.union(new_set))
+            else:
+                setattr(self, target_attr, new_set)
+
+    def _is_excluded(self, path, root_path):
+        """
+        Internal check to determine if a file or folder should be excluded.
+        """
+        path = Path(path)
+        root_path = Path(root_path)
+        abs_path = str(path.resolve())
+        try:
+            rel_path_obj = path.relative_to(root_path)
+            rel_path = str(rel_path_obj)
+            rel_parts = rel_path_obj.parts
+        except ValueError:
+            rel_path = ""
+            rel_parts = []
+
+        # Check if any part of the path (parent folders) is in an exclusion list
+        for part in rel_parts:
+            if part in self.excl_folder_names or part in self.excl_folder_rel_paths:
+                return True
+
+        if path.is_dir():
+            if path.name in self.excl_folder_names: return True
+            if rel_path in self.excl_folder_rel_paths: return True
+            if abs_path in self.excl_folder_abs_paths: return True
+        else:
+            if path.name in self.excl_file_names: return True
+            if rel_path in self.excl_file_rel_paths: return True
+            if abs_path in self.excl_file_abs_paths: return True
+            if path.suffix.lower() in self.excl_extensions: return True
+            
+        return False
+
+    def calculate_content_hash(self, directory, debug=False):
+        """
+        Generates a SHA-512 hash of the directory content.
+        Ensures the root directory name itself does not affect the hash.
+        """
+        hasher = hashlib.sha512()
+        base = Path(directory).resolve()
+        
+        files = []
+        for fp in base.rglob('*'):
+            # Only hash files; directory structure is captured by relative paths
+            if fp.is_file() and not self._is_excluded(fp, base):
+                files.append(fp)
+        
+        # Sort files by POSIX relative path for absolute determinism.
+        # This ensures 'restored_site/a.txt' and 'MockProject/a.txt' 
+        # both use 'a.txt' as the key.
+        sorted_files = sorted(files, key=lambda x: x.relative_to(base).as_posix())
+        
+        if debug:
+            print(f"\n--- Hashing Debug for Root: {base.name} ---")
+
+        for fp in sorted_files:
+            try:
+                # Force forward slashes and ensure the root name isn't part of this string
+                rel_path_string = fp.relative_to(base).as_posix()
+                
+                if debug:
+                    print(f"Hashing Path: {rel_path_string}")
+                
+                # Update hash with the path
+                hasher.update(rel_path_string.encode('utf-8'))
+                
+                # Update hash with the content
+                with open(fp, 'rb') as f:
+                    while chunk := f.read(8192):
+                        hasher.update(chunk)
+            except (PermissionError, OSError) as e:
+                if debug:
+                    print(f"Skipping {fp}: {e}")
+                continue
+                
+        return hasher.hexdigest()
+
+    def build_hierarchy(self, root_path, current_path=None, indent="", is_last=True, prefix=""):
+        """
+        Recursively builds a visual tree string of the directory structure.
+        """
+        if current_path is None:
+            current_path = Path(root_path)
+            root_path = current_path 
+        
+        path = Path(current_path)
+        
+        if self._is_excluded(path, root_path) and prefix != "":
+            return ""
+
+        if prefix == "":
+            output = f"{path.name}/\n"
+        else:
+            output = f"{indent}{prefix} {path.name}{'/' if path.is_dir() else ''}\n"
+
+        if path.is_dir():
+            try:
+                items = [item for item in path.iterdir() if not self._is_excluded(item, root_path)]
+                items.sort(key=lambda x: (not x.is_dir(), x.name.lower()))
+            except PermissionError:
+                return f"{indent}{prefix} [Permission Denied]\n"
+
+            for i, item in enumerate(items):
+                last_item = (i == len(items) - 1)
+                new_prefix = "└──" if last_item else "├──"
+                new_indent = indent + ("    " if is_last else "│   ")
+                pass_indent = "" if prefix == "" else new_indent
+                output += self.build_hierarchy(root_path, item, pass_indent, last_item, new_prefix)
+                    
+        return output

codepacker-12.6.0/src/codepacker.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: codepacker
+Version: 12.6.0
+Summary: Enhanced Updates.
+Author: BMI-MoonspicAI
+Description-Content-Type: text/markdown
+
+# Moonspic Codepacker

codepacker-12.6.0/src/codepacker.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/codepacker/GUI.py
+src/codepacker/__init__.py
+src/codepacker/codeServices.py
+src/codepacker/core.py
+src/codepacker/tests.py
+src/codepacker/utils.py
+src/codepacker.egg-info/PKG-INFO
+src/codepacker.egg-info/SOURCES.txt
+src/codepacker.egg-info/dependency_links.txt
+src/codepacker.egg-info/entry_points.txt
+src/codepacker.egg-info/top_level.txt

codepacker-12.6.0/src/codepacker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

codepacker-12.6.0/src/codepacker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codepacker-gui = codepacker.GUI:start

codepacker-12.6.0/src/codepacker.egg-info/top_level.txt

@@ -0,0 +1 @@
+codepacker